blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 905
values | visit_date timestamp[us]date 2015-08-09 11:21:18 2023-09-06 10:45:07 | revision_date timestamp[us]date 1997-09-14 05:04:47 2023-09-17 19:19:19 | committer_date timestamp[us]date 1997-09-14 05:04:47 2023-09-06 06:22:19 | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 22
values | gha_event_created_at timestamp[us]date 2012-06-07 00:51:45 2023-09-14 21:58:39 ⌀ | gha_created_at timestamp[us]date 2008-03-27 23:40:48 2023-08-21 23:17:38 ⌀ | gha_language stringclasses 141
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 10.4M | extension stringclasses 115
values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
7abe123d23f7926a6ff4a4f47d5550722887874e | 891dcf3050a62b093c310269c9932ef8e5f83cdf | /Tests/TestUtils.cpp | 0ecc8c2159c6d6b0c6900ca284f95254aca0e9e2 | [] | no_license | Loreas/Tram_SECSPEC | 0614db7ea08e6fdea75e588e5bf347a57539f51d | 3ae9d5d8d415f2fa9fb3a62f611399845f0fff2b | refs/heads/master | 2021-01-20T09:42:42.327223 | 2017-06-21T10:34:34 | 2017-06-21T10:34:34 | 90,278,022 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,648 | cpp | // TicTacToeUtils:
// Copyright: Project Software Engineering - BA1 informatica - Serge Demeyer -
// University of Antwerp
#include <iostream>
#include <fstream>
#include <sys/stat.h>
using namespace std;
#include "TestUtils.h"
/**
Auxiliary functions for file manipulation.
*/
bool DirectoryExists(const std::string dirname) {
struct stat st;
return stat(dirname.c_str(), &st) == 0;
}
bool FileExists(const std::string filename) {
struct stat st;
if (stat(filename.c_str(), &st) != 0) return false;
ifstream f(filename);
if (f.good()) {
f.close();
return true;
} else {
f.close();
return false;
}
}
bool FileIsEmpty(const std::string filename) {
struct stat st;
if (stat(filename.c_str(), &st) != 0) return true; // File does not exist; thus it is empty
return st.st_size == 0;
}
bool FileCompare(const std::string leftFileName, const std::string rightFileName) {
ifstream leftFile, rightFile;
char leftRead, rightRead;
bool result;
// Open the two files.
leftFile.open(leftFileName);
if (!leftFile.is_open()) {
return false;
};
rightFile.open(rightFileName);
if (!rightFile.is_open()) {
leftFile.close();
return false;
};
result = true; // files exist and are open; assume equality unless a counterexamples shows up.
while (result && leftFile.good() && rightFile.good()) {
leftFile.get(leftRead);
rightFile.get(rightRead);
result = (leftRead == rightRead);
};
if (result) {
// last read was still equal; are we at the end of both files ?
result = (!leftFile.good()) && (!rightFile.good());
};
leftFile.close();
rightFile.close();
return result;
}
| [
"loreas.clonen@student.uantwerpen.be"
] | loreas.clonen@student.uantwerpen.be |
43b07b4cfaf3f8c8a8aa9ef3837bf3f48258d214 | 72a4cacb817094a01bb7f49f09207b34b85b30ae | /Languages1/lexem.cpp | 1d1f6defb36f046c9646808539f98d95acfa4d3d | [] | no_license | Poletayson/LanguagesTLP | 8ae627b9eeb93e97f242786e13fdc7c6bef6f94c | eeffce6506ea319cd9c419df9b92070a5bcdd944 | refs/heads/master | 2020-04-29T07:04:10.659853 | 2019-03-17T20:00:21 | 2019-03-17T20:00:21 | 175,939,694 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 169 | cpp | #include "lexem.h"
Lexem::Lexem()
{
}
Lexem::Lexem(int t, QString i)
{
image = i;
type = t;
}
void Lexem::setPosInProgram (int p)
{
posInProgram = p;
}
| [
"dmitriipoletaev_1997@mail.ru"
] | dmitriipoletaev_1997@mail.ru |
83a00d1e6905922985f13e40ca674f352e36410e | 60bb67415a192d0c421719de7822c1819d5ba7ac | /blazetest/src/mathtest/dvecdvecouter/V2aV3b.cpp | 045bd867f4306a2d2eae0ce2727999be2e53aeeb | [
"BSD-3-Clause"
] | permissive | rtohid/blaze | 48decd51395d912730add9bc0d19e617ecae8624 | 7852d9e22aeb89b907cb878c28d6ca75e5528431 | refs/heads/master | 2020-04-16T16:48:03.915504 | 2018-12-19T20:29:42 | 2018-12-19T20:29:42 | 165,750,036 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,668 | cpp | //=================================================================================================
/*!
// \file src/mathtest/dvecdvecouter/V2aV3b.cpp
// \brief Source file for the V2aV3b dense vector/dense vector outer product math test
//
// Copyright (C) 2012-2018 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or modify it under
// the terms of the New (Revised) BSD License. Redistribution and use in source and binary
// forms, with or without modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other materials
// provided with the distribution.
// 3. Neither the names of the Blaze development group nor the names of its contributors
// may be used to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
// SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
*/
//=================================================================================================
//*************************************************************************************************
// Includes
//*************************************************************************************************
#include <cstdlib>
#include <iostream>
#include <blaze/math/StaticVector.h>
#include <blazetest/mathtest/Creator.h>
#include <blazetest/mathtest/dvecdvecouter/OperationTest.h>
#include <blazetest/system/MathTest.h>
//=================================================================================================
//
// MAIN FUNCTION
//
//=================================================================================================
//*************************************************************************************************
int main()
{
std::cout << " Running 'V2aV3b'..." << std::endl;
using blazetest::mathtest::TypeA;
using blazetest::mathtest::TypeB;
try
{
// Vector type definitions
using V2a = blaze::StaticVector<TypeA,2UL>;
using V3b = blaze::StaticVector<TypeB,3UL>;
// Creator type definitions
using CV2a = blazetest::Creator<V2a>;
using CV3b = blazetest::Creator<V3b>;
// Running the tests
RUN_DVECDVECOUTER_OPERATION_TEST( CV2a(), CV3b() );
}
catch( std::exception& ex ) {
std::cerr << "\n\n ERROR DETECTED during dense vector/dense vector outer product:\n"
<< ex.what() << "\n";
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
//*************************************************************************************************
| [
"klaus.iglberger@gmail.com"
] | klaus.iglberger@gmail.com |
4466cd21411ef74e5951e1d055470148f8c7c903 | d7ea55748b53cf98b9b3c63e6e7babec997db156 | /QT5/02. QT_C++/01_BasicWidget/build-QCheckBox-Desktop_Qt_5_14_1_GCC_64bit-Debug/qrc_resources.cpp | c4987086dc0f7d517d945e46dffd22cd8164d99d | [] | no_license | maerad7/AIPortfolio | 337f15d04ffe361dc0708d53ab24f46c6b896941 | 11544d19e33c328104e8480c1cb78f2e8dc7af20 | refs/heads/master | 2021-06-20T16:17:16.611431 | 2021-01-09T07:47:04 | 2021-01-09T07:47:04 | 158,547,230 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 144,101 | cpp | /****************************************************************************
** Resource object code
**
** Created by: The Resource Compiler for Qt version 5.14.1
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
static const unsigned char qt_resource_data[] = {
// /home/newdrone18/workspace/qtbook-master/20.02.27_Qt_Programming_Korean_v1.4_Example_Source_code/Ch03/01_BasicWidget/01_QCheckBox/resources/editor.png
0x0,0x0,0x12,0x8a,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x46,0x0,0x0,0x0,0x40,0x8,0x6,0x0,0x0,0x0,0xa7,0x77,0x1,0x99,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0x13,0xb0,0x0,0x0,0x13,0xb0,
0x1,0x5c,0x3c,0x30,0x13,0x0,0x0,0x0,0x19,0x74,0x45,0x58,0x74,0x53,0x6f,0x66,
0x74,0x77,0x61,0x72,0x65,0x0,0x77,0x77,0x77,0x2e,0x69,0x6e,0x6b,0x73,0x63,0x61,
0x70,0x65,0x2e,0x6f,0x72,0x67,0x9b,0xee,0x3c,0x1a,0x0,0x0,0x12,0x7,0x49,0x44,
0x41,0x54,0x78,0x9c,0xd5,0x9b,0x79,0x70,0xdc,0x47,0x95,0xc7,0x3f,0xfd,0x3b,0xe6,
0x37,0x33,0x3a,0x3d,0x3a,0x6c,0xeb,0xf0,0xad,0x44,0x96,0xef,0x23,0xe,0x86,0x38,
0xc6,0xb8,0x42,0x82,0x13,0x42,0x36,0x6c,0xd8,0x84,0x33,0xcb,0xe1,0x14,0x5,0x14,
0x22,0x59,0xe2,0x2d,0xb6,0x96,0xd,0x5b,0xbb,0x14,0xae,0x65,0xc1,0xc4,0x4a,0x8,
0x47,0xa8,0x2c,0x54,0x20,0x95,0xc4,0xb,0x2c,0x10,0xc,0xe4,0xc4,0x61,0xbd,0x5e,
0x2,0x71,0x79,0x1d,0x3b,0xc6,0xb2,0x6c,0xc5,0x87,0x6e,0x69,0x46,0x33,0x9a,0xd1,
0x6f,0x7e,0xbf,0x5f,0xf7,0xfe,0x31,0x87,0x67,0x46,0xa3,0xcb,0x96,0xe3,0xf8,0x95,
0xba,0x7e,0xa3,0x9e,0xd7,0xaf,0xdf,0xfb,0xce,0xeb,0xd7,0xdd,0xaf,0xfb,0x27,0x94,
0x52,0x4c,0x97,0x76,0xb6,0x8a,0xcf,0x69,0x9a,0xf8,0x12,0x70,0x56,0x4a,0xf5,0x85,
0x1d,0xbb,0xd4,0xbe,0x9d,0xad,0xc2,0xf,0x3c,0x2c,0x84,0xb8,0x3,0xd4,0x6f,0x94,
0xe2,0xd3,0x3b,0x76,0xa9,0xbe,0x9d,0xad,0x62,0x99,0xa6,0x89,0x36,0x60,0xa5,0x94,
0xea,0xa1,0x1d,0xbb,0xd4,0x97,0xd3,0x32,0xee,0xd2,0x34,0xf1,0x55,0x20,0x29,0xa5,
0xba,0x7f,0xc7,0x2e,0xf5,0xf3,0x9d,0xad,0x42,0x0,0x5f,0x17,0x9a,0xf8,0x4,0x8a,
0x3,0x4a,0xa9,0xcf,0xec,0xd8,0xa5,0xda,0x77,0xb6,0x8a,0x46,0x21,0xc4,0xb7,0x81,
0xcd,0x4a,0xa9,0x1f,0x1,0x9f,0xdd,0xb1,0x4b,0xc9,0x9d,0xad,0xe2,0x46,0x4d,0x13,
0x5f,0x7,0x2a,0xa4,0x54,0xf,0xec,0xd8,0xa5,0x7e,0x90,0x96,0xfd,0x25,0x4d,0x13,
0xf7,0x2,0xc7,0xa4,0x54,0x9f,0xdf,0xb1,0x4b,0xbd,0x32,0x5d,0x1b,0xb5,0xb,0x0,
0x65,0xb6,0x10,0x7c,0x63,0xfe,0x82,0x9a,0x39,0xe5,0xe5,0xc1,0x35,0x9a,0x26,0x76,
0xa5,0xbf,0xfa,0x0,0xf0,0xb7,0x2b,0xd7,0xcc,0x2f,0xd5,0x34,0xed,0x36,0xe0,0xd3,
0x0,0x42,0xf0,0x80,0x65,0x99,0x9b,0x9a,0xae,0xae,0xb,0x1,0xff,0xb8,0xb3,0x55,
0xac,0xdd,0xd9,0x2a,0x2,0x9a,0x26,0xbe,0x3d,0xb7,0x6e,0xd6,0xfc,0xda,0xd9,0x15,
0x4d,0x9a,0x26,0x1e,0xd9,0xd9,0x2a,0x74,0x60,0xb,0x70,0xef,0xd2,0x96,0x86,0xa,
0xd3,0xd4,0xb7,0x2,0xf7,0xa7,0x65,0x7f,0x41,0xd7,0xb5,0x9b,0x96,0xaf,0x6c,0x2c,
0x4d,0xcb,0x7d,0xef,0xce,0x56,0x21,0x34,0x4d,0x3c,0x3c,0xab,0xaa,0x74,0x59,0x7d,
0x43,0x55,0x83,0x10,0xe2,0xa1,0x9d,0xad,0xa2,0x6c,0x67,0xab,0xb8,0x1a,0xf8,0x97,
0x85,0x8b,0x66,0x57,0x95,0x94,0xfa,0xaf,0x15,0x42,0x7c,0x6d,0xba,0x36,0x4e,0x1b,
0x98,0x7,0x1f,0x7c,0x70,0x9e,0x1e,0x6c,0xb9,0x55,0x29,0x8c,0xcd,0x5b,0x97,0xb3,
0x7a,0xdd,0x2,0x4d,0x4a,0xb5,0xb6,0xad,0xad,0xad,0x59,0x18,0x95,0x5b,0x2b,0x2a,
0x82,0xee,0xd,0x37,0xad,0xa2,0x61,0x5e,0x95,0x2e,0xb4,0xe0,0xf5,0x6d,0x6d,0x6d,
0xcd,0x9a,0x66,0x5c,0xdf,0xbc,0xac,0x5e,0xbf,0xe9,0x96,0x35,0xa9,0xe,0xad,0xfa,
0x5b,0xcd,0xca,0xad,0x5b,0xa4,0x54,0x15,0xef,0xb8,0xbe,0x59,0x6c,0xd8,0xd8,0x24,
0xa4,0x54,0x73,0xac,0xda,0x3b,0x37,0x6a,0x66,0xed,0xcd,0x9a,0xa6,0xa9,0x6d,0xb7,
0xae,0x65,0xc9,0x55,0x73,0x75,0x5d,0xf7,0x6d,0x69,0x6b,0x6b,0x6b,0xd6,0xd,0xff,
0xe6,0x85,0x8b,0x6b,0xf5,0x1b,0x6f,0x5e,0x83,0xe5,0x37,0x3d,0x61,0x84,0x6e,0xf1,
0xcf,0xbd,0x67,0xbd,0x94,0x6a,0xd1,0xfa,0xd,0x8b,0xc5,0x75,0xef,0x5c,0x2a,0x94,
0x52,0x7e,0xa3,0xec,0x9a,0x6d,0xba,0x7f,0xd1,0xcd,0x80,0xb8,0xf1,0xe6,0xd5,0x2c,
0x5b,0xd1,0xa8,0xb,0x21,0x36,0xb6,0xb5,0xb5,0x35,0xef,0xde,0xbd,0xbb,0x7c,0x3a,
0xb6,0x1a,0x53,0x61,0x7a,0xe8,0xa1,0x87,0x6e,0x10,0x42,0x7c,0x43,0xd3,0xb4,0xe5,
0x66,0xe5,0x66,0xbc,0xf8,0x11,0x34,0x4d,0x20,0x84,0xc8,0xb0,0x1c,0x35,0x4a,0x57,
0x23,0xc4,0x9f,0x0,0x10,0x42,0xa0,0x5,0x96,0x6c,0x5,0x8e,0xa2,0x97,0x21,0xc4,
0x79,0x5e,0xb3,0xfc,0xba,0x7f,0xd2,0x2,0x4d,0x38,0xe1,0xe7,0x52,0x7c,0x5a,0xaa,
0x5e,0x2f,0x59,0xb1,0x4f,0x79,0x71,0xdc,0xf0,0xaf,0xd2,0x32,0x40,0x98,0xd5,0x4b,
0x80,0xa3,0xc2,0x57,0x8f,0xae,0x8f,0xa6,0x80,0xd5,0x74,0xdd,0x28,0x5b,0xf7,0x49,
0x2d,0xb0,0xf8,0x93,0xd9,0xbe,0x32,0xb2,0x2b,0xae,0x7f,0x42,0xba,0x3,0x78,0xdd,
0x1d,0xe8,0xba,0x96,0x92,0x2d,0x7c,0x41,0xe0,0xa8,0xa6,0x69,0xc9,0xb6,0xb6,0xb6,
0x5f,0xfa,0x7c,0xbe,0x8f,0x6f,0xdf,0xbe,0x3d,0x32,0x99,0xcd,0x93,0x7a,0xcc,0x53,
0x4f,0x3d,0xa5,0xb,0x21,0xbe,0x33,0x67,0xce,0xec,0x65,0x1b,0xae,0xbd,0x86,0xab,
0xaf,0xbe,0x7a,0xc,0xcf,0x35,0x1b,0xd6,0x31,0x7b,0x76,0x6d,0x2e,0x50,0xcc,0xaa,
0xac,0x60,0xdd,0xfa,0xb5,0xf8,0x4c,0x33,0x8f,0xb7,0x71,0x7e,0x23,0x2d,0xcb,0x96,
0x8e,0x91,0xb1,0x7c,0xf9,0x32,0xea,0xea,0xe6,0x22,0x72,0xea,0xfc,0x7e,0x8b,0x55,
0xab,0x57,0x50,0x52,0x12,0xcc,0xa9,0x15,0xd4,0xd4,0x56,0x17,0x95,0xb1,0x68,0xd1,
0x2,0x1a,0x1a,0x1a,0xf2,0xd,0xd4,0x34,0x5a,0x96,0x2d,0x65,0xf1,0x92,0x45,0x3e,
0x21,0xb8,0x2d,0x99,0x4c,0x7e,0x7a,0x32,0x9b,0x61,0xa,0xc0,0xf4,0xf6,0xf6,0x36,
0x4b,0x29,0x17,0x36,0x34,0xd4,0xb,0xa5,0x24,0x76,0x72,0x74,0xc,0x4f,0x3c,0x1e,
0xc7,0x75,0xdd,0xbc,0x3a,0xd7,0xf3,0x88,0xc7,0x47,0x28,0xc,0xee,0x49,0xdb,0x26,
0x91,0x88,0x8f,0x91,0x31,0x12,0x1f,0xc1,0x4e,0xda,0x79,0x75,0x52,0x4a,0x62,0xb1,
0x18,0x9e,0x94,0x79,0xf5,0x4e,0x32,0xc9,0xc8,0x48,0x6c,0xac,0x1e,0x89,0x38,0xa3,
0x76,0x22,0xaf,0x4e,0xa1,0x88,0x8d,0x44,0x31,0x4d,0x93,0xc6,0x79,0x8d,0x5a,0x3a,
0xfe,0x4d,0x4a,0x93,0xe,0x25,0x29,0x65,0xb5,0x10,0x2,0x5d,0xd7,0x19,0x1c,0x1c,
0xa0,0xaf,0x3f,0xe5,0x85,0xe1,0xf0,0x8,0x91,0x70,0x1c,0x4d,0xf7,0x71,0xaa,0xf3,
0x24,0xb1,0x58,0x2,0x2f,0x6e,0x63,0x8f,0x3a,0x44,0x87,0x6d,0x12,0xae,0xc3,0xc9,
0x93,0x1d,0x78,0x4a,0x27,0x12,0x8e,0x13,0x1e,0x1a,0x1,0xa0,0x7f,0x70,0x98,0xf0,
0x68,0x37,0x0,0x91,0x48,0x1c,0x7b,0xd4,0x1,0xa0,0xf3,0x8d,0xd3,0x38,0x91,0x18,
0x52,0x4a,0x86,0x23,0x71,0x22,0x91,0x4,0xb6,0x53,0x4a,0xfb,0x89,0xe3,0xd8,0xa3,
0x1e,0x43,0x83,0x71,0xe2,0x23,0x36,0x49,0x3b,0xc9,0x50,0x78,0x84,0xe1,0x8e,0x53,
0x8,0xa1,0x11,0x9,0xc7,0xd1,0xf5,0xd4,0xef,0xfb,0xc6,0xd9,0x6e,0x94,0x33,0x0,
0xc0,0x40,0x7f,0x94,0x48,0x38,0x8e,0x52,0x6,0xaf,0xbf,0x7e,0x94,0xd5,0xab,0xd6,
0x60,0x59,0x16,0x42,0x88,0x9a,0x19,0x1,0x46,0xd3,0xb4,0x90,0x52,0xa,0xa1,0x9,
0x3c,0x29,0xf1,0x95,0x2e,0xc1,0xb0,0x42,0xfc,0xf4,0xc9,0x3,0x28,0xa5,0x8,0x54,
0x5d,0xf,0x80,0xbf,0x72,0x3,0x83,0x3d,0xbf,0x66,0xf7,0x37,0x9e,0x1,0xa0,0x7c,
0xc1,0x6,0x0,0xcc,0xf2,0x6b,0x39,0x71,0xfc,0xe7,0x74,0xb4,0xf7,0xa0,0xe9,0x16,
0x66,0xf9,0x4a,0x84,0xf0,0x63,0x6,0x17,0xb2,0xf7,0x97,0xaf,0xa6,0x78,0x4a,0x5b,
0x10,0x7a,0x10,0xb3,0x6c,0x35,0xc9,0xbe,0x9f,0xf2,0xbd,0x87,0x9f,0x45,0x29,0x85,
0xaf,0xf6,0x9d,0x0,0xe8,0xa5,0x6b,0xe9,0xe9,0xfe,0x31,0xf,0x7f,0x6b,0x2f,0x20,
0xf0,0x95,0xad,0x5,0x61,0x22,0x82,0xcb,0xd9,0xff,0xf2,0xa1,0x94,0x9e,0xd6,0x6c,
0x84,0x39,0x7,0xf4,0x10,0x42,0xf,0xf2,0xe3,0x1f,0xee,0x4b,0x19,0x50,0xb6,0x9,
0x1,0xb8,0x9e,0x8b,0x61,0xf8,0x50,0x4a,0xcd,0x9a,0x11,0x60,0x94,0x52,0xa1,0xcc,
0x67,0xcf,0xf3,0x0,0x41,0xd5,0xd2,0xaf,0x90,0x18,0xd8,0x8f,0x66,0x56,0x62,0x95,
0xaf,0x46,0x1,0x46,0xa0,0x81,0x50,0xf3,0x3f,0x63,0x87,0xff,0x8c,0x59,0xd6,0x82,
0x11,0x98,0x9f,0x2,0xae,0xf6,0x26,0xf4,0xc0,0x2,0xbc,0xd1,0xd3,0x98,0x15,0x1b,
0x10,0x9a,0x1f,0x14,0x4,0xe6,0x7d,0xe,0x23,0xf2,0xa,0x8,0x1d,0xb3,0x6c,0xd,
0xa,0x10,0x46,0x39,0xc1,0x45,0x5f,0xc6,0x89,0xbc,0x82,0x16,0x98,0x8f,0xe6,0x5f,
0x9c,0x2,0xa6,0x6c,0x3d,0x96,0x59,0x8d,0x17,0x6f,0x47,0x2f,0x59,0xd,0x46,0x8,
0x14,0x18,0x35,0x1f,0x44,0x6,0x57,0xa2,0x64,0x1c,0x11,0x5c,0x95,0x52,0x52,0x98,
0x68,0x73,0xee,0x45,0x8e,0xfc,0x19,0xcc,0x5a,0xb0,0x9a,0x52,0xba,0xbb,0x1e,0x96,
0x4f,0x43,0x29,0x55,0x36,0x15,0x60,0xc4,0x64,0xb,0xbc,0xdd,0xbb,0x77,0x7f,0xd1,
0x34,0xcd,0x9d,0xeb,0xd7,0xaf,0x15,0xdd,0x3d,0x5d,0x44,0x22,0x91,0xc,0x60,0x28,
0x14,0xa9,0xbf,0xf4,0x33,0x2d,0x6b,0xa2,0xe7,0x98,0x36,0x13,0x3c,0x8b,0xca,0x99,
0xe,0x6f,0xce,0x73,0xc9,0xe2,0x26,0xca,0xcb,0x2b,0x78,0xed,0xf0,0x11,0xe2,0xf1,
0x78,0xf9,0xfd,0xf7,0xdf,0x1f,0x9d,0xc8,0xee,0x49,0x3d,0x46,0x8,0x11,0xa,0x6,
0x83,0x5e,0x6d,0xed,0x6c,0x63,0xcd,0x9a,0x75,0x79,0x33,0x4f,0x21,0x4d,0x75,0x15,
0x7d,0xb9,0xf8,0x4e,0x9e,0xea,0xe0,0xb5,0xc3,0x47,0x28,0x29,0x29,0x9,0x1,0x17,
0x7,0xc,0x10,0xa,0x4,0x2,0x34,0x34,0x34,0x4e,0x5b,0x91,0xb7,0x12,0x9f,0xa6,
0x69,0x54,0x57,0xa5,0xe2,0xae,0x94,0x32,0x4,0x74,0x4e,0x24,0x63,0xaa,0x1e,0x23,
0x26,0x52,0xec,0xad,0x4,0xc0,0x78,0x7c,0x4a,0x29,0xc,0x23,0x65,0xae,0xa6,0x69,
0xa1,0x49,0x9a,0x4c,0xc9,0x63,0xaa,0x83,0xc1,0xa0,0x3e,0x5d,0x45,0xde,0x8a,0x7c,
0x66,0x7a,0xb1,0x99,0x3b,0xa1,0x8c,0x47,0x53,0xf1,0x98,0x1a,0xbf,0xdf,0x3f,0xa6,
0xfe,0xd0,0xa1,0x43,0xc4,0xe3,0x63,0x17,0x6a,0xc5,0xe8,0x42,0x76,0xf0,0x33,0x21,
0xaf,0xae,0xae,0x8e,0xfa,0xfa,0xfa,0x6c,0x1b,0xc3,0x30,0x10,0x42,0xa0,0x94,0xaa,
0x9a,0xac,0xed,0x94,0x86,0x92,0xdf,0xef,0xcf,0xba,0x63,0x86,0x2c,0xcb,0x1a,0xa3,
0xe0,0xe5,0xf2,0x94,0xf1,0xc8,0xcc,0xd9,0x8e,0x28,0xa5,0x10,0x42,0x60,0x59,0x96,
0x97,0x48,0x24,0x2e,0xde,0x63,0xa4,0x94,0x95,0x96,0x65,0xe5,0xd5,0x29,0xa5,0x68,
0x6a,0x6a,0x9a,0x54,0xb1,0xb7,0xc2,0x90,0x2a,0x6c,0x13,0x8,0x4,0xa4,0x6d,0xdb,
0x17,0x7,0xcc,0x77,0xbf,0xfb,0x5d,0x53,0x29,0x15,0xc8,0x78,0xc7,0x95,0x1c,0x7c,
0x33,0x14,0xc,0x6,0xc5,0xd0,0xd0,0xd0,0xc5,0x1,0x93,0x48,0x24,0x42,0xba,0xae,
0xe3,0xf3,0xf9,0xc6,0x0,0xd3,0xd9,0xd9,0x49,0x32,0x99,0x9c,0x31,0x85,0x67,0x82,
0xaf,0x90,0x42,0xa1,0x10,0xa1,0x50,0x3e,0x6,0xc1,0x60,0x50,0x17,0x42,0x5c,0x1c,
0x30,0xa6,0x69,0x86,0xa4,0x94,0xf8,0x7c,0xbe,0x31,0xdf,0xf5,0xf5,0xf5,0x91,0x48,
0x24,0x8a,0xb4,0x1a,0x4b,0x6f,0x56,0x4c,0x29,0x24,0xd3,0x34,0x99,0x35,0x6b,0x56,
0x56,0xb6,0x52,0xa,0xcb,0xb2,0x4,0x50,0x3b,0x59,0xdb,0x9,0x81,0x49,0x2f,0x84,
0x30,0x4d,0x73,0x8c,0xc7,0xac,0x5b,0xb7,0x2e,0x8f,0x77,0x3a,0x46,0x5d,0x4e,0x8f,
0x4a,0xef,0xb0,0xab,0xef,0xde,0x5a,0xb9,0xd8,0x95,0xee,0x46,0xa1,0x31,0x7,0x29,
0x5e,0xb1,0x6b,0x62,0xfb,0x9e,0x7c,0x52,0x79,0x19,0xbe,0x9,0x81,0x51,0x4a,0x85,
0x84,0x10,0x63,0xa2,0xfb,0x4c,0x2a,0xfb,0x66,0x2,0xaa,0x94,0x22,0xd2,0x77,0x8a,
0x63,0x7f,0xf8,0xc1,0x7c,0x4f,0x79,0xc7,0x35,0x4d,0x13,0x25,0x81,0x52,0x15,0x8b,
0x47,0x85,0xbf,0xbf,0xe4,0xc0,0x5d,0x9b,0x83,0x77,0xfc,0xe4,0xa5,0xf8,0x69,0x98,
0x4,0x98,0x4c,0xca,0xc1,0x30,0x8c,0x31,0x1e,0x13,0x8d,0x46,0x91,0x52,0x5e,0xb4,
0xb2,0x86,0x61,0x50,0x52,0x52,0x32,0x29,0xdf,0x74,0x64,0x16,0xe3,0x3b,0x71,0xf4,
0x8f,0xfc,0xf6,0xe9,0x6f,0x71,0xf8,0x4f,0x2f,0xb0,0x68,0xde,0x7c,0xdf,0x67,0x3f,
0x76,0x1f,0x8b,0x3,0x57,0xa1,0xd,0x45,0x45,0xb8,0xf7,0x75,0xbe,0x7a,0xe0,0x89,
0x75,0xdd,0x89,0xd8,0x2f,0xb6,0x6c,0x11,0xeb,0x5f,0x78,0x41,0xb9,0x93,0x7a,0x8c,
0xae,0xeb,0xca,0x30,0xc,0xe1,0x79,0x5e,0x9e,0x22,0xe3,0x2d,0xf0,0xa6,0xb,0x54,
0x4d,0x4d,0xd,0xab,0x56,0xad,0x9a,0x94,0x6f,0x3a,0x32,0x73,0xe9,0xd8,0xa1,0x97,
0xd9,0xfb,0xe4,0x37,0xf9,0xcb,0xe1,0xff,0xa1,0x79,0xc1,0x22,0xbe,0xf2,0x91,0x2f,
0xb0,0xd0,0xd7,0x84,0x18,0xc,0xc3,0xc9,0xbf,0xc0,0xc0,0x0,0x95,0x3,0x3,0x7c,
0x31,0xb8,0xc4,0xb8,0x37,0x7e,0x70,0x55,0x83,0x28,0x7d,0x1f,0xb0,0x67,0x42,0x60,
0xd2,0x8b,0x3b,0x4f,0x29,0x65,0x14,0x76,0xba,0x72,0xe5,0xca,0x29,0x29,0x3d,0x19,
0x8f,0xae,0xeb,0x53,0xe2,0x9b,0xaa,0xbc,0xc,0xfd,0xdf,0x1f,0x9f,0x65,0xef,0x93,
0xff,0xce,0xa9,0xe3,0x87,0xd8,0xb0,0x76,0x13,0xad,0xf7,0x3d,0x8a,0xa5,0x97,0x13,
0xe8,0xed,0x85,0xd7,0x8e,0xc2,0xc0,0xc0,0xf9,0x32,0x38,0x48,0xd5,0xe0,0x20,0xe5,
0x8b,0x35,0x39,0x2c,0xbc,0x6,0x98,0x42,0x8c,0x9,0x6,0x83,0x2a,0xa3,0x50,0xae,
0x52,0xb9,0xee,0x7f,0xb1,0x86,0x4d,0xb5,0x6e,0x32,0x79,0x4a,0x29,0xe,0xee,0x7f,
0x86,0xbd,0x4f,0x7e,0x93,0xb3,0x9d,0xaf,0xb3,0xb0,0x61,0x36,0x9f,0xbf,0xe7,0x1,
0x12,0x73,0xd6,0x31,0x22,0x34,0x86,0x3d,0x8f,0x9e,0xfa,0x7a,0x22,0x7d,0x7d,0x34,
0xbf,0xf4,0x12,0xc,0xc,0x60,0xc7,0x62,0x44,0x3c,0x8f,0x88,0xe7,0x51,0xe5,0xa,
0x19,0x35,0x99,0x3,0x93,0xaf,0x7c,0x43,0xc1,0x60,0x30,0x2f,0x61,0xfe,0x56,0x58,
0xa4,0x15,0x92,0x94,0x1e,0xaf,0xfc,0xfe,0x67,0xfc,0xe6,0xe9,0x5d,0xf4,0x9c,0x3d,
0x49,0xd3,0xc2,0x3a,0x3e,0xf5,0xc1,0xf7,0xd0,0xd8,0x38,0xf,0xe8,0x82,0xe8,0x73,
0x74,0x8b,0x6b,0xb1,0x7d,0x16,0x52,0x4a,0x4e,0xb6,0xb4,0x50,0xfb,0xe8,0xa3,0x24,
0xc2,0xe1,0x2c,0x28,0x11,0x5d,0x72,0xce,0xef,0x9,0x25,0x85,0x84,0x49,0x80,0x11,
0x42,0x54,0xf9,0xfd,0x7e,0x3d,0xe3,0x2d,0x33,0xf5,0xcb,0xce,0x14,0x9f,0xe7,0x3a,
0x1c,0x78,0xe1,0x69,0x7e,0xbb,0xe7,0x41,0x6,0x7a,0xcf,0xd0,0xd2,0xd4,0xc8,0xed,
0x1f,0xbd,0x85,0xb9,0x73,0xeb,0xf3,0x78,0x3d,0xd5,0x43,0xc5,0xa9,0xa7,0x89,0x2c,
0xb9,0x13,0xcf,0xf3,0x90,0x52,0x72,0xbc,0xa6,0x6,0xbb,0xab,0x8b,0x88,0xe7,0x31,
0x6c,0x28,0x4e,0x2c,0xd7,0x95,0x2d,0x91,0x9a,0xf0,0x1e,0x86,0xc9,0x81,0xa9,0x9,
0x4,0x2,0x40,0xea,0x28,0x63,0xa6,0xd,0xbb,0x50,0x3e,0xd7,0xb1,0xf9,0xef,0x67,
0x7f,0xc2,0xef,0xf6,0xb4,0x11,0x1e,0xec,0x61,0x55,0xcb,0x2,0xee,0xba,0xe5,0xaf,
0xa8,0xad,0xc9,0x5f,0xb7,0xb9,0xa3,0x83,0x24,0xfa,0x8f,0x91,0x8c,0x75,0x83,0x13,
0xc4,0x75,0xff,0x3a,0xb,0xcc,0xd9,0xee,0x6e,0xa2,0x24,0x89,0xb6,0x98,0x1c,0x2e,
0x91,0x5e,0x5c,0xb8,0x36,0x52,0xff,0xc0,0x7f,0x3c,0x17,0x3d,0xb,0x93,0xf,0xa5,
0xaa,0xc2,0xd,0x64,0x86,0xe2,0xf1,0xf8,0x8c,0x4,0xdf,0xe9,0xf0,0x25,0xed,0x4,
0xfb,0x9f,0x7d,0x9c,0xdf,0xff,0xea,0x51,0xe2,0xb1,0x30,0x6b,0x57,0x2c,0xe6,0x1d,
0xef,0xdf,0x44,0x55,0x28,0x3f,0x8b,0xe0,0xc4,0x7b,0x49,0xf4,0x1f,0xc3,0x89,0xf7,
0x9f,0xaf,0x34,0xe3,0xb8,0xb1,0x18,0xd2,0xe7,0xc3,0x3d,0x73,0x9a,0xd3,0x95,0x5d,
0xbc,0x56,0x2f,0x3c,0x57,0x78,0x42,0x28,0xf6,0xe0,0x8a,0x7,0x7e,0xf4,0x52,0xe4,
0x68,0x86,0x7d,0xb2,0xe0,0x3b,0x6b,0xbc,0xd,0xe4,0xc1,0x83,0x7,0xf3,0xa6,0xeb,
0x4b,0xb9,0xec,0x77,0x92,0x9,0x3a,0xe,0xfd,0x8e,0x13,0x7,0xf7,0xe2,0x39,0xa3,
0x5c,0xb3,0xba,0x89,0xb7,0x6f,0x78,0x37,0x95,0x15,0x15,0xb9,0x92,0x49,0x46,0xbb,
0x48,0xc,0x1c,0xc3,0x1d,0xd,0xe7,0xb5,0x4f,0x24,0x15,0x27,0xbb,0x5d,0x2c,0x6b,
0x90,0xf0,0xe1,0x17,0xf9,0xe3,0xb1,0xe7,0x71,0xca,0x84,0xe7,0x79,0xe2,0x7b,0x86,
0xd0,0xbf,0xfe,0xd8,0xf3,0xe1,0x13,0x85,0x7d,0x8e,0xb,0xcc,0x53,0x4f,0x3d,0xa5,
0x3,0x25,0x99,0xd,0x64,0xa1,0x61,0xcd,0xcd,0xcd,0xe9,0xe3,0x94,0xe2,0x34,0x13,
0x40,0xc5,0x63,0x61,0xe,0x3c,0xf7,0x38,0xff,0xfb,0xdc,0xe3,0xb8,0xae,0xc3,0xdb,
0xd7,0x5d,0xcd,0xb5,0xeb,0x57,0x51,0x56,0x9a,0x7b,0x2,0x22,0xb1,0x23,0xa7,0x49,
0xc,0x1e,0xc7,0xb3,0xf3,0xf3,0xdb,0xd1,0x84,0xa4,0xa3,0x3b,0xc9,0x99,0x7e,0x87,
0xe1,0x11,0xc5,0xd0,0xa1,0x2f,0x63,0x58,0x6,0x8d,0x2b,0xb7,0xca,0x60,0xcd,0xd2,
0x27,0xbe,0xf8,0xf7,0xf,0x8c,0x7b,0x5c,0x3b,0x2e,0x30,0xbd,0xbd,0xbd,0x95,0x4a,
0x29,0x51,0x6c,0x67,0xd,0x50,0x59,0x59,0x39,0xa9,0x61,0xb9,0x34,0x1d,0xbe,0xe1,
0xa1,0x5e,0x5e,0xf8,0xc5,0xf7,0xd8,0xb7,0xf7,0x31,0x4,0x82,0xeb,0xae,0x59,0xca,
0x35,0xeb,0x56,0x50,0x12,0x8,0xe6,0xf0,0x79,0xd8,0xe1,0x53,0x24,0x6,0xdb,0x91,
0x4e,0xfe,0x42,0x73,0x28,0xe6,0x71,0xa2,0x2b,0x49,0xd7,0xa0,0x43,0x78,0x44,0x32,
0x18,0x4d,0x52,0x5e,0x51,0xcd,0xb6,0xf,0x6d,0xe7,0x5d,0xb7,0x7c,0x82,0x3f,0xec,
0x3f,0x40,0x67,0x67,0x67,0xb0,0xb0,0xef,0x5c,0x1a,0x17,0x18,0xcf,0xf3,0x42,0x9a,
0xa6,0x65,0x77,0xd6,0x6f,0x46,0x50,0x1d,0xea,0x3f,0xcb,0xb3,0x3f,0x7b,0x84,0x3,
0xcf,0x3d,0x81,0x69,0xe8,0x6c,0x79,0xfb,0x4a,0xd6,0xaf,0x5a,0x46,0x6e,0x6a,0x55,
0x49,0x87,0xd1,0xa1,0xe,0x46,0x7,0x4f,0x20,0xbd,0xfc,0xb3,0xee,0xbe,0x88,0xcb,
0x89,0x2e,0x87,0x9e,0xb0,0xc3,0x60,0x4c,0x32,0x3c,0x92,0xa4,0x66,0xce,0x3c,0xee,
0xfc,0xd0,0x67,0x58,0x77,0xfd,0x6d,0x98,0xa6,0x85,0xcf,0xb2,0x8,0x4,0x2,0x9a,
0xa6,0x69,0xd5,0x13,0xe9,0x37,0x2e,0x30,0xba,0xae,0x87,0x94,0x52,0x98,0xa6,0x59,
0x74,0x46,0x7a,0xf5,0xd5,0x57,0x19,0x1d,0x1d,0x7b,0xc0,0x3f,0x15,0x0,0xa,0x69,
0x64,0xb8,0x8f,0xc3,0xfb,0xf7,0x70,0xf2,0xb5,0x97,0x28,0x9,0x4,0x78,0xf7,0xe6,
0xb5,0xac,0x59,0xb1,0x34,0x2f,0xdd,0x21,0x3d,0x9b,0xd1,0xc1,0x76,0x46,0x87,0x3a,
0x50,0xf2,0xfc,0x5,0x2,0xa5,0xe0,0xdc,0xa0,0xc3,0x89,0xae,0x24,0x83,0x51,0x8f,
0xbe,0x88,0x43,0xdc,0xf6,0xa8,0x9a,0xb3,0x90,0x5b,0xef,0xf8,0x4,0x9b,0x6f,0xba,
0x13,0x21,0x52,0x4b,0xb1,0x8c,0x1d,0xe9,0x9,0x65,0xc2,0x33,0xec,0x71,0x81,0xc9,
0x64,0xd2,0x8b,0xa5,0x1c,0x20,0x35,0x94,0x1c,0xc7,0x99,0x16,0x0,0xc5,0xf8,0x86,
0xfa,0x4e,0xf3,0xec,0x8f,0xff,0x1,0x1d,0x97,0x5b,0xdf,0xbd,0x91,0x95,0xcb,0x9b,
0x31,0xf5,0xf3,0x6a,0x49,0x37,0x4e,0x62,0xe0,0x38,0x76,0xb8,0x13,0x75,0x3e,0x2b,
0x80,0x94,0x70,0xba,0xdf,0xa1,0xa3,0x3b,0xc9,0x60,0xd4,0xa5,0x6f,0xd8,0xc3,0x4e,
0xba,0x34,0x2e,0x59,0xcb,0xd,0x9b,0xef,0xa2,0x6e,0xe1,0x4a,0xaa,0xaa,0xaa,0xb2,
0xa0,0x64,0xfa,0x55,0x4a,0x65,0x0,0x9f,0x30,0x59,0x35,0x25,0x60,0x8a,0x19,0x36,
0x7f,0xfe,0xfc,0x69,0x1,0x50,0x8c,0x7a,0xce,0xb4,0xf3,0xc3,0x47,0xef,0x63,0x76,
0x4d,0x9,0x1f,0xfb,0xe4,0xc7,0x51,0x83,0x9d,0xe8,0x69,0x50,0xbc,0x64,0x94,0xc4,
0xc0,0x31,0xec,0xc8,0x19,0xe0,0xbc,0x2c,0xc7,0x53,0x9c,0xea,0x71,0x38,0xd5,0x93,
0x24,0x32,0xe2,0xd2,0x1b,0x91,0x78,0x52,0xb2,0xfa,0x6d,0x37,0xb3,0xe5,0x7d,0xf7,
0x50,0x37,0x3f,0xff,0xde,0x4c,0xb1,0x84,0x7d,0x3a,0xb9,0x5f,0xc1,0x4,0x34,0x61,
0x8c,0x11,0x42,0x28,0x5d,0xd7,0x85,0xe3,0x38,0x33,0x9e,0xef,0xed,0x3e,0x73,0x9c,
0x87,0x1f,0xf8,0x1b,0x6a,0x43,0x1,0xee,0xfe,0x5c,0x2b,0xbe,0xf2,0xb9,0xc8,0x50,
0x23,0xb1,0x23,0xbf,0x26,0x39,0x74,0x8a,0x64,0xf4,0x5c,0x1e,0xff,0x68,0x52,0x71,
0xb2,0x27,0xc9,0xa9,0x1e,0x87,0xe1,0xb8,0x4b,0x6f,0xc4,0x43,0xd7,0x75,0x36,0xbc,
0xeb,0x4e,0xde,0x79,0xcb,0xa7,0x8,0xd5,0xe6,0x5f,0x18,0x1a,0xaf,0xdf,0x4c,0x78,
0x50,0x4a,0x59,0x8f,0x3d,0xf6,0x98,0xff,0xee,0xbb,0xef,0x2e,0x1a,0xf,0xc6,0x5,
0xc6,0x75,0xdd,0x50,0x20,0x10,0xf0,0x32,0x3c,0x85,0x1d,0x8c,0x97,0xf3,0x9d,0xa,
0x50,0x83,0xbd,0x9d,0xfc,0xd7,0xf7,0xff,0x8e,0xda,0x6a,0x3f,0x1f,0xb9,0xe7,0x53,
0xe8,0x56,0x29,0x4a,0x3a,0x68,0xba,0x45,0x70,0xd1,0x75,0x44,0x5f,0xdc,0x9f,0xbd,
0x59,0x15,0x1b,0x95,0x74,0x74,0x25,0x39,0xdd,0x97,0x24,0x12,0x97,0xf4,0x47,0x1c,
0xac,0x40,0x80,0xd5,0x9b,0xde,0xcf,0xca,0x8d,0xb7,0xe1,0x2f,0xa9,0x60,0x20,0x92,
0x60,0x20,0x72,0x7c,0x4c,0x3f,0xc5,0x72,0xbe,0x19,0x60,0x5c,0xd7,0x25,0x16,0x8b,
0x85,0x80,0x73,0x63,0x1a,0x32,0x1,0x30,0x8e,0xe3,0x84,0x2a,0x2b,0x2b,0x95,0x52,
0xaa,0x68,0xf0,0x1d,0x18,0x18,0x98,0x76,0xf0,0x55,0x4a,0x11,0xe9,0x3f,0xcd,0xef,
0xf7,0xfc,0x2b,0x73,0xaa,0x3,0x7c,0xf8,0xa3,0x77,0xa1,0x1b,0x6,0x2a,0x39,0x82,
0x74,0x6d,0x94,0x10,0x20,0x4,0x66,0xd9,0x6c,0xfa,0xbb,0xcf,0xd2,0xd1,0xe5,0x70,
0x66,0x20,0xc9,0x50,0xcc,0x23,0x1c,0x73,0xf0,0x7,0x2b,0x58,0xba,0xf1,0x36,0x16,
0x2c,0xdb,0x82,0xcf,0xa,0x10,0x89,0x8d,0x12,0x4b,0x38,0xe3,0xf6,0x6b,0x59,0x56,
0x36,0xe7,0x5b,0x8,0x8c,0xe7,0x79,0xb8,0xae,0x3b,0x7d,0x60,0x5c,0xd7,0xd,0xf9,
0xfd,0x7e,0x2d,0x23,0xac,0xd0,0x13,0xd6,0xac,0x59,0x33,0x2e,0x0,0xb9,0x75,0xae,
0xeb,0x22,0xa5,0xc4,0x75,0x5d,0xba,0xde,0x38,0xc6,0x33,0xdf,0xff,0x1a,0x57,0x35,
0x2f,0xe5,0x1d,0x9b,0xde,0x86,0xa1,0x83,0xb4,0x47,0x50,0x6e,0x12,0xa1,0x65,0xf2,
0x32,0x92,0x23,0xa7,0x86,0x79,0xfd,0xf8,0x8,0x3,0x51,0x97,0xe1,0xb8,0xcb,0xac,
0x9a,0x7a,0x6e,0xd8,0xf6,0x61,0x96,0xad,0xbf,0x11,0xc3,0xf4,0xa1,0xeb,0x7a,0xb6,
0x68,0x9a,0x86,0xae,0xeb,0x18,0x86,0x91,0xfd,0x7f,0x3c,0xa0,0x20,0x35,0x33,0x65,
0x3c,0x86,0x9,0x2,0xf0,0x44,0xc0,0x54,0x59,0x96,0x35,0xe6,0xcc,0x7a,0xaa,0xfb,
0x23,0xc7,0x71,0xf0,0x3c,0x2f,0xfb,0xec,0x7a,0xe3,0x18,0x8f,0x7f,0xeb,0x1e,0x16,
0x2f,0x69,0xe6,0xb1,0x67,0x3a,0xf9,0xe7,0x47,0x5e,0xe6,0x95,0xff,0xdc,0x8e,0x6d,
0x3b,0x8c,0x8c,0x8c,0x10,0x8d,0xc5,0x9,0x87,0x23,0xc,0xe,0xc,0x73,0xf8,0x68,
0x17,0xc3,0x31,0x9b,0x9a,0xba,0xc5,0x6c,0x79,0xcf,0x1d,0x34,0x5e,0xb5,0x1,0x5d,
0xd7,0x89,0x8d,0xc4,0xd1,0x75,0x3b,0xb,0x44,0x6,0xc,0xd3,0x34,0xf3,0xc0,0x31,
0xc,0x63,0x5c,0x80,0x20,0x95,0x4e,0x4d,0x3,0x33,0xee,0x51,0xed,0xb8,0xc0,0x48,
0x29,0x6b,0x72,0x8f,0x66,0xb,0x1,0x19,0x1e,0x1e,0x1e,0x77,0x4b,0xe0,0xba,0x2e,
0xae,0xeb,0xe2,0x38,0xe,0x52,0x4a,0x6,0x7b,0x4e,0xb1,0xe7,0x3b,0x9f,0x27,0x3e,
0x12,0xe7,0xf9,0x97,0x5f,0xa5,0x29,0xa4,0xd1,0x5c,0x53,0xca,0x57,0xff,0xed,0x87,
0x79,0x72,0x2d,0x7f,0x9,0x25,0xe5,0xd5,0x94,0xce,0x59,0xcd,0xd2,0xe6,0x4d,0xd4,
0xd4,0x37,0x63,0x18,0x6,0xf1,0x78,0x3c,0xb,0x44,0xa6,0x48,0x29,0xf1,0x3c,0x2f,
0xbb,0x9c,0xc8,0xcd,0x4b,0xa7,0xae,0xc9,0xe6,0x4f,0xd3,0x39,0x76,0x65,0x3d,0x66,
0xa2,0xf3,0xa5,0x89,0x66,0xa5,0xea,0xcc,0x8a,0xb3,0x18,0x30,0x47,0x8e,0x1c,0x19,
0x37,0xe7,0x9b,0x51,0xda,0xf3,0x3c,0x86,0x7,0xce,0x70,0xe8,0x85,0x6f,0x63,0xc7,
0xa3,0x4,0x83,0x65,0x2c,0xaf,0x9f,0x4d,0xd9,0xac,0xb9,0x94,0x94,0xd7,0x10,0x28,
0xab,0x26,0x58,0x56,0x85,0xbf,0xb4,0x8a,0x40,0x69,0x8,0x85,0x9e,0x97,0x60,0xcf,
0xc,0x13,0x4d,0xd3,0xb2,0x77,0x85,0x73,0x4b,0x6e,0x7d,0x2e,0xa5,0xf,0xee,0x8b,
0xda,0xa5,0x94,0x42,0xd7,0x75,0x94,0x52,0x2a,0x1d,0x63,0xa6,0x7,0x8c,0xeb,0xba,
0x95,0xe3,0xed,0x93,0x20,0x95,0xf3,0x9d,0x28,0x47,0x93,0x89,0x2f,0x9d,0xed,0x7,
0x59,0xb5,0xea,0x11,0x2a,0xab,0xeb,0xd1,0x74,0x33,0xb,0x98,0xeb,0xba,0xd9,0xdc,
0x48,0xa6,0xae,0xb0,0xaf,0x5c,0x10,0x72,0x63,0x8a,0xa6,0x69,0x79,0xc3,0x26,0x53,
0x7c,0xbe,0x54,0xfc,0x99,0xc,0x18,0x0,0xcb,0xb2,0xbc,0x68,0x34,0x3a,0x3d,0x60,
0x84,0x10,0xa2,0xb5,0xb5,0xb5,0x7c,0xa2,0x33,0xeb,0xc2,0xab,0x21,0xe3,0x29,0xb2,
0x62,0xed,0xf5,0x48,0x29,0xb3,0x0,0x24,0x93,0xc9,0x3c,0x40,0x32,0x1e,0x52,0x78,
0x14,0x93,0xf9,0x5c,0xe8,0x1d,0x19,0x80,0x32,0x60,0x64,0xbc,0x2a,0xd7,0x6b,0x26,
0xca,0x34,0x66,0xfa,0xf1,0xfb,0xfd,0x6a,0xa2,0x33,0xec,0xa2,0xc0,0x6c,0xdf,0xbe,
0xbd,0xdc,0x71,0x1c,0xad,0xf0,0xaa,0xc7,0x85,0x1e,0x65,0xe4,0x1a,0x94,0xbb,0x29,
0x2d,0x2c,0xc5,0xda,0xe5,0x3e,0x33,0x9f,0x2f,0xe6,0x1e,0x60,0xe6,0xfb,0x40,0x20,
0xa0,0x4d,0x7b,0x28,0x49,0x29,0x43,0xae,0xeb,0x52,0xec,0x5e,0xcc,0x74,0x94,0x98,
0x8c,0xb7,0x98,0x91,0x97,0x7a,0x17,0x9f,0x19,0xfe,0x7e,0xbf,0x5f,0xf7,0x3c,0x6f,
0xda,0xb3,0x52,0xc8,0x75,0x5d,0x26,0xbb,0xfe,0x71,0xa1,0xca,0x4e,0x87,0x77,0xa6,
0xf9,0x72,0x86,0x12,0x52,0xca,0x71,0x77,0xd8,0x45,0x81,0x71,0x5d,0x37,0x94,0x59,
0x39,0x16,0xb,0xb0,0x97,0xcb,0xa8,0x99,0x94,0xe9,0xf7,0xfb,0x71,0x1c,0x67,0x7a,
0x1e,0xe3,0x38,0x4e,0x48,0x8,0x51,0xf4,0x5e,0xcc,0x85,0x28,0x71,0xa9,0xf8,0x2e,
0x54,0xa6,0x94,0x32,0x3,0xcc,0xb8,0xd7,0xe7,0x8b,0x2e,0xf,0x5d,0xd7,0xd,0x79,
0x9e,0xa7,0x8a,0xe5,0x7b,0xc7,0xb,0x9a,0x85,0x4a,0xbc,0x19,0x7c,0x17,0x2a,0x33,
0x33,0x94,0x1c,0xc7,0xf1,0x6f,0xdb,0xb6,0xad,0xe8,0x31,0xc8,0x18,0x8f,0x11,0x42,
0x68,0xb7,0xdf,0x7e,0x7b,0x6d,0x45,0x45,0x85,0x7,0x18,0x99,0xa9,0xf1,0x62,0xe8,
0x52,0x78,0xca,0xc5,0xf4,0x2d,0x84,0xc0,0xef,0xf7,0xe3,0xba,0x2e,0x43,0x43,0x43,
0xf3,0x84,0x10,0xa7,0x81,0xa4,0x52,0x2a,0x1b,0x37,0x8c,0x82,0x6,0x26,0x60,0xd9,
0xb6,0x5d,0xeb,0xf7,0xfb,0x95,0xdf,0xef,0xcf,0x2e,0xb5,0x2f,0x7,0x5d,0xaa,0x7e,
0x75,0x5d,0x27,0x14,0xa,0xe1,0x79,0x1e,0x42,0x88,0x3a,0x60,0x10,0x30,0x84,0x10,
0xb6,0x52,0xca,0x81,0x1c,0x60,0xd2,0xa0,0xf8,0x1,0xbf,0xeb,0xba,0x65,0xba,0xae,
0x8b,0x8e,0x8e,0xe,0xda,0xdb,0xdb,0x19,0x1e,0x1e,0xbe,0x24,0xa,0x5e,0x2e,0x6a,
0x6c,0x6c,0x64,0xd6,0xac,0x59,0xb8,0xae,0x8b,0x6d,0xdb,0xe5,0x40,0x80,0x54,0x58,
0x11,0xe9,0x55,0xb3,0x63,0x90,0xfa,0x4f,0x3,0x4c,0xc0,0x7,0xf8,0x1c,0xc7,0x31,
0x5d,0xd7,0x9d,0xf2,0x5,0xe7,0x2b,0x8d,0x3c,0xcf,0xcb,0xbe,0x95,0xe7,0xba,0xae,
0x45,0xca,0x21,0x14,0x20,0x1,0x4f,0x8,0x91,0xbd,0x38,0xa4,0x1,0x7a,0xba,0x98,
0xae,0xeb,0xa,0xdb,0x4e,0x1d,0x4d,0x58,0x96,0x35,0xe6,0xca,0xc7,0x95,0x4e,0x99,
0x1b,0xe2,0xe9,0xc,0x80,0x41,0x6a,0xe4,0x98,0x80,0x43,0x1a,0x87,0xc,0x30,0x22,
0xa7,0xe0,0x38,0x4e,0xff,0xb9,0x73,0xe7,0x34,0x29,0x25,0x55,0x55,0x55,0x54,0x55,
0x4d,0x7a,0xc3,0xfc,0x8a,0xa3,0xde,0xde,0x5e,0x5c,0xd7,0x95,0xe1,0x70,0x38,0xc2,
0xf9,0xd9,0x39,0x8b,0x81,0x48,0xe7,0x2f,0xc,0x52,0xee,0x14,0x0,0x2,0xb5,0xb5,
0xb5,0xf5,0x2b,0x56,0xac,0x78,0xb1,0xa4,0xa4,0xc4,0x68,0x69,0x69,0xb9,0x3c,0x9a,
0x5f,0x42,0x8a,0x46,0xa3,0xea,0xd8,0xb1,0x63,0xba,0x6d,0xdb,0xcf,0xef,0xdb,0xb7,
0xef,0x3e,0x20,0x51,0x50,0xe2,0xd9,0x37,0xdc,0x84,0x10,0x19,0x60,0xfc,0x80,0xbf,
0xa1,0xa1,0x61,0x7e,0x5d,0x5d,0xdd,0x7b,0xd,0xc3,0x68,0x56,0x4a,0x69,0x9c,0x47,
0xf5,0xf2,0x4c,0x51,0x17,0x4f,0x42,0x29,0x25,0x84,0x10,0xa,0xb0,0x63,0xb1,0xd8,
0x1f,0xda,0xdb,0xdb,0x5f,0x4c,0x24,0x12,0xc3,0xc0,0x68,0x4e,0x89,0x2b,0xa5,0xec,
0x5c,0x60,0x4,0xe7,0x81,0xb1,0xd2,0xc5,0x97,0x2e,0x26,0xa9,0xb1,0x27,0x80,0xf1,
0x4f,0xf2,0xdf,0xda,0x94,0x9,0x1b,0x92,0x94,0xd,0xe,0x90,0x4c,0x17,0x3b,0x5d,
0x46,0x94,0x52,0x36,0x14,0xbc,0x13,0x99,0x6,0xa7,0x10,0x94,0x4c,0x70,0xd2,0x73,
0x4,0x5f,0x89,0xa4,0x91,0xfa,0x61,0x15,0x29,0x60,0xdc,0x74,0xc9,0x80,0x33,0xa2,
0x94,0xca,0x9e,0xfd,0x16,0x7d,0x59,0x34,0x3d,0x7d,0xe7,0x2,0xa3,0xe7,0x8,0xbe,
0x52,0x3d,0x26,0xf3,0xc3,0x66,0xa7,0x65,0x52,0x80,0x8c,0x2,0x6e,0x21,0xe,0x93,
0xbe,0x45,0x9b,0x6,0x29,0x33,0x9d,0x6b,0x5c,0xd9,0x1e,0x93,0x1,0x45,0x2,0x9e,
0x9a,0xc0,0xf8,0xff,0x7,0x6b,0xa5,0xc1,0xce,0xa5,0x84,0xda,0x6b,0x0,0x0,0x0,
0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/newdrone18/workspace/qtbook-master/20.02.27_Qt_Programming_Korean_v1.4_Example_Source_code/Ch03/01_BasicWidget/01_QCheckBox/resources/chat.png
0x0,0x0,0xa,0xf9,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x51,0x0,0x0,0x0,0x40,0x8,0x6,0x0,0x0,0x0,0x62,0x5,0x9b,0x8,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0x1a,0x94,0x0,0x0,0x1a,0x94,
0x1,0xab,0xa0,0xe8,0xc9,0x0,0x0,0x0,0x19,0x74,0x45,0x58,0x74,0x53,0x6f,0x66,
0x74,0x77,0x61,0x72,0x65,0x0,0x77,0x77,0x77,0x2e,0x69,0x6e,0x6b,0x73,0x63,0x61,
0x70,0x65,0x2e,0x6f,0x72,0x67,0x9b,0xee,0x3c,0x1a,0x0,0x0,0xa,0x76,0x49,0x44,
0x41,0x54,0x78,0x9c,0xd5,0x9c,0x7d,0x6c,0x13,0xe7,0x1d,0xc7,0x3f,0xcf,0xf9,0x35,
0x71,0xf3,0x62,0xb5,0x20,0xa,0x4a,0xff,0xe8,0x68,0xa5,0xb5,0x15,0x1b,0x15,0xa8,
0xa1,0x74,0x52,0xb5,0xad,0xaa,0x84,0x40,0x48,0xfd,0x63,0x42,0xc,0x55,0xaa,0x54,
0xf1,0xa2,0xa1,0x95,0xc1,0x34,0xcd,0xff,0x6d,0xd2,0xaa,0xac,0xa3,0x4,0xba,0xaa,
0x52,0x12,0x50,0x3b,0x21,0x4,0xca,0xc2,0x34,0x16,0x5a,0x58,0xa0,0xd1,0xe8,0xa0,
0x5b,0x26,0xaa,0x88,0x26,0x6a,0x35,0x5a,0x1,0x1a,0x94,0x24,0x44,0xc4,0x6e,0xde,
0xec,0xb3,0x7d,0x77,0xcf,0xfe,0x38,0x9f,0x73,0xb1,0xcf,0x89,0xe3,0xf8,0x1c,0xf3,
0x95,0x1e,0xf9,0xfc,0xdc,0xf3,0xf2,0xbb,0xcf,0xfd,0x9e,0xd7,0x3b,0x5b,0x48,0x29,
0x71,0x5b,0x91,0x48,0xa4,0x11,0x78,0x13,0xf8,0x11,0xf0,0x24,0x20,0x5c,0xaf,0x74,
0xf1,0x8a,0x3,0x9f,0x3,0xc7,0x81,0xf6,0x96,0x96,0x96,0x82,0xa0,0x84,0xdb,0x10,
0x23,0x91,0x48,0x13,0xd0,0x7,0xac,0x4,0xa8,0xa9,0xa9,0xa1,0xa6,0xa6,0x66,0x56,
0x1a,0xbb,0xd,0x85,0x8e,0x4b,0x4d,0x57,0xaa,0x92,0xc9,0x24,0x9a,0xa6,0x59,0x5f,
0xcf,0x2,0x5b,0xb,0x81,0xf4,0x2e,0xba,0xb6,0xf9,0x75,0x14,0x58,0xf9,0xdc,0x73,
0xcf,0xf1,0xd2,0x4b,0x2f,0x51,0x5b,0x5b,0x8b,0x10,0xd5,0xef,0x88,0xba,0xae,0x33,
0x3a,0x3a,0x4a,0x57,0x57,0x17,0xc3,0xc3,0xc3,0x5b,0x80,0x37,0x80,0x23,0x4e,0x69,
0x15,0x37,0xd,0x89,0x44,0x22,0x2b,0x80,0x97,0xeb,0xea,0xea,0xd8,0xb2,0x65,0xb,
0xa1,0x50,0x8,0x21,0x4,0x52,0x4a,0xc,0xc3,0x40,0x4a,0x59,0xb5,0xc1,0xe3,0xf1,
0xf0,0xe8,0xa3,0x8f,0xb2,0x7d,0xfb,0x76,0xeb,0x72,0xb6,0x17,0xba,0x4e,0xb7,0x3d,
0xf1,0x7b,0x0,0xab,0x57,0xaf,0xc6,0xe3,0xf1,0x20,0xa5,0x44,0x55,0xd5,0x92,0x9b,
0x9b,0x53,0x3e,0xb7,0xe2,0x7c,0x3e,0x1f,0xa1,0x50,0x88,0x70,0x38,0x8c,0xdf,0xef,
0x27,0x95,0x4a,0x7d,0xbf,0x90,0x5d,0xae,0x7a,0x22,0x50,0x3,0xb0,0x62,0xc5,0xa,
0x80,0xac,0xf7,0x95,0xa2,0x4a,0x2,0x4,0x48,0xa7,0xd3,0x59,0x8f,0xc,0x4,0x2,
0x0,0xbe,0x42,0xb6,0xb9,0xd,0xd1,0xac,0x44,0x31,0xab,0x79,0x50,0x0,0xe6,0xc6,
0x59,0xf6,0x17,0x52,0x45,0x20,0x2e,0x46,0x4b,0xd,0xb0,0x18,0x55,0x35,0xc4,0x7,
0x1,0x20,0x54,0x66,0x8a,0x53,0x92,0x8a,0x99,0xfb,0x2d,0x35,0x3c,0x4b,0x55,0x7,
0xf1,0x41,0xf1,0x3e,0xbb,0xaa,0xaa,0x39,0x57,0x13,0xc0,0x7,0xb2,0x4f,0xac,0x26,
0x58,0xb,0xf5,0xca,0xaa,0x80,0x58,0x4d,0xb0,0x4a,0x81,0xba,0xe4,0x7d,0x62,0x31,
0x46,0x17,0xba,0x8,0xb7,0x7,0x9f,0x62,0xb5,0x64,0x10,0xab,0xc9,0xab,0x1e,0xc8,
0x3e,0xb1,0x9a,0xc0,0xb8,0x3a,0x4f,0x8c,0x44,0x22,0x1,0xe0,0x57,0xc0,0xcb,0xc0,
0x77,0x28,0x6d,0x23,0x35,0x0,0xf0,0xf1,0xc7,0x1f,0xf3,0xc9,0x27,0x9f,0x94,0x64,
0x60,0xd1,0x15,0x5,0x2,0xac,0x5a,0xb5,0x8a,0x8d,0x1b,0x37,0xd2,0xd0,0xd0,0x90,
0x77,0xde,0xcd,0x66,0xed,0x8,0x31,0x12,0x89,0x84,0x81,0x7f,0x2,0xcf,0x0,0x8,
0x21,0xf0,0x78,0x3c,0xb,0x2e,0xdc,0x92,0xae,0xeb,0xe8,0xba,0x5e,0x72,0xfe,0xf9,
0x64,0x18,0x6,0xd3,0xd3,0xd3,0x44,0xa3,0x51,0xae,0x5f,0xbf,0xce,0xd6,0xad,0x5b,
0x79,0xfc,0xf1,0xc7,0xb3,0xe7,0x97,0x6a,0xb2,0x7d,0x18,0x78,0xe6,0x89,0x27,0x9e,
0x60,0xdb,0xb6,0x6d,0xd4,0xd4,0xd4,0x54,0xfd,0x46,0x6a,0x22,0x91,0xe0,0xda,0xb5,
0x6b,0x74,0x77,0x77,0x73,0xee,0xdc,0x39,0x5e,0x7f,0xfd,0x75,0x6b,0xf7,0x65,0x96,
0x2a,0xd2,0x27,0x46,0x22,0x91,0x1a,0xe0,0xa7,0x7e,0xbf,0x9f,0x57,0x5f,0x7d,0x35,
0xbb,0x13,0xbd,0x98,0xd,0x4e,0xb7,0x3,0x98,0x8f,0x1d,0x36,0x6c,0xd8,0xc0,0xb3,
0xcf,0x3e,0xcb,0xf4,0xf4,0x34,0x37,0x6e,0xdc,0xa8,0x8,0x40,0x70,0xf6,0xc4,0x35,
0x80,0xf7,0xb1,0xc7,0x1e,0xc3,0xeb,0xf5,0x22,0xa5,0x24,0x91,0x48,0x2c,0xa8,0xd0,
0x85,0xaa,0xd4,0x8b,0xb3,0xbe,0xb,0x21,0x8,0x6,0x83,0xf8,0x7c,0x3e,0xd6,0xac,
0x59,0x43,0x7f,0x7f,0x3f,0xa3,0xa3,0xa3,0x3c,0xf5,0xd4,0x53,0x8b,0xae,0xa3,0x18,
0x39,0x8d,0xce,0x35,0x0,0x4d,0x4d,0x4d,0x80,0xd9,0xdf,0xb8,0x29,0x27,0x30,0xc5,
0xc6,0xd9,0x8f,0xad,0x87,0x4a,0xe1,0x70,0x18,0x80,0x54,0x2a,0x55,0xb0,0x8e,0x85,
0xc4,0x15,0xa3,0x82,0xa3,0xb3,0xd5,0x9f,0xb8,0x35,0x9a,0x96,0x3a,0xc9,0x2e,0x14,
0x67,0xdd,0xec,0xdc,0xbe,0xbb,0x12,0x53,0x9d,0x8a,0x4f,0xb6,0x17,0xdb,0x74,0xe7,
0x8b,0xb3,0x9f,0x2b,0xe7,0x8a,0x66,0x2e,0x55,0x14,0xe2,0x52,0x2e,0xd3,0x2a,0x3e,
0x4f,0x2c,0xb7,0xca,0xdd,0x74,0x8b,0x89,0x73,0xa3,0x9c,0x42,0x72,0x15,0xa2,0xdb,
0x4d,0xd7,0xed,0xb2,0x8a,0x95,0x6b,0x10,0xab,0x15,0x8c,0x1b,0x50,0xcb,0xe,0xb1,
0x1a,0x3c,0xad,0x58,0xdb,0x16,0xa,0x4f,0x8,0x11,0x90,0x52,0x26,0x73,0xe3,0xcb,
0x6,0xb1,0x5a,0xbc,0xaa,0x9c,0xb6,0x39,0xc8,0x2f,0x84,0x48,0x4b,0x29,0x67,0x4d,
0x9e,0xcb,0x2,0xb1,0x5a,0x9b,0x6e,0x39,0xf2,0xe7,0xc8,0x7,0xf8,0x1,0xd5,0x1e,
0xb9,0x28,0x88,0xd5,0xd0,0x74,0xe7,0x9b,0x2b,0x96,0x1a,0x7,0x33,0x13,0x77,0xdb,
0x79,0x4f,0x26,0xcc,0x52,0x49,0x10,0xab,0xa1,0xe9,0xba,0x3d,0xad,0x11,0x42,0xa0,
0x28,0xa,0x86,0x61,0x90,0x4e,0xa7,0x1,0x24,0xe6,0x32,0x59,0x8,0x21,0x84,0xb4,
0x65,0x5c,0x30,0xc4,0x6a,0xf0,0x34,0xa7,0x7c,0xb9,0x71,0x81,0x40,0x80,0xc6,0xc6,
0x46,0xa4,0x94,0x4c,0x4c,0x4c,0xe4,0xed,0x1,0xf8,0xfd,0x7e,0x6a,0x6b,0x6b,0xf3,
0xca,0xb6,0xe4,0xf5,0x9a,0x68,0x12,0x89,0x4,0xaa,0xaa,0xa2,0xeb,0xfa,0xd,0xcc,
0x8d,0xe9,0xbc,0x3d,0xc1,0xa2,0x21,0x56,0x83,0xa7,0x2d,0xc4,0x93,0x14,0x45,0xc9,
0x82,0xa8,0xaf,0xaf,0x67,0x7c,0x7c,0x3c,0x9b,0x56,0x4a,0x89,0xdf,0xef,0xc7,0xe7,
0x2b,0xf8,0xa2,0x17,0x0,0xf1,0x78,0x9c,0x9e,0x9e,0x1e,0xeb,0xf8,0x2,0xa6,0x37,
0x4a,0x99,0x53,0x69,0x51,0x10,0xcb,0xe9,0x31,0x6e,0xe6,0xb3,0xeb,0xab,0xaf,0xbe,
0xe2,0xd4,0xa9,0x53,0xbc,0xf2,0xca,0x2b,0x4,0x2,0x1,0x1e,0x7a,0xe8,0x21,0x26,
0x27,0x27,0xb3,0xf9,0x2c,0x80,0x5d,0x5d,0x5d,0x8e,0x5b,0x7d,0xe3,0xe3,0xe3,0xc,
0xd,0xd,0x1,0xa0,0x69,0xda,0x7f,0x4f,0x9f,0x3e,0x7d,0x18,0xd0,0x81,0xbc,0x6d,
0xad,0x5,0x35,0xe7,0x6a,0xf0,0xb4,0x62,0xf3,0xc5,0x62,0x31,0x62,0xb1,0x18,0x63,
0x63,0x63,0xec,0xd9,0xb3,0x87,0x60,0x30,0x88,0x61,0x18,0x4c,0x4d,0x4d,0x65,0xbd,
0x34,0x9d,0x4e,0xd3,0xdf,0xdf,0x9f,0x97,0xd7,0x92,0x61,0x18,0x93,0x93,0x93,0x93,
0x7f,0xf9,0xf0,0xc3,0xf,0x5b,0xef,0xdd,0xbb,0x17,0x7,0x34,0x20,0x95,0x9b,0xae,
0x20,0xc4,0xf9,0x8c,0xaf,0x56,0xa0,0x96,0xa6,0xa6,0xa6,0x7a,0x84,0x10,0x9e,0xbb,
0x77,0xef,0xfe,0xf8,0xe4,0xc9,0x93,0xec,0xd8,0xb1,0x83,0xda,0xda,0x5a,0xfc,0x7e,
0x3f,0xf1,0x78,0x1c,0x20,0xeb,0x81,0xd3,0xd3,0xd3,0xbd,0x97,0x2f,0x5f,0xfe,0xa3,
0x10,0xc2,0xd0,0x75,0xdd,0x2b,0x84,0x30,0x34,0x4d,0x53,0xbf,0xf8,0xe2,0x8b,0x21,
0x20,0x89,0x39,0xa5,0x49,0x1,0x29,0x29,0xa5,0x96,0x5b,0xd7,0xbc,0x9e,0xe8,0xd4,
0x69,0x57,0x83,0xa7,0x15,0x71,0x93,0x27,0x8e,0x1d,0x3b,0xf6,0xbb,0x9d,0x3b,0x77,
0xb6,0x7c,0xf9,0xe5,0x97,0x9b,0xda,0xda,0xda,0x78,0xed,0xb5,0xd7,0x8,0x6,0x83,
0xd4,0xd7,0xd7,0x3,0xe6,0xe0,0x2,0x66,0xff,0x79,0xed,0xda,0xb5,0x1b,0x98,0x7d,
0x9e,0x7,0xb3,0xc9,0xea,0x40,0x1a,0x13,0x5e,0x32,0x13,0x1c,0xb7,0xf8,0x17,0xf4,
0xdc,0xb9,0x10,0xd0,0x62,0xbc,0xb6,0x92,0xf9,0x0,0x14,0x45,0xd1,0x55,0x55,0x4d,
0x1c,0x3d,0x7a,0x74,0x7f,0x22,0x91,0x38,0x73,0xfb,0xf6,0x6d,0xe,0x1d,0x3a,0x94,
0xed,0xe7,0x60,0x6,0x62,0x20,0x10,0x78,0xd2,0xeb,0xf5,0x26,0x30,0x21,0x4d,0x67,
0x42,0x3c,0xf3,0x3d,0x1b,0x9f,0x3b,0xa0,0x64,0xeb,0x72,0x8a,0xcc,0xd5,0x42,0x2e,
0xa6,0x5a,0x80,0x2a,0x8a,0xa2,0x3,0x6a,0x22,0x91,0x88,0xb7,0xb7,0xb7,0xef,0x53,
0x55,0xb5,0x73,0x6a,0x6a,0x8a,0x77,0xdf,0x7d,0x97,0x9e,0x9e,0x1e,0x34,0x4d,0x43,
0x51,0x14,0x9a,0x9a,0x9a,0x50,0x14,0xa5,0x69,0xc7,0x8e,0x1d,0xcd,0x98,0xb0,0xd4,
0x4c,0xb0,0xe0,0x4d,0x1,0x53,0x32,0x67,0xa9,0x67,0x57,0x49,0x6f,0x40,0x54,0x2b,
0x50,0xbb,0x32,0x10,0x53,0x40,0x52,0x55,0xd5,0xc4,0x91,0x23,0x47,0x7e,0xfe,0xed,
0xb7,0xdf,0xee,0x96,0x52,0x8e,0x5d,0xba,0x74,0x89,0xd6,0xd6,0x56,0x39,0x32,0x32,
0xc2,0xda,0xb5,0x6b,0x1,0x58,0xb6,0x6c,0xd9,0xcf,0x2,0x81,0x40,0x8a,0x19,0x90,
0x71,0x4c,0x8f,0x4c,0x93,0x99,0x60,0x17,0x7a,0x6c,0x5c,0x96,0xe6,0x5c,0x4c,0x9a,
0x4a,0xe6,0x83,0x2c,0xc4,0xa4,0x3d,0xb4,0xb5,0xb5,0x9d,0x1a,0x18,0x18,0x58,0xaf,
0xeb,0xfa,0x9f,0x63,0xb1,0x98,0x78,0xe7,0x9d,0x77,0xb8,0x70,0xe1,0x2,0x0,0x1e,
0x8f,0xe7,0xf9,0xbd,0x7b,0xf7,0xee,0x61,0xc6,0x3,0xd3,0x56,0x51,0xf6,0xe0,0x44,
0xb3,0xec,0xcd,0x79,0x29,0xf3,0xe5,0x9c,0x53,0x30,0x7,0x9,0x2f,0x33,0x6b,0x5e,
0xcf,0xf9,0xf3,0xe7,0x63,0x7,0xf,0x1e,0xdc,0x15,0x8d,0x46,0x37,0xeb,0xba,0x7e,
0x51,0x55,0xd5,0x6c,0x21,0x3e,0x9f,0xef,0x37,0xbb,0x77,0xef,0x5e,0x47,0xe,0x38,
0x87,0x30,0x8b,0xe5,0xbc,0x10,0x97,0x1a,0x4c,0xb1,0xf9,0x1c,0xec,0x16,0xd8,0xe0,
0x61,0x5e,0x6b,0xf6,0xb8,0xa3,0xa3,0xe3,0x5f,0x7,0xf,0x1e,0xfc,0xc9,0x37,0xdf,
0x7c,0xb3,0x41,0xd3,0xb4,0xe3,0x98,0x4d,0xdf,0xdb,0xd0,0xd0,0xf0,0xa7,0x17,0x5f,
0x7c,0xb1,0x2e,0x93,0x5e,0xcc,0x17,0x84,0x10,0xf9,0x10,0x33,0x95,0x17,0x3d,0xad,
0x58,0x6a,0xa0,0x85,0x64,0x18,0x86,0xe5,0x85,0xb3,0x3c,0x28,0x27,0x28,0x27,0x4e,
0x9c,0xb8,0xfe,0xf6,0xdb,0x6f,0xbf,0x31,0x38,0x38,0xf8,0x4c,0x2a,0x95,0xfa,0x83,
0x10,0x22,0xbc,0x7e,0xfd,0xfa,0x43,0xe,0x69,0xb,0x86,0x59,0x10,0x85,0x10,0x4a,
0x32,0x99,0xcc,0xdb,0xea,0xa9,0x6,0x4f,0x2b,0x16,0x9e,0xa5,0xc,0x44,0x1f,0x73,
0x7b,0x14,0xd6,0xe7,0x47,0x1f,0x7d,0x34,0xda,0xda,0xda,0xfa,0x66,0x6f,0x6f,0xef,
0x77,0x35,0x4d,0xeb,0xdf,0xb9,0x73,0xe7,0xda,0x62,0xeb,0xca,0x4e,0xb6,0x33,0xd,
0xdc,0x9b,0x4a,0xa5,0xbc,0xc1,0x60,0xb0,0x60,0x86,0x62,0x3d,0xd4,0xcd,0x7c,0x45,
0xca,0x6a,0xce,0x6,0xe6,0x72,0xd,0x32,0x1b,0x8,0x73,0x85,0xab,0x57,0xaf,0xc6,
0xaf,0x5e,0xbd,0xda,0x51,0xe0,0x3c,0xb6,0xcf,0xac,0x89,0xf6,0x15,0x8b,0x7,0xf0,
0xa6,0xd3,0x69,0xc7,0x55,0x8c,0xdb,0x60,0x16,0xeb,0x79,0xe,0xe5,0xd9,0xbd,0x4d,
0x61,0x66,0xb4,0x2d,0x4,0x66,0xbe,0x80,0x43,0x7a,0x43,0x4a,0x69,0x7a,0x62,0xc6,
0xb,0x3d,0x80,0x47,0xd7,0x75,0x5,0x60,0x7a,0x7a,0xda,0xac,0x5d,0x51,0x2a,0xee,
0x69,0xa5,0x0,0xb4,0xde,0x9f,0xcc,0x6c,0xa0,0xe6,0x15,0x89,0xb9,0x8c,0xb3,0x8e,
0xad,0xcf,0xb9,0x40,0x3a,0xc5,0xcd,0xa,0x96,0x9d,0x96,0xd7,0x59,0x1d,0xaf,0x67,
0x7c,0x7c,0x7c,0x6c,0xf9,0xf2,0xe5,0xdc,0xbc,0x79,0x13,0x29,0x25,0x5e,0xaf,0x97,
0xda,0xda,0xda,0xec,0xb,0x43,0x4e,0x17,0xa8,0x69,0xda,0xac,0x97,0x38,0xa5,0x94,
0xf8,0x7c,0xbe,0x39,0x7f,0x58,0x58,0xce,0xa6,0xeb,0xf1,0x78,0xb0,0xba,0xa0,0x91,
0x91,0x11,0x0,0x52,0xa9,0xd4,0xb0,0x55,0x6c,0x26,0x18,0xe4,0x3,0xc2,0x21,0x6e,
0x5e,0x88,0xb9,0x76,0x5a,0x10,0x5,0x19,0x90,0xdd,0xdd,0xdd,0x37,0xf7,0xef,0xdf,
0x1f,0x1b,0x1e,0x1e,0xe,0x8f,0x8d,0x8d,0xf1,0xc8,0x23,0x8f,0xe0,0xf7,0xfb,0xb3,
0xeb,0x4c,0x27,0xc5,0xe3,0x71,0x74,0x5d,0xcf,0x42,0xb0,0xf6,0xef,0x2a,0x2d,0x4d,
0xd3,0xb8,0x72,0xe5,0xa,0x0,0xd1,0x68,0x74,0x80,0x7c,0x80,0x3a,0xf3,0x43,0xb4,
0xc7,0x15,0x4,0x67,0x57,0x5e,0xff,0x97,0x4e,0xa7,0x65,0x34,0x1a,0xfd,0xfd,0xc3,
0xf,0x3f,0xfc,0x56,0x6b,0x6b,0x2b,0xeb,0xd6,0xad,0xe3,0xe9,0xa7,0x9f,0x9e,0xf5,
0xbf,0xd,0x56,0x81,0xe1,0x70,0x98,0xfa,0xfa,0xfa,0xec,0x4b,0xa0,0x60,0x6e,0xab,
0x87,0x42,0x21,0x0,0xee,0xdd,0xbb,0x87,0xaa,0xaa,0xb9,0x55,0xcc,0xd2,0x62,0xfb,
0x3e,0x30,0x5f,0xff,0xbb,0x73,0xe7,0xe,0x9f,0x7e,0xfa,0x29,0x93,0x93,0x93,0x24,
0x93,0xc9,0x7f,0x9f,0x3e,0x7d,0xfa,0xa,0x33,0x9b,0xa8,0xd6,0xae,0x8c,0x7d,0x80,
0xc1,0x76,0x9c,0xe7,0x81,0xb,0xb1,0x4b,0x48,0x29,0x11,0x42,0x78,0x31,0x5f,0x52,
0xf,0x60,0x3e,0x12,0xc,0xec,0xda,0xb5,0x6b,0x6f,0x38,0x1c,0x7e,0x83,0x39,0x7e,
0x2c,0xbd,0x79,0xf3,0x66,0x36,0x6e,0xdc,0x48,0x22,0x91,0x20,0x1e,0x8f,0xa3,0x28,
0xa,0xd,0xd,0xd,0x28,0x8a,0xc2,0xd7,0x5f,0x7f,0xcd,0xfb,0xef,0xbf,0x5f,0xb4,
0x21,0xe5,0x92,0xaa,0xaa,0x57,0x7a,0x7b,0x7b,0x7f,0x3d,0x38,0x38,0x38,0xc4,0xcc,
0x36,0x96,0x9a,0xf9,0x74,0xea,0x17,0x17,0x7d,0x23,0x2d,0x4f,0xb4,0x5c,0xde,0x72,
0x7b,0xa3,0xbd,0xbd,0xbd,0xad,0xb9,0xb9,0xf9,0xef,0xab,0x57,0xaf,0x7e,0x3e,0x18,
0xc,0xae,0xb2,0x2f,0x17,0x83,0xc1,0x60,0x53,0x28,0x14,0xda,0x64,0x7f,0x27,0xd0,
0xe3,0xf1,0x50,0x57,0x57,0x87,0xa2,0x28,0xc,0xf,0xf,0x5b,0x0,0xd3,0xb1,0x58,
0xec,0x84,0x61,0x18,0x79,0xbb,0xc1,0x65,0x94,0x94,0x52,0x2a,0xba,0xae,0x4f,0xde,
0xbf,0x7f,0x7f,0xf0,0xec,0xd9,0xb3,0xff,0xc1,0x1c,0x89,0xad,0xa0,0x91,0xf1,0xc2,
0x5,0xb9,0xd7,0x2,0x64,0x41,0xcc,0xc2,0xcb,0x54,0xea,0x1,0xb4,0xbe,0xbe,0xbe,
0xff,0xf5,0xf5,0xf5,0xdd,0x65,0x66,0xbe,0x5,0xc0,0xb6,0x6d,0xdb,0x7e,0x18,0xa,
0x85,0x36,0xd5,0xd5,0xd5,0x99,0x85,0x78,0xbd,0x34,0x34,0x34,0x20,0x84,0x20,0x1a,
0x8d,0xf2,0xde,0x7b,0xef,0x1,0x68,0xb7,0x6e,0xdd,0xda,0xd7,0xd9,0xd9,0xf9,0xf,
0x37,0xc,0xcf,0x91,0x35,0x82,0x59,0x4d,0xd6,0x2,0x67,0x5,0xc3,0x2d,0x80,0x90,
0x81,0x28,0xa5,0x94,0x42,0x8,0x8d,0x99,0x51,0xda,0x3e,0x4f,0x30,0x32,0x71,0x59,
0x23,0x82,0xc1,0xa0,0xf,0xa0,0xb1,0xb1,0xd1,0x2c,0x24,0xf3,0x54,0xed,0xf6,0xed,
0xdb,0x74,0x74,0x74,0xa0,0xeb,0xba,0x31,0x34,0x34,0xb4,0xaf,0xb3,0xb3,0xb3,0xc7,
0x2d,0xc3,0x6d,0x92,0xcc,0x40,0xb4,0x9c,0x20,0x17,0xa4,0xe3,0xbc,0xa7,0x5c,0xb2,
0xf,0x2c,0xd6,0x5d,0xb4,0xcf,0x4b,0x8c,0x4c,0x1a,0x81,0xd,0x62,0x38,0x1c,0xfe,
0x41,0xe6,0xd3,0x4c,0x64,0x18,0x5c,0xba,0x74,0x89,0x8b,0x17,0x2f,0x2,0x18,0xf7,
0xef,0xdf,0xff,0xc5,0xf1,0xe3,0xc7,0xff,0xe6,0xa6,0xe1,0x39,0xb2,0xfa,0x1a,0xc9,
0xc,0x3c,0xab,0x39,0xa7,0xe4,0x1c,0x1b,0xaa,0xe5,0x50,0x16,0xa2,0xcd,0x1b,0x2d,
0x60,0x32,0x73,0x5e,0xc7,0x4,0x6b,0x0,0x34,0x37,0x37,0x37,0x6,0x2,0x81,0x4d,
0x5e,0xaf,0x97,0xba,0xba,0x3a,0x26,0x26,0x26,0xf8,0xe0,0x83,0xf,0x18,0x19,0x19,
0x41,0x4a,0x39,0x16,0x8b,0xc5,0xe,0x1c,0x3b,0x76,0xec,0x9c,0x9b,0x46,0x3b,0xc8,
0x6a,0x29,0xd6,0x34,0xc6,0x72,0x8,0xc7,0x7,0x4b,0xe5,0xd6,0xac,0x29,0x8e,0x94,
0xd2,0x10,0x42,0xa4,0x98,0xe9,0x1f,0x2d,0x80,0xd9,0x51,0xe5,0x85,0x17,0x5e,0xf8,
0x2d,0x10,0x5c,0xb9,0x72,0x25,0x9f,0x7d,0xf6,0x19,0x67,0xce,0x9c,0x41,0x4a,0x89,
0xae,0xeb,0x7f,0x1d,0x18,0x18,0xf8,0x65,0x4f,0x4f,0xcf,0x98,0xdb,0x46,0x3b,0xc8,
0x7e,0xe3,0x2d,0xbb,0x53,0x52,0x4a,0xf7,0x7e,0xc6,0x65,0xaf,0xbc,0x50,0x7f,0x2b,
0x84,0xb0,0xef,0xc3,0x9,0x40,0xee,0xdb,0xb7,0x6f,0x4b,0x30,0x18,0xfc,0xb3,0x3d,
0x9d,0x94,0xf2,0x56,0x2a,0x95,0x8a,0x1c,0x3e,0x7c,0xb8,0x92,0xcd,0x37,0x57,0x79,
0xcd,0xd9,0xcd,0x81,0x24,0xaf,0xf2,0x62,0xea,0x12,0x42,0x88,0x3,0x7,0xe,0x2c,
0xf7,0xf9,0x7c,0x83,0xc0,0xb2,0x4c,0xf4,0xe7,0x52,0xca,0xb7,0xee,0xdc,0xb9,0xd3,
0x75,0xf2,0xe4,0xc9,0x8a,0xdc,0xf1,0xf9,0x54,0x49,0x70,0x76,0x15,0xfd,0xaf,0x75,
0x91,0x48,0xa4,0x1b,0xd8,0x2,0x5c,0x6,0x5a,0x5a,0x5a,0x5a,0xce,0xbb,0x69,0xd8,
0x83,0xa4,0xff,0x3,0xb7,0x7e,0x69,0x42,0x94,0x4a,0x97,0x69,0x0,0x0,0x0,0x0,
0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/newdrone18/workspace/qtbook-master/20.02.27_Qt_Programming_Korean_v1.4_Example_Source_code/Ch03/01_BasicWidget/01_QCheckBox/resources/calendar.png
0x0,0x0,0xf,0xaa,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x50,0x0,0x0,0x0,0x40,0x8,0x6,0x0,0x0,0x0,0x8d,0xc7,0xf0,0x36,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0x17,0xc4,0x0,0x0,0x17,0xc4,
0x1,0x74,0x9a,0x4f,0xf9,0x0,0x0,0x0,0x19,0x74,0x45,0x58,0x74,0x53,0x6f,0x66,
0x74,0x77,0x61,0x72,0x65,0x0,0x77,0x77,0x77,0x2e,0x69,0x6e,0x6b,0x73,0x63,0x61,
0x70,0x65,0x2e,0x6f,0x72,0x67,0x9b,0xee,0x3c,0x1a,0x0,0x0,0xf,0x27,0x49,0x44,
0x41,0x54,0x78,0x9c,0xe5,0x9c,0x7b,0x70,0x54,0xd7,0x7d,0xc7,0x3f,0xe7,0xde,0xbb,
0xab,0x7d,0x20,0x81,0x2c,0xad,0xd0,0x63,0xf5,0x70,0xc1,0x10,0x49,0x80,0x31,0xa,
0x1,0x8c,0x29,0x4e,0x1d,0x4c,0x4c,0x26,0x6d,0xed,0x6,0x1c,0x7b,0x6c,0xc6,0xa9,
0xdb,0x5,0x89,0xd6,0x1e,0xbb,0xae,0x67,0x3a,0x99,0x4e,0xfa,0x8f,0x67,0xec,0xc,
0x9,0x99,0x4c,0x56,0x60,0x3b,0xe3,0x19,0xbb,0xcd,0xcb,0x8f,0xca,0x9d,0x29,0xa6,
0xc6,0x1e,0x48,0xa7,0xc1,0xf,0x1e,0xb5,0xc1,0xa4,0x80,0x30,0xa0,0xa0,0x95,0x64,
0xc4,0x4a,0x91,0x94,0x5d,0xd0,0xbe,0xee,0xe9,0x1f,0x7b,0x77,0xf7,0xee,0x4a,0x5a,
0xed,0x5e,0xf1,0xb0,0xc9,0x77,0xe6,0x8e,0x96,0x73,0xce,0x3d,0xe7,0x77,0xbe,0xfb,
0xfb,0x9d,0xdf,0xf9,0xfd,0xce,0x59,0x84,0x94,0x12,0xab,0xe8,0xe8,0xe8,0x58,0x5,
0xfc,0x2d,0x70,0x3f,0xe0,0xb2,0xdc,0xd1,0xb5,0xc7,0x31,0xe0,0x5,0xe0,0xdf,0x3a,
0x3b,0x3b,0x47,0x67,0xd2,0x91,0x66,0xf5,0xc5,0x8e,0x8e,0x8e,0x16,0xe0,0x3d,0x0,
0x87,0xc3,0x81,0xdd,0x6e,0x9f,0x89,0x1c,0xd7,0xc,0x52,0x4a,0x42,0xa1,0xd0,0x62,
0x29,0xe5,0x4f,0x80,0x3b,0x80,0x7,0x66,0xd2,0x9f,0xb0,0xaa,0x81,0x1d,0x1d,0x1d,
0x2f,0x2,0x7f,0xb3,0x78,0xf1,0x62,0x16,0x2d,0x5a,0x44,0x24,0x12,0x21,0x10,0x8,
0x30,0x77,0xee,0x5c,0x54,0x55,0x9d,0x89,0x4c,0x57,0x1d,0x3,0x3,0x3,0x1c,0x3f,
0x7e,0x9c,0x70,0x38,0x9c,0x0,0x1a,0x3b,0x3b,0x3b,0xfb,0xac,0xf6,0x65,0x49,0x3,
0x3b,0x3a,0x3a,0x14,0xe0,0x41,0x87,0xc3,0xc1,0xc2,0x85,0xb,0x29,0x2d,0x2d,0xa5,
0xb4,0xb4,0x94,0x91,0x91,0x11,0x22,0x91,0x8,0x8a,0xa2,0x58,0x95,0xe7,0xaa,0x23,
0xa5,0x30,0x55,0x55,0x55,0x9c,0x3b,0x77,0x4e,0x5,0x36,0x2,0x3f,0xb2,0xda,0x9f,
0x55,0x13,0x6e,0x2,0x5c,0x6e,0xb7,0x9b,0x50,0x28,0x44,0x79,0x79,0x39,0x89,0x44,
0x82,0x70,0x38,0x4c,0x2c,0x16,0xb3,0x2a,0xcb,0x35,0xc5,0xac,0x59,0xb3,0x52,0x1f,
0x17,0xcd,0xa4,0x1f,0xab,0x4,0x36,0x3,0x38,0x9d,0x4e,0x6,0x7,0x7,0x19,0x1d,
0x1d,0x25,0x16,0x8b,0xa1,0xeb,0xfa,0x4c,0x64,0xb9,0xa6,0xb0,0xd9,0x6c,0xa8,0xaa,
0x2a,0x13,0x89,0xc4,0x8c,0x8,0xb4,0x6a,0x6b,0xcd,0x90,0x74,0x1e,0x0,0x91,0x48,
0xe4,0xb,0x45,0x5e,0xa,0xe,0x87,0x43,0x0,0xad,0x1d,0x1d,0x1d,0xc2,0x6a,0x1f,
0x56,0x9,0x8c,0x1,0x44,0xa3,0x51,0xab,0xe3,0x5e,0x77,0x48,0x29,0x89,0x46,0xa3,
0x12,0x88,0x0,0x96,0xbd,0x9e,0x55,0x13,0x7e,0x5,0xf8,0xfe,0xc0,0xc0,0x80,0x5d,
0xd7,0x75,0xca,0xca,0xca,0xac,0x8e,0x7f,0x5d,0x10,0x8b,0xc5,0xb8,0x78,0xf1,0x22,
0xb1,0x58,0x4c,0x0,0x2f,0x74,0x76,0x76,0xc6,0xad,0xf6,0x65,0x79,0x1b,0xd3,0xde,
0xde,0x7e,0x52,0x8,0xb1,0xd0,0xea,0xc0,0x9f,0x13,0x5c,0x6,0xe6,0x77,0x76,0x76,
0xf6,0x5b,0xed,0xc0,0xf2,0x46,0x1a,0x98,0x5,0xb0,0x60,0xc1,0x82,0x2c,0xcf,0x9b,
0xf5,0x75,0xe4,0x7c,0x39,0x72,0xaa,0xb2,0x49,0xca,0xb,0x6d,0x93,0xb7,0xcf,0x29,
0xde,0x53,0x14,0x85,0xe1,0xe1,0x61,0xc2,0xe1,0xb0,0x5d,0xd3,0xb4,0xa1,0x29,0x7,
0x2e,0x0,0x96,0x8,0xf4,0xf9,0x7c,0x42,0x55,0xd5,0x6a,0x55,0x55,0x79,0xec,0xf1,
0xc7,0x51,0x84,0xe5,0x35,0xf8,0xba,0xe1,0x7f,0x7e,0xf3,0x1b,0x7e,0xf1,0xf3,0x9f,
0xab,0xb1,0x58,0x6c,0x35,0xb0,0xcf,0x6a,0x3f,0x96,0x8,0x14,0x42,0x2c,0x14,0x42,
0xa8,0xb,0xbf,0xf4,0x25,0x14,0x21,0x88,0x44,0xa3,0x5c,0x8e,0x44,0xac,0x49,0x60,
0x90,0x7f,0x25,0xbe,0x2,0x21,0x44,0xb2,0x9f,0xd4,0x5f,0xa3,0x2c,0xdd,0xbf,0x10,
0x28,0x8a,0x82,0xc3,0x6e,0x67,0xe1,0x82,0x5,0xa9,0xfa,0x7b,0xb9,0xd6,0x4,0x2,
0x1b,0x0,0x5a,0x5b,0x5b,0x1,0x18,0x8f,0x46,0x19,0x37,0x11,0x68,0x3d,0x3d,0x31,
0x33,0x8,0x21,0xd2,0x24,0x9a,0x3f,0x93,0x53,0x5e,0x62,0xb3,0x51,0x51,0x51,0x81,
0xaa,0xaa,0x24,0x12,0x89,0x6f,0x0,0x7f,0x6f,0x75,0x4c,0x4b,0xdb,0x18,0x21,0xc4,
0x9f,0x1,0x34,0x36,0x36,0x2,0x10,0x8f,0x67,0x9c,0xd8,0x75,0x25,0x8f,0x8c,0xa6,
0x99,0x2a,0xd2,0xe5,0x29,0x52,0xe3,0x89,0x4,0xaa,0xaa,0xd2,0xba,0x68,0x11,0x40,
0xd3,0x13,0x4f,0x3c,0x31,0xc7,0xea,0xb8,0x56,0xf7,0x81,0x8b,0x1,0xaa,0x3c,0x1e,
0xa4,0x94,0xc4,0xe2,0x96,0x77,0x1,0x57,0x16,0x26,0x73,0x15,0x26,0x33,0x26,0x67,
0x8d,0x4e,0x18,0x9b,0xfe,0xaf,0x2c,0x5f,0xe,0x20,0x22,0x91,0xc8,0x57,0xad,0xe,
0x69,0x55,0x3,0x6b,0x15,0x45,0xc1,0xed,0x76,0x13,0x4f,0x24,0xd2,0xe5,0x56,0xb4,
0x4f,0x4a,0xc9,0x4c,0x72,0x92,0x86,0x3c,0x5,0x6b,0x1f,0x90,0x96,0xf9,0x4f,0xe6,
0xcd,0x4b,0xb5,0xb4,0x9c,0xd2,0x2a,0x7a,0xd,0x7c,0xf4,0xd1,0x47,0xe7,0x95,0x94,
0x94,0x68,0x2d,0x2d,0x2d,0x8,0x21,0x8a,0xd2,0xbe,0xb1,0xd1,0x51,0x7e,0xbd,0x7f,
0x3f,0xef,0xec,0xdd,0xcb,0xa9,0x93,0x27,0xb9,0x78,0xf1,0x22,0x43,0xc1,0x20,0xaa,
0xaa,0x52,0xe7,0xf5,0xd2,0xd0,0xd0,0xc0,0xb7,0x36,0x6d,0xe2,0x2f,0xee,0xbd,0xb7,
0xe0,0x94,0xd8,0xd8,0xd8,0x18,0x87,0xf,0x1d,0xe2,0xe0,0x7,0x1f,0xf0,0xe1,0x7,
0x1f,0xb0,0x62,0xe5,0x4a,0xfe,0xf9,0x7b,0xdf,0x9b,0x52,0xfb,0x84,0x10,0x48,0x5d,
0x47,0x4a,0x49,0x59,0x59,0x19,0xe,0x87,0x83,0xf1,0xf1,0xf1,0x3b,0xb,0x9e,0x44,
0xe,0x8a,0x26,0x50,0xd3,0xb4,0x6f,0x0,0x34,0xb7,0xb4,0x0,0xa4,0x9,0x9c,0x4e,
0x87,0x62,0xb1,0x18,0x8b,0x9b,0x9b,0x27,0xcd,0xd6,0xc4,0xe3,0x71,0xce,0x9e,0x39,
0xc3,0xd9,0x33,0x67,0xf8,0xf5,0xfe,0xfd,0x6c,0x7f,0xee,0x39,0x7e,0xf1,0xfa,0xeb,
0xe9,0x35,0xd6,0x8c,0xcf,0x6,0x6,0x38,0xf8,0xe1,0x87,0x7c,0x68,0x10,0x76,0xf2,
0xc4,0x89,0xac,0x38,0xbc,0xd2,0xe3,0x49,0x7e,0xc8,0xd1,0xbe,0x2c,0x8,0x41,0x22,
0x91,0x40,0xd3,0x34,0xda,0xda,0xda,0x38,0x70,0xe0,0x80,0xa7,0xbd,0xbd,0xbd,0x6e,
0xe7,0xce,0x9d,0x45,0xe7,0x5,0x8b,0x26,0x30,0xe5,0x40,0x9a,0x9a,0x9a,0x0,0xa,
0xd6,0xc0,0xcf,0x3e,0xfb,0xac,0xe0,0x54,0x57,0x4f,0x4f,0xf,0x7f,0xfd,0xf0,0xc3,
0xec,0xde,0xbb,0x37,0x9d,0xb0,0x0,0x58,0xbb,0x7a,0x35,0xa7,0xbb,0xbb,0xf3,0xbe,
0x1b,0xe8,0xed,0x9d,0x54,0xfb,0xb2,0xbc,0x32,0xc9,0x75,0x50,0x3,0x96,0x2d,0x5b,
0xc6,0x81,0x3,0x7,0x10,0x42,0x6c,0x0,0x5e,0x2c,0x48,0x40,0x13,0xac,0xac,0x81,
0x4b,0x1,0x3c,0x86,0x3,0x89,0xc7,0xe3,0x5,0xad,0x7d,0xfd,0x7d,0x7d,0x94,0x94,
0x94,0xf0,0xd0,0xe6,0xcd,0xfc,0xec,0x57,0xbf,0xe2,0xbd,0x83,0x7,0x39,0xdd,0xd3,
0xc3,0xeb,0x6f,0xbe,0xc9,0x93,0x4f,0x3d,0x45,0xd3,0xcd,0x37,0x67,0xb5,0x3f,0x71,
0xe2,0x4,0xff,0xf7,0xdb,0xdf,0x66,0x95,0x4d,0xf6,0x5,0x68,0x5a,0xb6,0xe,0x4,
0x2,0x81,0x69,0xb5,0x4f,0x90,0x71,0x24,0x26,0x2d,0xff,0x76,0x1,0xd3,0x98,0x38,
0x7e,0xb1,0x2f,0xa4,0x1d,0x88,0xcb,0x95,0xe5,0x40,0xa6,0x43,0x43,0x43,0x3,0x87,
0x3e,0xfe,0x98,0xca,0xca,0xca,0xac,0xf2,0xdb,0x57,0xaf,0xe6,0xf6,0xd5,0xab,0xd9,
0xf4,0xc0,0x3,0xdc,0xbe,0x7c,0x79,0x96,0x39,0xf6,0xf7,0xf7,0xb3,0xac,0xad,0x2d,
0xfd,0xef,0xba,0xba,0x3a,0x86,0x82,0x41,0x56,0xac,0x5c,0xc9,0xed,0x77,0xdc,0xc1,
0x1d,0x6b,0xd6,0x10,0xc,0x6,0x79,0x70,0xd3,0xa6,0x74,0x9b,0xa1,0x60,0x90,0xf1,
0xf1,0x71,0x9c,0x4e,0xa7,0x59,0xe6,0x8c,0x93,0x49,0x16,0xa4,0x9d,0x97,0xd3,0xe5,
0x62,0xf6,0x9c,0x39,0x8c,0x8e,0x8c,0xac,0x28,0x8a,0x8,0x3,0x45,0x11,0xe8,0xf3,
0xf9,0x1a,0x35,0x4d,0xb3,0x99,0x1d,0x48,0xa1,0xfe,0xb3,0xa6,0xb6,0x36,0x6f,0x7d,
0x43,0x43,0x3,0x73,0xe6,0xcc,0x61,0x78,0x78,0x38,0x5d,0xb6,0x68,0x51,0x76,0xae,
0xf3,0xc7,0x7e,0x3f,0x55,0xc6,0x99,0x4b,0x8a,0x94,0x33,0x67,0xce,0x4c,0xe8,0xab,
0xaf,0xb7,0x97,0x5b,0x16,0x2c,0xc8,0xd6,0x3e,0x21,0x26,0x68,0x66,0x42,0xd7,0xd1,
0x54,0x95,0x55,0xab,0x56,0xf1,0x5f,0x7b,0xf6,0xb8,0xb7,0x6d,0xdb,0xd6,0xec,0xf7,
0xfb,0x4f,0x14,0x38,0x25,0xa0,0x78,0x13,0xde,0x0,0xd0,0x62,0x44,0x20,0x57,0x72,
0xff,0x77,0xfc,0x93,0x4f,0xb2,0xc8,0xbb,0x6d,0xd9,0xb2,0x9,0x66,0x5d,0x53,0x5b,
0x9b,0xed,0x9d,0x85,0xc0,0xeb,0xf5,0x4e,0xe8,0x2b,0xd0,0xd7,0x67,0x6a,0x32,0x51,
0xfb,0x52,0x48,0x69,0xfb,0x92,0x25,0x4b,0x0,0x90,0x52,0x6e,0x2c,0x56,0xee,0xa2,
0x8,0x14,0x42,0x7c,0xd,0x32,0xeb,0x46,0xf4,0xa,0x10,0x38,0x34,0x34,0xc4,0x9e,
0xdd,0xbb,0x79,0xf8,0x81,0xcc,0x56,0xac,0xac,0xac,0x8c,0x9f,0xec,0xdc,0x39,0xb5,
0x1c,0x64,0x8,0x71,0x38,0x9d,0x54,0xe4,0x2c,0xb,0x81,0xf3,0xe7,0xa7,0xd5,0x3e,
0x0,0xdd,0xd8,0x7f,0xd6,0x1a,0xd6,0x21,0xa5,0xfc,0xcb,0x62,0xe5,0x2f,0xca,0x84,
0x85,0x10,0x13,0x1c,0x48,0x31,0x38,0x75,0xf2,0x24,0x2f,0xfd,0xf4,0xa7,0x0,0x4,
0x83,0x41,0x8e,0x1d,0x3d,0x4a,0x5f,0x20,0x90,0xd5,0x66,0xcd,0xda,0xb5,0x6c,0xdf,
0xb1,0x83,0xfa,0xfa,0xfa,0x7c,0x82,0x24,0xff,0x18,0x8f,0xd7,0xeb,0x65,0x28,0x18,
0x4c,0x57,0x7,0x8c,0x3e,0xf3,0x69,0x9f,0x10,0x2,0x8c,0x75,0xd0,0x6e,0xb3,0xe1,
0xf5,0x7a,0xe9,0xeb,0xeb,0x5b,0xb4,0x69,0xd3,0x26,0xf5,0xd5,0x57,0x5f,0x2d,0x78,
0x71,0x2f,0x96,0x40,0xaf,0xaa,0xaa,0xb8,0x5d,0x2e,0x4b,0xe6,0xfb,0xbf,0x47,0x8e,
0xf0,0xaf,0x2f,0xbf,0x3c,0x69,0xdd,0x82,0x85,0xb,0xf9,0xa7,0xef,0x7e,0x97,0x75,
0xeb,0xd7,0xe7,0x3d,0x16,0xcd,0x8a,0x38,0xc,0x42,0xbc,0x5e,0x2f,0x47,0x3f,0xfe,
0x38,0xdd,0xa6,0xb7,0xb7,0xd7,0x2c,0x74,0xd6,0x7b,0xb9,0x9a,0xa9,0xeb,0x3a,0xaa,
0xb1,0xe,0xbe,0xf6,0xda,0x6b,0x36,0x8f,0xc7,0xf3,0x15,0xe0,0xfd,0x42,0xe7,0x54,
0xb0,0x9,0xfb,0x7c,0xbe,0x3a,0x45,0x51,0xec,0x56,0x22,0x90,0x14,0x7a,0xcf,0x9f,
0x9f,0xb2,0xae,0xfb,0xd4,0x29,0xbe,0xb3,0x79,0x33,0x2b,0xda,0xda,0x78,0x7b,0xcf,
0x9e,0xa9,0x3b,0x99,0x84,0x10,0x6f,0x8e,0xb6,0x6,0x2,0x81,0x89,0xe1,0x5d,0xee,
0x9e,0xd0,0xa8,0x4b,0x99,0x71,0x2a,0x30,0x90,0x52,0x3e,0x5c,0xcc,0x9c,0xa,0xd6,
0x40,0x45,0x51,0xee,0x91,0x52,0xd2,0x92,0x13,0x81,0x14,0x83,0x3f,0xbd,0xf3,0x4e,
0xaa,0x6b,0x6a,0x48,0x24,0x12,0x9c,0xff,0xdd,0xef,0x38,0xdd,0xdd,0xcd,0xa7,0xa7,
0x4f,0x13,0x8,0x4,0xd2,0xb,0x7a,0x5f,0x20,0xc0,0x77,0x36,0x6f,0xe6,0xa5,0x97,
0x5f,0xe6,0xeb,0x1b,0x36,0x64,0xbd,0x3f,0x15,0x21,0xb9,0x4,0xa6,0xbf,0xa8,0x69,
0xb4,0xf,0x4c,0x7,0xed,0x1e,0xf,0x22,0xa9,0x91,0xdf,0x4,0x3a,0xa,0x9d,0x53,
0x31,0x26,0xbc,0xe,0xa0,0xb1,0xc8,0x8,0xc4,0x8c,0x95,0xab,0x56,0xb1,0x72,0xd5,
0xaa,0x9,0xe5,0xa3,0x23,0x23,0x3c,0xfc,0xe0,0x83,0x1c,0x3e,0x74,0x28,0x5d,0xf6,
0xfd,0x67,0x9f,0x9d,0x40,0xe0,0x54,0x84,0xe4,0xae,0x97,0xfd,0xfd,0xfd,0x48,0x5d,
0x47,0x51,0xd5,0x49,0x63,0xe1,0xdc,0xc4,0x83,0x2e,0x25,0x8a,0xa2,0xb0,0x6e,0xdd,
0x3a,0xf6,0xee,0xdd,0xeb,0xdd,0xb6,0x6d,0xdb,0xed,0x7e,0xbf,0xff,0xbd,0x42,0xe6,
0x54,0x8c,0x17,0xbe,0xd,0xc0,0x53,0x59,0x99,0x74,0x20,0x45,0x6c,0xa2,0xa7,0xc3,
0xec,0x39,0x73,0x78,0xfc,0xc9,0x27,0xb3,0xca,0x72,0xcd,0x3d,0x9f,0x39,0xd6,0xe7,
0x6c,0x65,0x62,0xb1,0x18,0x9f,0x5d,0xb8,0x90,0x79,0xcf,0x94,0x89,0x21,0xd5,0x87,
0xa9,0x4e,0x1a,0xda,0x7f,0xd7,0x5d,0x77,0x1,0xa0,0xeb,0xfa,0x3f,0x16,0x2a,0x7b,
0xc1,0x4,0xa,0x21,0x1a,0x34,0x4d,0xc3,0x65,0xd1,0x81,0x4c,0x87,0x68,0xce,0x91,
0x40,0x43,0x43,0x43,0xae,0x0,0xc9,0x3f,0x4c,0x34,0xc7,0x5c,0x13,0x86,0x64,0x4c,
0x5c,0x88,0xf6,0x41,0x32,0x11,0x22,0xa5,0xa4,0xb4,0xb4,0x94,0xe6,0xe6,0x66,0x84,
0x10,0x7f,0xde,0xde,0xde,0xde,0x54,0x88,0xdc,0x5,0x11,0xe8,0xf3,0xf9,0xe6,0x2a,
0x8a,0x52,0xd2,0xda,0xda,0x5a,0xb4,0x3,0x39,0xfe,0xc9,0x27,0x84,0xc3,0xe1,0xbc,
0x6d,0x2e,0x5d,0xba,0x44,0xa7,0xdf,0x9f,0x55,0xf6,0x57,0x1b,0x33,0x7b,0xda,0x49,
0x73,0x7d,0x64,0x8,0xf1,0x78,0x3c,0x38,0x4c,0xa1,0x1b,0x18,0x8e,0x84,0xc9,0x63,
0xe1,0x74,0x9f,0xa6,0xe4,0x42,0x2a,0xa2,0xba,0xef,0xbe,0xfb,0x20,0xc9,0xcb,0x63,
0x79,0x85,0x36,0x50,0xa8,0x6,0x7e,0x5d,0x4a,0x39,0x21,0x85,0x55,0x8,0x76,0xfa,
0xfd,0x7c,0x79,0xe9,0x52,0xb6,0x3f,0xf7,0x1c,0x47,0xe,0x1d,0xe2,0xf7,0x46,0xb4,
0x31,0x3c,0x3c,0xcc,0xfe,0x7d,0xfb,0xd8,0xf1,0x83,0x1f,0xf0,0xcd,0x7b,0xee,0xe1,
0x88,0x69,0xfd,0xab,0xae,0xa9,0xe1,0x5b,0xf7,0xdf,0x9f,0xe9,0x24,0x77,0xd2,0x93,
0x98,0xa3,0xb7,0xae,0x2e,0x6b,0x5c,0xf3,0x56,0x26,0xeb,0xac,0xc4,0xf4,0x4e,0xea,
0x7d,0x1,0xe9,0xa3,0xcf,0xba,0xba,0x3a,0xe6,0xcf,0x9f,0x8f,0xa2,0x28,0xbe,0xad,
0x5b,0xb7,0xb6,0x4c,0x37,0xbf,0x82,0x9c,0x88,0x10,0x62,0x3d,0x64,0x22,0x90,0x62,
0x8,0xec,0xb,0x4,0x18,0x1d,0x19,0xe1,0x87,0xdb,0xb7,0xf3,0xc3,0xed,0xdb,0x1,
0x70,0xbb,0xdd,0x53,0x6a,0x65,0x53,0x53,0x13,0xbf,0x7c,0xe3,0xd,0xaa,0xaa,0xaa,
0x92,0x63,0x67,0x84,0xc8,0x95,0x29,0x8b,0x10,0x6f,0x7d,0x3d,0x9f,0x7e,0xfa,0x69,
0xba,0x3e,0xd0,0xdb,0x5b,0xb0,0xf6,0x99,0x3d,0xb2,0x10,0x82,0xf6,0xf6,0x76,0x9e,
0x7e,0xfa,0x69,0x97,0x94,0x72,0xf7,0x96,0x2d,0x5b,0x96,0x3f,0xff,0xfc,0xf3,0x41,
0xa6,0x40,0x41,0x1a,0x28,0x84,0x58,0x6,0x50,0x69,0xc1,0x81,0xf4,0xf5,0x4d,0xcc,
0x51,0x4e,0x46,0x9e,0xcb,0xe5,0x62,0xf3,0x23,0x8f,0xf0,0xe6,0xee,0xdd,0xd9,0xeb,
0xdf,0x34,0xa9,0x29,0x8c,0xba,0x5c,0x4f,0x7c,0xde,0x70,0x42,0xb9,0x79,0xc0,0x7c,
0x29,0xff,0x14,0x9c,0x4e,0x27,0x4f,0x3d,0xf5,0x94,0x0,0x9a,0x54,0x55,0xfd,0xf7,
0xc7,0x1e,0x7b,0xac,0x64,0xaa,0xf9,0x15,0xaa,0x81,0x8d,0x36,0x9b,0xd,0x97,0xd3,
0x59,0xb4,0x3,0x79,0xad,0xab,0x8b,0xb7,0xf7,0xec,0x61,0xff,0xbe,0x7d,0xc,0xf4,
0xf7,0x13,0xc,0x6,0x9,0x85,0x42,0x54,0x55,0x55,0x51,0x53,0x53,0x43,0x6d,0x6d,
0x2d,0xcb,0x57,0xac,0x60,0xe3,0xfd,0xf7,0x4f,0xb8,0x63,0x33,0x5d,0x62,0xd4,0x6c,
0x8e,0x4d,0x37,0xdf,0x4c,0x49,0x49,0x66,0x9e,0x17,0x7,0x7,0x73,0x27,0x91,0x77,
0x3f,0x48,0x4e,0x79,0x63,0x63,0x23,0xdb,0xb6,0x6d,0xc3,0xef,0xf7,0xaf,0x89,0xc5,
0x62,0xef,0x6d,0xdd,0xba,0xf5,0xdb,0xbb,0x76,0xed,0x3a,0x9d,0x3b,0xbf,0x69,0xef,
0xc6,0xf8,0x7c,0xbe,0x4a,0x4d,0xd3,0x2e,0xde,0x7a,0xeb,0xad,0x6c,0xd9,0xb2,0x85,
0xf0,0xe5,0xcb,0x8c,0x4d,0xe3,0x14,0xae,0x14,0x72,0xcf,0x78,0x31,0x7d,0x2e,0xe4,
0xfc,0xd7,0xfc,0x39,0x5f,0x9d,0xb9,0xef,0x5c,0x9c,0x39,0x73,0x86,0x1d,0x3b,0x76,
0x20,0xa5,0xc,0xe9,0xba,0xfe,0x2f,0x8a,0xa2,0x3c,0xef,0xf7,0xfb,0x43,0xa9,0xfa,
0x69,0x4d,0x58,0x55,0xd5,0xbb,0x1,0x9a,0xaf,0x42,0xa,0x2b,0x1f,0xa6,0xd3,0xbe,
0xdc,0xba,0xbc,0x1a,0x56,0xa4,0xf6,0x99,0x31,0x6f,0xde,0x3c,0x9e,0x79,0xe6,0x19,
0xec,0x76,0xfb,0x2c,0x21,0xc4,0x76,0x29,0xe5,0x7f,0xa,0x53,0xe3,0x42,0x4c,0xf8,
0x1e,0x80,0x46,0x63,0x5d,0xba,0x66,0x67,0xc0,0xd3,0xac,0x7d,0x85,0x10,0x92,0x36,
0xf3,0x3c,0x75,0x53,0x11,0x97,0x82,0x94,0x92,0x63,0xc7,0x8e,0x11,0x89,0x44,0x10,
0x42,0x9c,0x50,0x55,0x75,0xa3,0x34,0x99,0xed,0xb4,0x4,0x4a,0x29,0x97,0x9,0x21,
0x32,0x29,0xac,0x2b,0x18,0x81,0x4c,0x85,0xe9,0x26,0x9d,0xaf,0x6e,0xca,0x88,0x63,
0x8a,0x3a,0x72,0xcb,0x4d,0x8,0x4,0x2,0xbc,0xf2,0xca,0x2b,0x32,0x10,0x8,0x8,
0x29,0xe5,0xeb,0x52,0xca,0x6d,0x7e,0xbf,0xff,0xa2,0xb9,0xcd,0xb4,0x4,0xa,0x21,
0x9a,0x6c,0x76,0x3b,0x2e,0xa7,0x93,0xe8,0xb5,0xba,0x40,0x7e,0x5,0xcc,0x31,0x5f,
0xe8,0xa7,0xa4,0xd6,0x3d,0xf3,0x72,0x60,0x40,0xd7,0x75,0x4e,0x9d,0x3a,0xc5,0x1b,
0x6f,0xbc,0x41,0x7f,0x7f,0x3f,0xc0,0x59,0x5d,0xd7,0xdb,0x77,0xed,0xda,0xf5,0xce,
0x64,0xa2,0xe6,0x25,0xd0,0xe7,0xf3,0x95,0x6b,0x9a,0xe6,0x4a,0x5d,0x22,0x2,0x70,
0x99,0x8e,0x19,0xaf,0x16,0xcc,0x37,0xaa,0x26,0x4c,0x34,0x87,0x1c,0x61,0x7a,0x27,
0x95,0x47,0x9c,0xe0,0x40,0x98,0x5a,0xcb,0x74,0x5d,0x67,0x64,0x64,0x84,0x9e,0x9e,
0x1e,0x8e,0x1c,0x39,0xc2,0xd1,0xa3,0x47,0xd1,0x75,0x1d,0xbb,0xdd,0x8e,0xae,0xeb,
0x24,0x12,0x89,0x7f,0x78,0xf1,0xc5,0x17,0x27,0x25,0xf,0xa6,0x21,0x50,0x51,0x94,
0xaf,0x1,0x34,0x37,0x37,0x3,0x60,0xb7,0xd9,0xb0,0xdb,0x6c,0xd3,0x12,0xf0,0x79,
0x82,0x94,0x12,0x5d,0xd7,0x89,0xc7,0xe3,0x44,0x22,0x11,0xc2,0xe1,0x30,0x63,0x63,
0x63,0xf4,0xf4,0xf4,0x70,0xec,0xd8,0x31,0xce,0x9d,0x3b,0x97,0x6e,0xab,0x69,0x1a,
0x42,0x8,0x34,0x4d,0x63,0xfd,0xfa,0xf5,0x74,0x75,0x75,0x61,0x9c,0x83,0xff,0xc7,
0x54,0xfd,0xe7,0x25,0x50,0x4a,0x79,0xf,0xc0,0xa1,0x83,0x7,0x53,0xea,0x7c,0xd5,
0x91,0x7f,0x49,0x67,0x62,0x44,0x62,0xfc,0x8d,0xc7,0xe3,0x84,0x2f,0x5d,0x22,0xf4,
0x87,0x3f,0x30,0x36,0x36,0xc6,0xe8,0xe8,0x28,0xe3,0xe3,0xe3,0x79,0xef,0xdd,0x38,
0x1c,0xe,0x2a,0x2b,0x2b,0x29,0x2b,0x2b,0xa3,0xb4,0xb4,0x14,0x97,0xcb,0xc5,0xb9,
0x73,0xe7,0xd2,0x97,0x0,0xdc,0x6e,0xb7,0xc,0x87,0xc3,0x77,0xe7,0x15,0x27,0xdf,
0x0,0x5b,0xb7,0x6e,0xfd,0x48,0x51,0x94,0xa5,0xe,0x87,0x83,0x48,0x24,0x82,0xaa,
0xaa,0x59,0x9b,0xd5,0xc9,0x50,0xcc,0x45,0xa1,0x42,0xdb,0x16,0xd3,0xa7,0xaa,0xaa,
0xa8,0xaa,0x8a,0xa2,0x28,0xe9,0xcf,0xaa,0xaa,0xa2,0x69,0x1a,0x4e,0xa7,0x13,0x87,
0xc3,0x91,0xfe,0x6d,0x9f,0x10,0x99,0xf3,0xe1,0xd4,0x33,0x3c,0x3c,0xcc,0xa9,0x53,
0xa7,0x58,0xb2,0x64,0x9,0x97,0x2f,0x5f,0xe6,0xc4,0x89,0x13,0x0,0xd,0x2f,0xbc,
0xf0,0x42,0xef,0x64,0xe3,0xe5,0xd5,0x40,0x5d,0xd7,0xdd,0x36,0x9b,0x4d,0x6e,0xd8,
0xb0,0x41,0x74,0x75,0x75,0x51,0x5f,0x5f,0xcf,0xc6,0x8d,0x1b,0xd3,0x66,0x91,0x3b,
0xf8,0x64,0x4f,0x21,0xed,0xae,0x64,0x5f,0xc5,0x8e,0x99,0xb,0x9b,0xb1,0x44,0x85,
0x42,0x21,0xea,0xeb,0xeb,0x53,0x4,0xae,0x3,0x5e,0x2a,0x8a,0x40,0x9f,0xcf,0x57,
0x6,0xcc,0xf7,0x78,0x3c,0xc2,0x6e,0xb7,0x63,0xb3,0xd9,0xe8,0xe9,0xe9,0xe1,0xf0,
0xe1,0xc3,0xb4,0xb4,0xb4,0xa0,0xaa,0x6a,0x51,0x93,0x1,0x66,0x34,0x61,0x2b,0xed,
0x8a,0x1d,0x33,0x14,0xa,0xa5,0x63,0xe8,0xea,0xea,0x6a,0xe6,0xce,0x9d,0x8b,0x91,
0xe6,0x5f,0x5f,0x14,0x81,0x42,0x8,0xf5,0xa1,0x87,0x1e,0x5a,0xe1,0x74,0x3a,0x85,
0xc7,0xe3,0xc9,0x12,0x68,0xdf,0xbe,0x7d,0xec,0xdb,0x67,0xf9,0x4a,0xf1,0x17,0x6,
0xe1,0x70,0x18,0xbb,0xdd,0x8e,0xc7,0xe3,0x91,0x83,0x83,0x83,0xeb,0x3c,0x1e,0x8f,
0x2b,0x18,0xc,0x46,0xa4,0x94,0x59,0x1b,0xe1,0x9,0x4,0xa,0x21,0x6c,0x80,0x5d,
0x51,0x94,0xe5,0x0,0x15,0x15,0x15,0x44,0xa3,0x51,0x62,0xb1,0x18,0xf5,0xf5,0xf5,
0xd4,0xd6,0xd6,0x72,0xe1,0xc2,0x85,0x19,0x5f,0x8a,0xfc,0x3c,0xa2,0xa4,0xa4,0x84,
0x8a,0x8a,0xa,0xde,0x7f,0xff,0x7d,0x6,0x6,0x6,0x58,0xbc,0x78,0x31,0xf5,0xf5,
0xf5,0x62,0x70,0x70,0xb0,0x7c,0xcd,0x9a,0x35,0x2b,0xba,0xba,0xba,0xe,0xa,0x21,
0xa2,0x52,0xca,0xf4,0x86,0x38,0x8b,0x40,0x83,0xbc,0x12,0x92,0x4,0xb6,0x1,0x94,
0x97,0x97,0x13,0x8b,0xc5,0x50,0x14,0x85,0xb1,0xb1,0x31,0xd6,0xae,0x5d,0xcb,0x2d,
0xb7,0xdc,0x72,0x6d,0x67,0x76,0xd,0x91,0x4a,0xc4,0xa6,0x2e,0xe,0xd4,0xd4,0xd4,
0x0,0xe0,0x76,0xbb,0xef,0x6,0x8e,0x2,0xc2,0x70,0x3e,0x31,0x30,0x11,0x28,0x84,
0x50,0x1,0xbb,0xf1,0x94,0xa8,0xaa,0xba,0xc4,0x6e,0xb7,0x4b,0x97,0xcb,0x25,0x86,
0x86,0x86,0x28,0x2f,0x2f,0x67,0x68,0x68,0x88,0x77,0xde,0x79,0x87,0xc6,0xc6,0xc6,
0x9,0xd7,0xca,0x6e,0x4,0x8c,0x8c,0x8c,0x70,0xf6,0xec,0x59,0x20,0xa9,0x38,0xa1,
0x50,0x88,0x9b,0x6e,0xba,0x9,0x9b,0xcd,0x26,0xe3,0xf1,0xf8,0x57,0x81,0x1f,0x1b,
0x4d,0xa5,0x10,0x42,0x97,0x52,0x26,0xcc,0x2c,0xd8,0x48,0x12,0xaa,0x79,0xbd,0xde,
0xd9,0x8a,0xa2,0xcc,0xf3,0x78,0x3c,0x42,0x8,0x41,0x34,0x1a,0xa5,0xb2,0xb2,0x92,
0x68,0x34,0xca,0x85,0xb,0x17,0xb8,0x60,0x9c,0x78,0xdd,0x88,0xb0,0xd9,0x6c,0x54,
0x57,0x57,0x63,0xb7,0xdb,0xd3,0x3f,0x1e,0xaf,0xab,0xab,0x13,0x3d,0x3d,0x3d,0xcb,
0xbc,0x5e,0xef,0xec,0x40,0x20,0x30,0xc,0x24,0x48,0xf2,0x95,0x24,0x50,0x8,0xa1,
0x90,0x4c,0x6d,0xa9,0x80,0xd6,0xd2,0xd2,0xb2,0x18,0x10,0x15,0x15,0x15,0x18,0xf5,
0xd8,0x6c,0x36,0x1a,0x1b,0x1b,0x89,0xc5,0x62,0x5c,0xba,0x74,0xe9,0xfa,0xcc,0xee,
0x2a,0x43,0x55,0x55,0xdc,0x6e,0x77,0x3a,0x14,0x4c,0x1d,0xf6,0x57,0x57,0x57,0xd3,
0xd3,0xd3,0x63,0x5b,0xba,0x74,0xe9,0xaa,0x40,0x20,0xf0,0x36,0x10,0x7,0x14,0x21,
0x84,0x92,0xd2,0x40,0xc5,0xfc,0xd8,0xed,0xf6,0x72,0xc8,0xfc,0xaa,0x5b,0xd3,0x34,
0x66,0xcd,0x9a,0x45,0x34,0x1a,0xc5,0x66,0xb3,0xe1,0x72,0x7d,0x91,0xfe,0x83,0x8e,
0xe2,0xa1,0xaa,0x2a,0xe,0x87,0x23,0x1d,0x3f,0xcf,0x99,0x93,0xfc,0x19,0x89,0xd3,
0xe9,0x6c,0x22,0x87,0xab,0x49,0x17,0xb2,0xf1,0xf1,0xf1,0xdf,0x43,0xf2,0xea,0x19,
0x24,0x8f,0xd,0x3d,0xc6,0xe5,0xed,0xc4,0x35,0x48,0x67,0x5d,0x4f,0x98,0x93,0x12,
0x29,0xa4,0xce,0x70,0x12,0x89,0x44,0x6e,0x2a,0x5e,0xa6,0x8,0xd4,0xcd,0xcf,0xbb,
0xef,0xbe,0x7b,0xe4,0x91,0x47,0x1e,0x39,0xdc,0xdd,0xdd,0xfd,0x65,0x5d,0xd7,0xa9,
0xae,0xae,0x4e,0xef,0xd0,0xff,0xd8,0x30,0x3a,0x3a,0xca,0xf1,0xe3,0xc7,0x25,0x10,
0xed,0xee,0xee,0xfe,0x6f,0xb2,0xb9,0x92,0xe9,0x58,0x58,0x8,0xe1,0x20,0xb9,0x85,
0x71,0x0,0x25,0xad,0xad,0xad,0xf5,0x6d,0x6d,0x6d,0xcf,0x96,0x94,0x94,0xdc,0x71,
0x9d,0x64,0xff,0x3c,0x21,0xd2,0xd7,0xd7,0xf7,0x77,0x6f,0xbd,0xf5,0xd6,0x5e,0x92,
0xbf,0x70,0x1f,0x7,0xc6,0xa5,0x94,0x11,0x33,0x81,0x1a,0x49,0x2,0xcd,0x8f,0xfd,
0xb6,0xdb,0x6e,0x9b,0x5f,0x55,0x55,0xd5,0xac,0xaa,0xea,0x6c,0x29,0xa5,0x2a,0xa5,
0x54,0x84,0x10,0x9,0xa,0x48,0x9c,0x7c,0xc1,0x20,0xa5,0x94,0x2a,0x80,0x10,0x42,
0x17,0x42,0x24,0x14,0x45,0x49,0x44,0x22,0x91,0xfe,0x8f,0x3e,0xfa,0xe8,0xc3,0x60,
0x30,0x38,0x46,0x92,0xbc,0xd4,0x73,0x59,0x4a,0xa9,0x67,0x65,0x63,0x84,0x10,0xe9,
0x7d,0x20,0x99,0x3d,0xa1,0x8d,0xcc,0x16,0x47,0x25,0xb9,0x78,0xea,0xdc,0x80,0x4,
0x92,0x9c,0x9f,0x24,0x39,0xbf,0x4,0x49,0x6f,0x1b,0x33,0x9e,0xa8,0xf1,0x44,0x80,
0x4b,0x52,0x4a,0x1d,0x72,0x22,0x11,0x29,0x65,0x54,0x8,0x91,0x62,0x34,0xb7,0x13,
0x8d,0x8c,0xf7,0xb9,0xf1,0xe2,0xb8,0x24,0x52,0x73,0x4b,0xad,0x71,0x71,0x26,0x92,
0x78,0xc9,0x7c,0xa8,0x34,0x69,0x3e,0xd0,0xd8,0x17,0x9a,0xb5,0x4f,0x25,0xa3,0x7d,
0x7f,0x4c,0x4,0x26,0x8c,0x27,0x46,0x52,0xf3,0xa2,0xb9,0x7c,0xe5,0x4d,0xa8,0x1a,
0x44,0xe6,0x9a,0xaf,0xe0,0xc6,0x25,0xd0,0x7c,0x59,0x2b,0xa5,0x81,0x51,0x20,0x3e,
0x15,0x4f,0x5,0xff,0xaf,0x1d,0xc6,0x61,0x72,0x4a,0x3,0x6f,0x64,0xa4,0xc8,0x93,
0xb2,0x0,0x72,0xfe,0x1f,0x3a,0x27,0xe8,0x76,0x3,0x89,0x6b,0x5e,0x0,0x0,0x0,
0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/newdrone18/workspace/qtbook-master/20.02.27_Qt_Programming_Korean_v1.4_Example_Source_code/Ch03/01_BasicWidget/01_QCheckBox/resources/browser.png
0x0,0x0,0x18,0xe8,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x3b,0x0,0x0,0x0,0x40,0x8,0x6,0x0,0x0,0x0,0xa4,0xc0,0xf,0xb1,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0x14,0x3a,0x0,0x0,0x14,0x3a,
0x1,0xe2,0x93,0x5f,0x67,0x0,0x0,0x0,0x19,0x74,0x45,0x58,0x74,0x53,0x6f,0x66,
0x74,0x77,0x61,0x72,0x65,0x0,0x77,0x77,0x77,0x2e,0x69,0x6e,0x6b,0x73,0x63,0x61,
0x70,0x65,0x2e,0x6f,0x72,0x67,0x9b,0xee,0x3c,0x1a,0x0,0x0,0x18,0x65,0x49,0x44,
0x41,0x54,0x68,0x81,0xc5,0x9b,0x7b,0x74,0x5c,0xc5,0x9d,0xe7,0x3f,0x55,0xb7,0xdf,
0x2d,0xa9,0xd5,0xad,0xb7,0x64,0xc9,0xb6,0x2c,0x1b,0xdb,0xd8,0xc6,0xc4,0x36,0x98,
0x6,0xc,0xe6,0xd,0xc9,0x10,0x20,0xc9,0x3c,0xb2,0xd9,0x24,0x27,0xcb,0xd9,0xdd,
0x99,0x1c,0xed,0xec,0xec,0xec,0x64,0x13,0x96,0x4c,0x66,0x77,0xe6,0xcc,0x23,0xc9,
0xfc,0x31,0x51,0x26,0x13,0xb2,0x27,0x64,0x26,0x8f,0x99,0x84,0x40,0x2,0x87,0xa7,
0x4d,0x30,0xf,0xe3,0xc6,0x60,0x1b,0xcb,0xf8,0x89,0x2d,0x59,0x7e,0x60,0xc9,0x7a,
0x5a,0xaf,0x7e,0xdd,0xbe,0x55,0xb5,0x7f,0x74,0xdf,0x56,0x77,0x5b,0x32,0x86,0x25,
0x67,0xeb,0x9c,0xdf,0xa9,0xba,0xdd,0x7d,0xaf,0xea,0x53,0xdf,0x5f,0x55,0xfd,0xaa,
0xea,0x4a,0x18,0x63,0xf8,0x6d,0xa4,0x78,0xbc,0x7b,0x3,0x10,0x7,0x5a,0x81,0x36,
0x21,0x44,0x9b,0x10,0x62,0xb1,0x31,0xa6,0x19,0xf0,0x8,0x21,0x86,0x8d,0x31,0x67,
0x8c,0x31,0xef,0x1,0xe7,0x80,0x41,0xe0,0x6d,0x60,0x67,0x22,0xd1,0xa3,0x7e,0x1b,
0x75,0x12,0x1f,0x15,0x6c,0x3c,0xde,0xed,0x5,0x6e,0x2,0x3e,0x29,0xa4,0x7c,0xc0,
0x68,0xdd,0x2a,0xa5,0x20,0x56,0x1f,0x75,0x9a,0x5b,0x1b,0x44,0x63,0x4b,0xbd,0x55,
0xdf,0x58,0x4b,0x2c,0x16,0x41,0x48,0xc1,0xd8,0xf8,0x14,0x63,0xc3,0x13,0x8c,0x9c,
0x1f,0x57,0xc3,0x83,0xa3,0x66,0x62,0x74,0xd2,0xa3,0xb5,0x46,0x8,0x31,0x69,0x8c,
0x79,0xa,0x78,0x12,0xd8,0x9e,0x48,0xf4,0xa4,0x3e,0x92,0xa,0xf2,0x11,0xc0,0xc6,
0xe3,0xdd,0xf5,0xc0,0xc3,0x42,0x88,0x2f,0x79,0xbd,0x9e,0xea,0xcf,0x7f,0xfe,0x16,
0xdd,0xb6,0xb8,0x49,0xd6,0xd4,0x37,0xd1,0xb5,0xa4,0x9,0x9f,0x57,0x62,0x49,0x10,
0xc6,0x20,0x5,0x8,0x1,0x99,0x6c,0xe,0x5b,0x4b,0x6c,0x5,0x5a,0x1b,0xb4,0x31,
0xe4,0x1c,0xc5,0xc9,0xd3,0xa3,0xbc,0xbd,0xf7,0x18,0xbb,0x5f,0xde,0xeb,0x8c,0x9e,
0x1f,0xf3,0x20,0x44,0x16,0x63,0x7e,0x5,0x7c,0x23,0x91,0xe8,0x39,0xf1,0xff,0xd,
0x36,0x1e,0xef,0xe,0x2,0x7f,0x22,0xa4,0x78,0x68,0xc5,0x8a,0x45,0xc1,0x3f,0xf9,
0xd3,0xcf,0xc8,0xa5,0x8b,0x9b,0x90,0x2,0x72,0x4a,0x21,0xa4,0x7,0x4b,0xa,0xc2,
0x41,0xff,0x82,0xcf,0xf8,0xf5,0xb,0xaf,0x92,0xab,0xee,0x44,0x1b,0x43,0xc8,0x67,
0xd1,0x54,0x1b,0x20,0x56,0xe5,0x43,0x19,0xc3,0xb9,0xa1,0xb,0x1c,0xe8,0x3d,0xc1,
0xf6,0x5f,0xbf,0xac,0x66,0xa6,0x66,0xc,0x86,0x47,0x80,0xff,0x9d,0x48,0xf4,0x8c,
0x7c,0x38,0xd4,0xf,0x1,0x1b,0x8f,0x77,0x5b,0xc0,0x17,0xa4,0x94,0x7f,0x2d,0x4,
0x8d,0xff,0xfe,0xc1,0x4f,0x8a,0xdf,0xbd,0xff,0x5a,0xa4,0x30,0xc,0x8d,0xcf,0x72,
0x21,0x6b,0xa1,0xec,0x34,0x9b,0xae,0x68,0xc1,0xeb,0xf5,0x2c,0xf8,0x1c,0x63,0xc,
0x7f,0xd3,0xf3,0xcf,0x6c,0xd8,0x72,0xf,0x39,0xa5,0x99,0x4d,0xe5,0x98,0x4c,0xda,
0xcc,0x66,0x1d,0x9a,0x23,0x7e,0x5a,0x62,0x41,0x1a,0x6a,0xfc,0x64,0xb2,0xe,0x2f,
0xef,0x78,0x9b,0x17,0x7e,0xb9,0x5d,0xdb,0xb6,0x93,0xc1,0x98,0xbf,0x5,0xfe,0xfe,
0xc3,0xb8,0xf7,0x7,0x82,0x8d,0xc7,0xbb,0xeb,0x84,0x10,0xbf,0x32,0xc6,0x6c,0xf9,
0xc4,0x3,0x5b,0xcd,0x83,0x5f,0xba,0x43,0x44,0x6b,0x42,0x8c,0x4e,0xce,0xd2,0x3f,
0x6e,0xb8,0x90,0x72,0xf0,0x5a,0x82,0x9a,0xa0,0x87,0xe4,0xe8,0x29,0x56,0xb4,0x45,
0x59,0xdc,0xb1,0x68,0xde,0x67,0xbd,0xb5,0x77,0x1f,0xa7,0xa6,0xbd,0xd4,0x35,0xb4,
0xe0,0x28,0x5d,0x34,0xdb,0xd1,0x8c,0x4c,0xa6,0x19,0x9b,0xce,0xe0,0xb1,0x4,0x57,
0xb6,0xd7,0xd2,0xd1,0x10,0x62,0x7a,0x26,0xcd,0xb6,0x67,0x13,0xbc,0xfe,0xc2,0x2e,
0xb4,0xe1,0x38,0xc6,0xdc,0x93,0x48,0xf4,0xf4,0xff,0x56,0x60,0xe3,0xf1,0xee,0xd5,
0x52,0xca,0xe7,0xae,0xbf,0x61,0x4d,0xfb,0xd7,0x1e,0xfa,0x3,0x19,0x8,0x4,0xd0,
0xca,0x41,0x6b,0x85,0x31,0x86,0xaa,0x70,0x98,0x5d,0x7b,0xe,0x50,0xd3,0xb2,0x2,
0x21,0xf2,0xf7,0xf8,0x74,0x8a,0x15,0xed,0x75,0x65,0xcf,0x31,0xc6,0xf0,0xf6,0xfe,
0x3,0xbc,0xf4,0xfa,0x1e,0xae,0xbb,0xfd,0x53,0x38,0x5a,0xe3,0x28,0x83,0x52,0xa,
0x47,0x99,0x2,0xb4,0x22,0x6d,0x2b,0xc6,0xa6,0x32,0x74,0xd6,0x7b,0xe9,0x88,0x59,
0x44,0xc2,0x41,0x6c,0x3c,0x9c,0x3d,0x3f,0xcd,0xf7,0xbe,0xfd,0x33,0x35,0x32,0x38,
0x36,0x8b,0x31,0xf,0x24,0x12,0x3d,0x3b,0x3e,0x52,0xd8,0x78,0xbc,0xfb,0x1e,0x21,
0xc5,0x63,0x9f,0xfd,0x77,0xb7,0x5,0x1e,0xfc,0xf,0x77,0x5b,0x7e,0x9f,0x97,0x83,
0x47,0xfb,0xb0,0xed,0x2c,0xcf,0xbf,0xde,0x4b,0xd7,0xaa,0xf5,0xc4,0xc4,0x24,0x37,
0xc5,0x37,0x72,0xe0,0x48,0x1f,0xde,0xda,0x56,0xaa,0x42,0x21,0x1a,0x43,0x39,0x6a,
0xaa,0xc2,0x0,0x8c,0x8c,0x8c,0xf2,0xd2,0x2b,0xaf,0x31,0x32,0x99,0x61,0xc5,0xba,
0x8d,0xc4,0xea,0x9b,0xf1,0x5a,0x82,0xd9,0x8c,0x83,0xa3,0x34,0x4a,0x69,0x72,0x25,
0xb9,0x25,0x61,0xeb,0xea,0x18,0xd5,0xe1,0x20,0xa9,0x54,0xa,0xad,0x35,0x0,0xc9,
0x54,0x86,0xa1,0xd1,0x9,0x7e,0xf6,0xaf,0xaf,0xeb,0x37,0x77,0xbe,0x63,0xb4,0x36,
0xdd,0x89,0x44,0xcf,0x3f,0x5d,0xe,0xac,0xbc,0xc,0xd0,0xff,0xc,0x3c,0xf3,0x77,
0xdf,0xfc,0x8f,0xa1,0x2f,0xff,0xe1,0xbd,0x96,0xdf,0xe7,0xe5,0xd5,0x5d,0x6f,0x50,
0x15,0xe,0xb2,0xed,0xb5,0x7d,0xdc,0x70,0xdb,0x27,0xb9,0xba,0xab,0x81,0xb5,0xab,
0x97,0xb3,0x7d,0xe7,0x3e,0xf6,0xf6,0xbe,0x43,0x28,0x18,0x44,0x4a,0x1,0x26,0x5f,
0xc1,0xe7,0xb7,0xbd,0xc8,0x8e,0xb7,0x8e,0xb0,0x66,0xf3,0x9d,0xdc,0x7c,0xf7,0x7d,
0x34,0xb7,0xb4,0x51,0xe3,0xb1,0xe9,0x8c,0x41,0xff,0x91,0x7d,0x58,0x52,0x20,0xa5,
0xc0,0x92,0x12,0x21,0x4,0x7e,0x8f,0xc5,0xaa,0x96,0x0,0x35,0x55,0x21,0xc6,0xc6,
0xc7,0xf9,0xab,0xef,0xfc,0x18,0x57,0x92,0x5d,0x7b,0xf,0x32,0x9c,0xf2,0xf1,0x3f,
0xbf,0xf2,0x69,0xf9,0x3f,0x1e,0xfa,0xa4,0x25,0xa5,0xf8,0x5e,0x3c,0xde,0xfd,0xf,
0x97,0x3,0x7b,0x49,0x65,0xe3,0xf1,0xee,0xbb,0x10,0x3c,0xfb,0x9d,0xef,0xfe,0xb1,
0xdc,0x78,0x75,0x17,0xb6,0x6d,0xf3,0xe8,0xcf,0x9e,0x20,0xd4,0x76,0x25,0xd5,0xd5,
0x35,0xb4,0x35,0xc5,0xa8,0x52,0x17,0x30,0xa1,0x28,0x87,0xdf,0x7e,0x8b,0x96,0xf6,
0x4e,0xda,0xda,0x3b,0xc0,0x80,0x11,0x30,0x3b,0x72,0x9a,0xc6,0xda,0x30,0x4f,0xbf,
0x94,0x60,0xcb,0x6d,0xf7,0xa0,0x35,0x28,0xad,0x51,0x5a,0x93,0x4a,0xa5,0x38,0x72,
0xe0,0x6d,0xae,0xb8,0x6a,0x13,0xc6,0x8,0x72,0x8e,0xc2,0x51,0x1a,0x83,0x61,0x73,
0x67,0x15,0x91,0xea,0xbc,0x47,0xfc,0xfd,0xf7,0x7e,0xc4,0xc7,0x6e,0xb8,0x8b,0xeb,
0x57,0xd6,0xe1,0x38,0xe,0xb9,0x5c,0x8e,0x99,0xd9,0x24,0xd5,0x55,0x61,0xa4,0x94,
0xbc,0xb9,0xe7,0x20,0xff,0xeb,0x1b,0x3f,0x47,0x6b,0xbe,0x92,0x48,0xf4,0x7c,0xeb,
0x43,0x29,0x1b,0x8f,0x77,0x5f,0x21,0xa4,0xf8,0xe5,0xc3,0x5f,0xff,0x3c,0x1b,0xaf,
0xee,0x62,0x64,0x74,0x9c,0xef,0xfe,0xeb,0x36,0x96,0x5d,0x73,0xf,0xed,0x4b,0x3a,
0xa9,0x6f,0x68,0x64,0x49,0xc4,0xb0,0xaa,0xab,0x83,0xb1,0x53,0x47,0xd9,0xb0,0x61,
0x3,0xed,0x8b,0x17,0x23,0xa5,0xc4,0xb2,0x24,0x1e,0x29,0x89,0x34,0x2d,0xe6,0x95,
0xb7,0xe,0xb1,0xf5,0xf6,0x8f,0x23,0xa5,0x44,0x16,0x14,0x94,0x42,0x10,0x8,0x86,
0xb8,0x6a,0x53,0x1c,0x8f,0x65,0x21,0x4,0x54,0x5,0x2c,0x2c,0xa9,0x31,0x6,0x1c,
0xc7,0xe1,0xc0,0x3b,0x87,0x0,0x88,0x45,0x6b,0x19,0x99,0xca,0xd0,0x7b,0xa4,0x1f,
0xcb,0xb2,0x90,0x52,0x12,0xa,0x6,0x48,0xa7,0xd3,0x64,0xb3,0x59,0xae,0xd9,0xb8,
0x86,0x2f,0x3e,0x78,0x33,0xc0,0xdf,0xc5,0xe3,0xdd,0x77,0x7f,0x60,0x65,0xe3,0xf1,
0xee,0x5a,0x21,0xe5,0xde,0x7b,0x3e,0xbe,0x79,0xc9,0x43,0x5f,0xfd,0x7d,0x4b,0x8,
0xc1,0xf1,0xbe,0x93,0xbc,0x97,0x8d,0x20,0xbc,0x7e,0xbc,0x96,0x45,0x38,0x60,0xb1,
0xbe,0xd5,0x5b,0xbc,0x67,0x66,0x76,0x96,0x63,0xef,0x4d,0xd2,0xda,0xd6,0xe,0x18,
0x8c,0x1,0x3,0x18,0x6d,0xd0,0x46,0xa3,0xb4,0x41,0x6b,0x93,0x57,0xb6,0x38,0x10,
0x69,0x1c,0x9d,0xef,0xa7,0x32,0x33,0xc9,0xd0,0xd9,0x7e,0x42,0xad,0x6b,0x19,0x3e,
0xd3,0x47,0xb4,0xbe,0x1,0x4f,0x7a,0x84,0x37,0xf6,0xbf,0xcb,0x7d,0xf7,0xdd,0xcb,
0xc7,0xba,0xea,0xc9,0xe5,0x72,0xe4,0x72,0x39,0x6c,0xdb,0x2e,0xe6,0x7e,0xbf,0x1f,
0x29,0x25,0x7f,0xfd,0xad,0x9f,0x9a,0x37,0x76,0xf6,0x27,0x31,0x66,0x53,0x22,0xd1,
0x73,0xec,0xb2,0x60,0xe3,0xf1,0x6e,0x29,0x84,0x78,0xbe,0xbd,0xa3,0xf1,0xb6,0x9f,
0xfe,0xe4,0x6b,0xd2,0xe3,0xb1,0x70,0x7f,0x63,0x8c,0x61,0xff,0xe1,0x13,0x78,0xa2,
0xed,0x2c,0xaf,0x93,0x4,0x3,0x73,0x1,0x83,0x6d,0xdb,0x1c,0x3e,0x7e,0x92,0x86,
0x8e,0x95,0x8,0x77,0x38,0x2e,0xdc,0x53,0x84,0xd4,0x6,0xad,0x4c,0x7e,0x4,0x2e,
0x40,0x3a,0x4a,0x53,0x2d,0xd3,0xbc,0x37,0x34,0xca,0xfa,0xe5,0x2d,0xbc,0x79,0x62,
0x92,0xba,0xba,0x5a,0x62,0xd6,0xc,0x83,0x53,0x86,0x58,0x24,0xc8,0xba,0xce,0x26,
0x0,0xb4,0xd6,0xd8,0xb6,0x5d,0x34,0x17,0x3e,0x14,0xa,0x91,0xc9,0x66,0xf9,0xaf,
0xff,0xfd,0x7,0x6a,0xe8,0xec,0xe4,0x69,0x8c,0xd9,0x90,0x48,0xf4,0x4c,0x56,0xc2,
0xce,0xe7,0xc6,0x9f,0x93,0x52,0xdc,0xf1,0xc8,0xf,0xfe,0x5b,0x19,0x28,0x80,0x10,
0x82,0xab,0x56,0x2d,0xa3,0x96,0xa9,0x32,0x50,0x0,0x9f,0xcf,0x47,0x73,0x7d,0x2d,
0xfb,0xde,0x4c,0x94,0xb7,0xa6,0x28,0xb8,0x6e,0xc1,0x8d,0x85,0x4,0x29,0xf2,0xae,
0x2c,0x84,0x40,0x20,0x18,0x1c,0xb9,0xc0,0xd4,0xc4,0x18,0x75,0xb1,0x28,0xb5,0x62,
0x92,0xcd,0xcb,0x63,0xac,0xe8,0x5c,0xcc,0xcd,0x57,0x2f,0x29,0x82,0x2,0x85,0x67,
0xcc,0x99,0x28,0x3c,0x63,0x66,0x66,0x86,0x80,0xdf,0xcf,0xc3,0xf,0xfd,0xae,0xe5,
0xf3,0xc9,0x25,0xc0,0x9f,0xbf,0xaf,0xb2,0xf1,0x78,0xb7,0x5f,0x48,0xd9,0xf7,0xf5,
0x6f,0x7c,0xbe,0xed,0xae,0xdb,0x37,0xbc,0xef,0xb4,0x34,0x33,0x33,0xc3,0xf3,0xdb,
0x5f,0x2,0xe9,0x23,0xeb,0x38,0x74,0xad,0x58,0x45,0x6d,0x6d,0x94,0xea,0x58,0x43,
0xfe,0xe1,0x25,0xbf,0xd5,0xda,0x94,0xa9,0xa9,0x4a,0x2,0x9,0x47,0x69,0x2c,0x1,
0xa3,0xa7,0x8e,0x70,0xc7,0x4d,0x9b,0xb0,0x2c,0x6b,0xc1,0xbf,0xe9,0x38,0x4e,0x99,
0xba,0xae,0x19,0x63,0x88,0x44,0x22,0x3c,0xbb,0xfd,0x75,0x7e,0xf0,0x8f,0x3b,0x72,
0xc0,0xf2,0x44,0xa2,0xe7,0x74,0xe9,0xbd,0x95,0xca,0x7e,0x39,0x18,0xf0,0x2e,0xba,
0x75,0xeb,0x55,0x82,0xcb,0x48,0x4a,0x6b,0xee,0xbc,0xfd,0x56,0x56,0x2c,0xef,0xe4,
0x9a,0x1b,0x6f,0x63,0x71,0xe7,0xa,0xe,0xf6,0xee,0x2b,0x74,0xd6,0x62,0x86,0x1,
0x44,0x61,0x60,0x12,0xe4,0xd5,0xc8,0x47,0x1e,0x25,0x96,0x9d,0xe6,0xee,0x5b,0x36,
0x5f,0x12,0x14,0x28,0xaa,0x59,0x69,0x4a,0x29,0x32,0x99,0xc,0x77,0x6c,0xbd,0x96,
0x86,0x46,0xcb,0x2,0xfe,0xb2,0xf2,0xde,0x22,0x6c,0x3c,0xde,0x1d,0x11,0x52,0x7e,
0xfd,0xe1,0xbf,0xf8,0xa2,0xf1,0x7a,0x3c,0x5c,0x4e,0xb0,0x31,0x3b,0x9b,0x64,0x7f,
0x6f,0x2f,0x7b,0xf6,0x1f,0x24,0x14,0xa,0xa3,0xc,0x6c,0xbe,0xf9,0xce,0x22,0x60,
0x19,0xad,0x21,0xf,0x25,0xf3,0x70,0x2,0x51,0xe4,0xf4,0x48,0x8,0xd7,0xd4,0x92,
0x4c,0xa5,0xf3,0x8d,0xa8,0x14,0xa3,0x63,0xe3,0x0,0x8c,0x15,0xf2,0xf7,0x83,0x85,
0xbc,0xa7,0x9,0x21,0xf8,0xbd,0xcf,0x6e,0x95,0xc0,0xe7,0xe2,0xf1,0xee,0x75,0xa5,
0xf7,0x96,0x46,0xea,0x5f,0xa9,0xa,0x7,0x22,0x37,0x6c,0x5e,0x75,0x59,0xaa,0xf6,
0x1e,0x78,0x87,0xbe,0xc1,0x29,0xae,0xde,0xb8,0x99,0xce,0xf5,0xbe,0xbc,0x7a,0x85,
0xca,0xb8,0xe9,0xa2,0xe6,0x12,0x20,0x8c,0xfb,0x5d,0xbe,0xe0,0xb7,0x24,0xcb,0x9a,
0x3c,0xc5,0x31,0xe0,0xcd,0x3d,0xfb,0x78,0x61,0xd7,0x21,0xda,0x97,0xad,0x62,0xf3,
0x8a,0xb,0x4c,0x5c,0x98,0xa2,0xea,0xfc,0x28,0xeb,0xd7,0xac,0xbc,0x24,0xac,0x10,
0x2,0x5d,0x98,0xbf,0xaf,0xbf,0x76,0x3d,0x3f,0x89,0xbd,0xa6,0xa7,0x26,0x72,0x7f,
0xb,0xdc,0xe3,0xfe,0x79,0x9,0x10,0x8f,0x77,0xb,0x21,0xe5,0x83,0xf,0x7d,0xe3,
0xb,0xa2,0x72,0x50,0xaa,0x4c,0xb3,0xc9,0x24,0x3f,0xfe,0xb7,0xc7,0xe9,0x1b,0x9a,
0x62,0x53,0x7c,0xb,0x5e,0x9f,0xaf,0x48,0x55,0x26,0xe2,0x7c,0xc9,0xb8,0xdf,0xe5,
0xa7,0x26,0x0,0x29,0x29,0x3,0xdd,0x77,0x72,0x92,0x8d,0x5b,0xee,0x22,0xd6,0xb4,
0x88,0x77,0x86,0x25,0xa1,0x50,0x88,0xfe,0xf3,0xd3,0xf4,0x9d,0x1c,0xe0,0x87,0x3f,
0x7f,0xa6,0xac,0x31,0xe7,0x4b,0x33,0x33,0x33,0x48,0x29,0xb9,0xf7,0xfe,0x4d,0x16,
0x98,0xbb,0xe2,0xf1,0xee,0xe6,0x32,0x58,0x60,0x93,0x14,0x34,0x6e,0xde,0xd0,0x75,
0xc9,0x7,0x1,0x3c,0xbf,0x7d,0x7,0x57,0xdd,0x7c,0x1f,0x9b,0xae,0xdb,0x52,0x6,
0x58,0x49,0x5a,0xe9,0xc1,0x6,0xa,0x73,0xaf,0x29,0x36,0x86,0x36,0x60,0x3b,0x86,
0xb7,0xf6,0xf5,0x72,0x7e,0x78,0x84,0xdf,0xbc,0xbe,0x87,0x65,0x2b,0xd7,0x15,0xef,
0xf7,0xf9,0xfc,0xbc,0xb4,0xef,0x24,0xb3,0xb2,0x9e,0x6d,0xaf,0xed,0x25,0x53,0xdd,
0xc5,0x73,0xaf,0xbc,0xc5,0xd4,0xf4,0xc,0xc6,0x98,0x79,0x5d,0x59,0x6b,0x4d,0x3a,
0x9d,0xe6,0xfa,0x6b,0xd6,0xa0,0x75,0x4e,0x0,0xf7,0x56,0xc2,0xde,0xb7,0xfe,0xea,
0xe5,0xda,0xef,0xf7,0x5d,0x52,0xd5,0x91,0xd1,0x31,0x86,0x26,0xb3,0x8,0x61,0xa1,
0x2b,0x7e,0x56,0xa6,0xe8,0xbc,0xa4,0xa0,0x31,0x68,0x93,0x87,0xd6,0xc6,0x60,0x8c,
0xc1,0x56,0x1a,0x55,0xd3,0x49,0xdf,0x7b,0xe3,0xfc,0xfe,0xa7,0xee,0x63,0x63,0x87,
0x8f,0xbb,0xae,0xaa,0x67,0xf3,0x62,0x1f,0x32,0x3d,0x42,0x4b,0xe7,0x1a,0xb4,0x31,
0x78,0x9a,0xf3,0x8d,0xb0,0x67,0xd0,0xc3,0x9f,0x7e,0xff,0x65,0xbe,0xfa,0x8f,0xcf,
0x90,0xc9,0xe6,0x47,0x61,0xd7,0xdc,0x94,0x4e,0xa7,0xa9,0xa9,0xae,0x62,0xfd,0x86,
0x66,0x3,0xdc,0x5f,0x6,0x2b,0xa4,0xfc,0xf4,0x27,0xee,0xbb,0xfe,0x92,0xfe,0x71,
0xe8,0xc8,0x51,0x1e,0x7d,0xec,0x79,0x36,0xdf,0x7a,0x6f,0x7e,0x1b,0x45,0xcf,0xef,
0xae,0xb,0x70,0xe6,0x83,0xb,0x63,0xf2,0x11,0x95,0x36,0x73,0xc0,0xda,0xd0,0x5a,
0xad,0xb9,0x61,0xc3,0x2a,0x96,0x75,0x34,0x53,0x17,0x8d,0x60,0x59,0x16,0x2d,0x4d,
0xf5,0xfc,0xce,0x96,0x75,0x78,0x52,0x83,0xd4,0x57,0xfb,0x59,0xd3,0xea,0xa5,0xb9,
0xca,0x90,0x53,0x50,0xdb,0xb0,0x88,0xdf,0xb9,0x79,0x3,0x7e,0x9f,0x77,0x9e,0x1a,
0x40,0x26,0x93,0xc1,0x18,0xc3,0xe6,0xcd,0x2b,0x5,0x70,0x6b,0x3c,0xde,0x5d,0xd,
0xe0,0x89,0xc7,0xbb,0x57,0x0,0xcb,0xd7,0x5e,0xb9,0xf8,0xa2,0x9b,0x4e,0xf4,0x9d,
0xa4,0xa3,0xbd,0xd,0xbf,0xdf,0xcf,0x53,0x3b,0xf6,0xb0,0xe5,0xee,0xcf,0xa0,0x4d,
0x7e,0xca,0xc9,0xe6,0x4,0x5e,0x29,0xcb,0x26,0xd3,0x4b,0xb5,0x96,0xe3,0x86,0x8b,
0x5,0x68,0x5d,0xb8,0xae,0xf,0x19,0x16,0x37,0xd7,0xce,0x7b,0x8f,0x65,0x59,0x7c,
0xe6,0x8e,0x6b,0xc8,0xda,0x39,0x42,0xc1,0x0,0x0,0xf,0x18,0x53,0x36,0xbf,0x96,
0x26,0xad,0xe7,0x22,0xbd,0x4c,0x26,0xc3,0xca,0x15,0xcb,0x50,0xea,0x65,0xaf,0x65,
0xf9,0xee,0x6,0x1e,0xf3,0x0,0x5b,0xa4,0x14,0x34,0xd5,0x47,0x8a,0xae,0xf0,0xdc,
0xf6,0x1d,0x9c,0x1b,0x9d,0xe2,0x82,0x13,0x22,0x1a,0x1b,0xe7,0xd6,0xb5,0xcd,0x84,
0x22,0xd,0x28,0xad,0x91,0x2a,0x3f,0x5f,0xe6,0x84,0x26,0xe3,0x40,0xd0,0x23,0x8b,
0xa4,0xb,0x75,0x0,0xa5,0xe6,0x62,0x62,0xad,0xc,0xaa,0x0,0x1d,0x9,0x8,0x3a,
0x9b,0xab,0x2f,0xd1,0x44,0x79,0xe0,0x50,0x70,0x6e,0xee,0x75,0x5d,0xf6,0xe8,0xf1,
0x3e,0x6a,0x6b,0x6a,0xa8,0xa,0x7,0x8b,0x9f,0xbd,0xb9,0xef,0x0,0x5a,0xfa,0x58,
0xde,0xd1,0x80,0xc7,0xe3,0xa1,0x2e,0x56,0x4b,0x75,0x44,0xea,0xd4,0x2c,0x5b,0x80,
0xc7,0x24,0xd0,0xba,0x66,0x6d,0xa7,0x71,0x27,0xf3,0xef,0xfe,0x9f,0x9f,0x72,0x6c,
0x32,0x4c,0x68,0xc9,0xb5,0x2c,0x59,0xb9,0x9e,0xfa,0xd6,0xa5,0x1c,0x1e,0x93,0xd4,
0x37,0xb5,0x17,0x2a,0x5a,0x88,0x7a,0x1c,0x4d,0x3a,0xab,0xb1,0x95,0xce,0x37,0xd2,
0x3c,0xbe,0x6b,0x74,0x3e,0xe0,0x57,0x5a,0xcd,0x1,0x6b,0x93,0xf,0xfc,0xd,0x74,
0xd6,0xfb,0xdf,0x77,0x74,0xad,0x4c,0x5a,0xe7,0xff,0x5e,0x3a,0x9d,0xe5,0x9f,0x9e,
0x3b,0x42,0xb6,0xa4,0xdf,0x2e,0x6a,0x6d,0xe6,0xd9,0xa3,0x8a,0xaf,0xfe,0x70,0xf,
0x8f,0xbf,0xd4,0x8b,0xd6,0x86,0x58,0x5d,0x40,0x90,0xdf,0xbb,0x46,0x2,0x2d,0xd7,
0xc5,0x57,0x17,0x45,0x39,0x33,0x5,0x91,0x86,0x96,0x7c,0xa5,0xa,0x15,0xd3,0x32,
0x40,0x5d,0x73,0x5b,0x59,0x78,0xe7,0x28,0x4d,0x4e,0x29,0x66,0x32,0x8a,0xac,0x93,
0xdf,0x5d,0x70,0xa,0x6b,0x55,0x47,0xbb,0xdf,0x6b,0x94,0xa3,0x4b,0xb6,0x5b,0xa,
0x21,0xa3,0x36,0x54,0xfb,0xd5,0x25,0x37,0xe4,0x16,0x4a,0xf9,0x85,0x85,0x66,0xf5,
0xca,0x2e,0x26,0x27,0xa7,0x78,0x79,0x5f,0x1f,0x5a,0x6b,0xb4,0xd6,0xb4,0x36,0x37,
0xf0,0x47,0xb7,0x34,0xf2,0xe9,0x9b,0xba,0xc8,0x66,0x6d,0x5e,0xdd,0x7f,0xa,0x7c,
0x8d,0x2,0x21,0x16,0xb9,0xb0,0xad,0xab,0x56,0x2e,0x2a,0x36,0xaf,0xc7,0x17,0x44,
0x6b,0x43,0x34,0x28,0x11,0xb9,0x54,0x1,0x5a,0x57,0x80,0xaa,0xfc,0x62,0xdb,0xd1,
0xd8,0x39,0xc5,0x74,0xc6,0xc1,0x2e,0x5c,0xe7,0x1c,0x5d,0xc8,0xb,0xd7,0x4a,0xe3,
0x38,0xaa,0xd8,0x0,0xee,0xb2,0x2e,0x16,0xd0,0x1f,0x1a,0x54,0x6b,0x8d,0x14,0x82,
0x3f,0xfa,0xc4,0x1a,0x76,0xf5,0xa7,0x70,0x94,0x2a,0x7e,0x17,0x8d,0x54,0x71,0xdd,
0xca,0x6,0x5a,0xaa,0x14,0x39,0x4f,0x84,0xaa,0x48,0x2d,0x40,0x1e,0x56,0x48,0xb9,
0xe8,0x58,0xff,0x60,0x11,0x76,0xe3,0x15,0x4d,0xb4,0x45,0xfd,0xdc,0xb6,0x26,0xc6,
0xc0,0xa1,0xdd,0x17,0x5,0xec,0x4e,0x1,0xc6,0x5,0xce,0x39,0xa,0xdb,0x56,0x4c,
0x26,0x1d,0x92,0x59,0x45,0xae,0x0,0x9c,0x2b,0x28,0x9f,0x73,0x14,0x39,0x65,0x70,
0x1c,0x5d,0xd8,0x54,0xcb,0xdf,0x3f,0x36,0x39,0xf3,0x81,0x61,0x5d,0x50,0xd7,0x95,
0xdb,0x5a,0x1a,0x9,0x66,0x87,0xd8,0xf9,0xf6,0x89,0xe2,0x67,0xae,0xed,0x3f,0xdc,
0x47,0x26,0x6b,0x13,0x8,0x7,0xc0,0x98,0x6,0xc8,0x87,0x8b,0x6d,0xe3,0x33,0x86,
0xd1,0xf1,0x49,0xea,0xa2,0x35,0x3c,0x70,0xe7,0xd,0xc5,0x87,0xa7,0x95,0xc4,0xd1,
0x1a,0xca,0x4e,0x5e,0xf2,0x61,0x81,0x36,0x12,0x2d,0x4d,0x71,0xe7,0x41,0x8,0x41,
0x4e,0x29,0xbc,0x52,0xe2,0xf5,0x80,0x47,0xe4,0x83,0x6,0x77,0x7a,0x51,0xee,0xba,
0x56,0x69,0xc2,0x7e,0xc9,0x8a,0x25,0x6d,0x1f,0x18,0x56,0x29,0x55,0x6,0xac,0xb5,
0xe6,0xfa,0xd5,0x2d,0x3c,0x76,0x50,0xb1,0xa4,0x69,0x82,0x68,0x4d,0x98,0x4c,0x26,
0xcb,0xf,0xff,0xed,0x69,0x4e,0xda,0x8b,0x58,0x9d,0xc9,0x11,0x8,0x5,0x20,0x3f,
0xeb,0xd4,0x49,0xa,0x73,0xed,0x85,0xac,0xe4,0x9b,0xff,0xfc,0x3c,0x7,0xe,0x1d,
0x2d,0xee,0xe4,0xfd,0xf9,0x1f,0x7e,0x9a,0xcc,0xd0,0xb1,0x32,0x55,0x8b,0xca,0x39,
0xa,0xdb,0x51,0xe4,0x72,0x1a,0xbb,0x58,0x56,0xa4,0xb2,0xe,0x53,0xc9,0x1c,0x17,
0x92,0xe,0xa9,0xac,0x83,0x9d,0x53,0x65,0xf7,0x38,0x4a,0x93,0xca,0x64,0x3f,0x34,
0xa8,0x52,0xaa,0xcc,0x36,0xac,0x5b,0x89,0x99,0x1d,0x22,0x14,0xc,0x70,0x6e,0x68,
0x98,0x87,0x7b,0x1e,0xe7,0x94,0xb8,0x2,0x7f,0x38,0x8a,0xd1,0x65,0x2a,0x59,0x1e,
0x60,0xe8,0xc2,0xf8,0x74,0x3,0x6,0xac,0x68,0x27,0xcf,0x1d,0xb5,0x79,0x62,0xe7,
0xb,0x2c,0xad,0xb7,0xf8,0xc2,0xa7,0xee,0x40,0xdb,0xb3,0x38,0x4e,0x3e,0x82,0x68,
0x8c,0x79,0x59,0x56,0xab,0x78,0xfb,0xf4,0x34,0xda,0x5f,0x83,0x94,0x12,0x25,0xdc,
0x33,0x1c,0x51,0x36,0xd1,0x1a,0x3,0xa9,0x82,0x4b,0x15,0x3f,0x36,0xf9,0x3d,0x26,
0xa5,0x35,0x47,0xfb,0x4e,0xb3,0x7a,0xf9,0x92,0xcb,0x2,0x35,0xc6,0x94,0x1,0xba,
0xd0,0xae,0xeb,0xde,0xbc,0xb2,0x9a,0x13,0x67,0xc7,0x38,0xde,0x7f,0x8a,0x15,0x57,
0x6e,0xa4,0x6f,0x4c,0x63,0x54,0xe,0xbf,0xcf,0x22,0x9d,0x4c,0x41,0xde,0x37,0x47,
0x3d,0x46,0xeb,0xb3,0xe3,0x23,0x13,0x6b,0xb5,0x31,0xc2,0xef,0x15,0xd8,0x8e,0x45,
0x55,0x4b,0x27,0x93,0x96,0xe4,0x89,0x17,0xdf,0x64,0xeb,0xb5,0x6b,0x79,0x77,0x34,
0x4b,0x4d,0x24,0xc2,0x8d,0x2b,0xa3,0x58,0x96,0x45,0x5b,0x63,0x94,0x53,0xe7,0x46,
0xa9,0xe,0x7,0x49,0x1c,0xe8,0x47,0x44,0x97,0x14,0x76,0x1d,0x4a,0x2a,0xc8,0xdc,
0x96,0x8c,0x31,0xa6,0x7c,0xf,0x4a,0x1b,0x7a,0x67,0xd2,0x74,0x2d,0xc9,0xe1,0xf3,
0xce,0x1f,0x5,0x55,0xaa,0xaa,0x94,0xc2,0x71,0x9c,0x8b,0x94,0xd5,0x5a,0xb3,0xf5,
0x9a,0x2b,0xb1,0x6d,0x9b,0xe5,0x6d,0xb5,0x3c,0xfe,0xcc,0x4b,0x60,0xda,0x90,0xc6,
0xe0,0xf7,0x58,0xa4,0x93,0x69,0x10,0x8c,0x25,0x76,0xf5,0x18,0x9,0xc,0x8d,0xd,
0x4f,0x28,0xa5,0xd,0x3e,0x8f,0xcc,0xcf,0x8b,0x85,0x1,0xe6,0xac,0x1d,0x63,0x47,
0xef,0x59,0x32,0x23,0xc7,0x59,0x56,0xab,0x8a,0xb,0x6b,0x9f,0xcf,0xc7,0x8a,0xa5,
0x6d,0xb4,0x34,0xc6,0xe8,0xa8,0xf7,0x93,0xb5,0x6d,0x72,0x39,0x55,0x74,0x67,0xdb,
0x51,0xd8,0x39,0x55,0x70,0xe1,0x82,0x8b,0x57,0xd8,0xb4,0x13,0xe0,0x17,0xdb,0xf7,
0xbd,0xef,0xba,0xd9,0x85,0xac,0x4,0xad,0x74,0x69,0xad,0x35,0x8e,0xe3,0xb0,0xe7,
0xf8,0x38,0x68,0x8d,0xdf,0x2b,0x30,0x46,0x93,0x9e,0x49,0x41,0xfe,0xec,0x17,0xf,
0x30,0x38,0x3e,0x32,0x2e,0x5d,0x58,0xa5,0x74,0x41,0x99,0x7c,0xa0,0x90,0xf6,0x37,
0x33,0x64,0x49,0xd2,0xce,0xfc,0x93,0xff,0x86,0xab,0xd6,0x92,0xda,0x7b,0x98,0x29,
0x15,0x66,0xda,0x29,0xdf,0x97,0x2a,0xc6,0xc3,0xc6,0x1d,0x49,0x4d,0x71,0x2a,0x53,
0xda,0x30,0x6e,0xea,0x78,0x7c,0xdb,0x6e,0x3e,0xbe,0x65,0x3d,0x3f,0xfa,0xf9,0x53,
0xb4,0x34,0x44,0x79,0xf5,0xc0,0x69,0xd6,0x75,0x36,0xd2,0xd1,0xda,0xc8,0xad,0x5b,
0x36,0xcf,0xab,0xe6,0x7c,0xf0,0x4a,0x29,0x7a,0xf,0x1e,0xc3,0x9,0x2f,0xc6,0x6b,
0x14,0x1,0x9f,0x37,0x1f,0x36,0x26,0x33,0x1a,0xc3,0x59,0x17,0x76,0x28,0x95,0x4c,
0xcb,0x4c,0xd6,0x26,0xe4,0xb3,0xc8,0x29,0x5d,0x16,0xf6,0x19,0x24,0xe1,0x80,0x97,
0xe5,0x1d,0x8d,0xf3,0xc2,0x4a,0x29,0xb8,0xe9,0x9a,0x35,0xcc,0xce,0x26,0xf9,0xd1,
0xb6,0xc3,0x54,0xd5,0xb5,0x14,0x40,0xb,0xe3,0xb6,0x99,0xb,0xfc,0x55,0x9,0xb0,
0x2e,0xcc,0xbb,0xfd,0x76,0x84,0xbf,0xf8,0xfe,0xd3,0x4,0x1a,0x97,0x33,0x78,0xc1,
0x10,0xee,0x68,0xe0,0x58,0x56,0x73,0xf8,0x84,0x62,0x45,0xd7,0x30,0xf5,0xd1,0x9a,
0x22,0xdc,0x42,0x90,0x4a,0x29,0x6c,0x3b,0xc7,0xb3,0xaf,0x1d,0xc0,0x17,0xbb,0x1a,
0xe3,0xe4,0xa8,0xf2,0x7b,0xd0,0x4a,0x91,0x9a,0x49,0x1a,0x60,0x8,0xf2,0x23,0xf1,
0x6e,0x80,0x13,0x7d,0x83,0xb4,0x44,0x83,0xe5,0x11,0x92,0x93,0xf,0x8,0xd6,0x2d,
0xa,0xbc,0x6f,0x58,0x57,0x55,0x15,0xe6,0x9a,0xa5,0x41,0xa4,0xca,0xe6,0x5d,0xd8,
0x71,0xf2,0xae,0x5d,0x18,0x8d,0x4b,0x5d,0xd9,0x71,0xf3,0xc2,0x8,0x1f,0x6a,0x59,
0x89,0x11,0x16,0x1a,0x99,0xf,0x42,0x94,0x26,0xe0,0xb3,0x8a,0xa0,0xb9,0x5c,0xee,
0x22,0xe0,0x4a,0xf8,0x47,0x7f,0xf1,0xc,0xc9,0xea,0x2b,0x31,0x5a,0x61,0xb4,0xa2,
0xa9,0xae,0x8a,0xe4,0x4c,0x92,0xe4,0x74,0xca,0x72,0x19,0x65,0x22,0xd1,0xd3,0x2b,
0xa4,0x78,0xef,0xc0,0xde,0x63,0x84,0x3,0x1e,0xc2,0x3e,0xab,0xa4,0x32,0xf9,0x8a,
0x76,0x35,0x87,0x2f,0x9,0xea,0xa6,0x6b,0x3f,0xb6,0x96,0xcf,0xdd,0xbc,0x94,0x55,
0xb5,0x49,0x3c,0x26,0x57,0xde,0x57,0x8b,0x53,0x90,0xfb,0xd9,0x5c,0x79,0xae,0x61,
0xe7,0x2c,0x99,0xc9,0x71,0xf0,0x58,0xdf,0x25,0x21,0x5d,0x3b,0x75,0xe6,0x1c,0x47,
0xa7,0x22,0x48,0x8f,0xf,0xb4,0x42,0xa2,0x69,0x8c,0x86,0x19,0x3c,0x75,0x1e,0x40,
0x3,0x4f,0xbb,0xca,0x62,0xb4,0x79,0xa2,0xf7,0x8d,0x3,0xca,0x51,0x9a,0x96,0x58,
0xb0,0x10,0xe2,0xe5,0x2b,0x60,0x49,0x88,0x45,0x2e,0xbd,0x32,0x29,0x4d,0x96,0x65,
0xb1,0x65,0xd3,0x95,0x7c,0xf1,0x96,0x4e,0xd6,0xd6,0xa5,0xf1,0x92,0x2b,0xe,0x54,
0xc5,0x88,0xab,0xb4,0x11,0x94,0x9e,0x6b,0x58,0x95,0xcf,0x1d,0x95,0x9f,0xaf,0xb7,
0x1f,0x9e,0x29,0xaa,0x3a,0x9f,0xba,0xae,0xb,0x3f,0xff,0xda,0x3e,0x42,0xb5,0xad,
0x50,0x50,0xb5,0x3e,0x12,0xc2,0x23,0x61,0xe8,0xd4,0x90,0x6,0x76,0x25,0x12,0x3d,
0xe3,0x45,0x58,0xe0,0xc9,0xd9,0xe9,0xa4,0x75,0xea,0xcc,0x8,0x6d,0xb1,0x50,0x5e,
0xd9,0x42,0xa8,0x57,0xe5,0x97,0x18,0xf3,0xc1,0xe3,0x58,0x8f,0xc7,0xc3,0xd6,0x6b,
0xd7,0x12,0x9c,0x3e,0x41,0xce,0x71,0x8a,0x23,0xf4,0x7c,0xea,0x96,0x29,0x5b,0xba,
0x97,0x6c,0x79,0xcb,0x40,0x4b,0x81,0x4b,0x7,0xaa,0x59,0x5b,0x62,0x94,0x3,0xda,
0x1,0xad,0x68,0xa9,0xab,0x22,0x93,0xce,0x30,0x31,0x7c,0x41,0x2,0xbf,0x72,0xeb,
0xe4,0xc2,0xee,0x44,0x88,0xa9,0x43,0xbd,0xc7,0x89,0x54,0xf9,0x8,0xfa,0x3c,0xc5,
0x60,0xfe,0xcc,0x58,0x8a,0x37,0xf,0x1c,0xc3,0xb6,0x6d,0x1c,0xc7,0xb9,0xac,0x2d,
0xd6,0xd2,0x34,0x38,0x3a,0x81,0x5d,0x2,0x68,0x57,0xba,0x70,0x69,0x5e,0xe8,0x36,
0xae,0x2b,0xf,0x4e,0x64,0xc8,0x64,0xb3,0xc5,0x63,0x8e,0x52,0x55,0x4b,0xaf,0xb5,
0x52,0x45,0x55,0x2d,0xc,0x2d,0x75,0xd5,0x9c,0x3f,0x3b,0xe2,0x2e,0xe6,0x9f,0x2a,
0x83,0x4d,0x24,0x7a,0x14,0xc6,0xfc,0x74,0xd7,0xb,0x9,0x3d,0x3b,0x9b,0xe1,0xaa,
0xa5,0xd1,0xb9,0x55,0x8b,0xa3,0xf8,0xcd,0x91,0x59,0x32,0x99,0x6c,0xd9,0xa1,0x92,
0x2a,0xac,0x34,0x2e,0x95,0xde,0x3e,0x70,0x88,0x53,0xd3,0x1,0x72,0x39,0x67,0xce,
0x95,0x2b,0x5c,0xba,0x8,0xae,0xe6,0x56,0x4b,0xae,0x3b,0x8f,0x4c,0x67,0xd9,0x7f,
0xf4,0x4c,0x11,0xae,0x12,0xda,0x2d,0x63,0x34,0xa6,0xa0,0xea,0xb2,0x45,0x75,0x58,
0x12,0xfa,0xe,0xe,0x28,0x60,0x77,0x22,0xd1,0x33,0x50,0xa9,0x2c,0xc0,0x5f,0x65,
0xb3,0xb6,0xfd,0xf2,0x8b,0x6f,0xd1,0x56,0x17,0xa6,0x36,0xec,0x2b,0xba,0xf2,0xf0,
0x8c,0xe6,0xa5,0xdd,0x7,0x2f,0x3a,0x72,0xc8,0x66,0xb3,0x45,0xf8,0xf9,0xa6,0x84,
0x47,0x7e,0xf1,0x22,0xb5,0x6d,0xcb,0x8b,0x7d,0xd4,0x9e,0xf,0xf2,0xa2,0xc1,0x6a,
0x6e,0xa9,0x28,0x80,0xa5,0xad,0xb5,0x17,0x1,0x56,0xaa,0x5c,0x1d,0xf4,0x80,0x52,
0xf8,0x2c,0x58,0xb6,0x28,0xc6,0x99,0xfe,0x73,0xcc,0x5c,0x98,0xb5,0x80,0xaf,0x94,
0x36,0x7e,0x11,0x36,0x91,0xe8,0x39,0x8f,0x31,0xdf,0x4e,0x6c,0x4b,0x98,0xf1,0x89,
0x19,0xd6,0x77,0xd6,0x95,0x55,0x64,0xdb,0xbb,0xe,0xdb,0x5e,0xdb,0xb3,0x20,0x70,
0x65,0xd9,0xb6,0x6d,0xfc,0xa1,0x48,0x5e,0x49,0x77,0xa,0xca,0x95,0x44,0x57,0x17,
0x1,0xbb,0x83,0x95,0x2e,0x2a,0xeb,0xf7,0x18,0x3c,0x52,0x5c,0xa4,0x6a,0x65,0x39,
0x35,0x33,0x85,0xd1,0xe,0x2b,0x3a,0xea,0x41,0x6b,0x8e,0xef,0x3f,0xa1,0x80,0x67,
0x13,0x89,0x9e,0x9d,0xf3,0xc2,0x16,0xd2,0xb7,0xb4,0xd6,0x93,0xbf,0x79,0x76,0x97,
0x89,0xd5,0xf8,0x69,0x8d,0x85,0xf2,0x8a,0xe4,0x14,0xb6,0x63,0xd8,0xde,0xef,0xe5,
0xd7,0xdb,0xdf,0x98,0x17,0xd8,0x5,0x75,0xcb,0xd9,0x6c,0x16,0x8f,0x9c,0xb,0x1f,
0x2b,0xc3,0xc5,0xf9,0x6c,0xae,0xff,0x16,0x66,0x2,0x61,0xca,0x8e,0x26,0x2b,0x55,
0x3d,0x37,0x34,0xcc,0x77,0x7e,0xf4,0x24,0x83,0xb9,0x26,0xaa,0xfc,0x1e,0xda,0x9b,
0xa2,0xf4,0x1f,0x3d,0x4d,0x3a,0x99,0x95,0xc6,0xe8,0xaf,0x55,0x76,0xab,0x32,0xd8,
0x44,0xa2,0x67,0xda,0x68,0xf5,0x97,0x7,0xdf,0xe8,0x15,0x67,0x4e,0xf,0x73,0xed,
0xca,0xc6,0x7c,0x54,0x55,0x8c,0x79,0x35,0x89,0xa1,0x30,0x3,0x67,0x6,0x2f,0x52,
0xb1,0x52,0xd9,0xc9,0xa9,0x69,0x6,0x86,0x67,0x2f,0x9a,0x72,0x2a,0xfb,0xee,0xdc,
0xe0,0x55,0x3a,0x32,0xe7,0x95,0x4d,0x66,0x54,0xd9,0x38,0x51,0x6a,0x17,0x26,0xa7,
0x78,0xe4,0x89,0x37,0x70,0x62,0xeb,0x8,0x85,0xaa,0xd8,0x70,0x65,0x3b,0x99,0x54,
0x9a,0xfe,0x83,0x27,0x95,0xd6,0xce,0xcf,0x77,0xef,0xfe,0xde,0x49,0x21,0x84,0x5c,
0x10,0x56,0x8,0xe1,0x39,0x71,0xe2,0xc5,0x7f,0xd1,0x46,0x1f,0xfc,0xe5,0xf,0x1e,
0x57,0xc9,0xd9,0x34,0x5b,0xd6,0xb4,0x0,0xa6,0x58,0xe1,0x6c,0x4e,0x33,0x3e,0x9d,
0x2e,0x83,0xab,0x54,0x76,0x62,0xe2,0x2,0x8f,0xfe,0xec,0x9,0xaa,0x5a,0x57,0x17,
0x17,0x4,0xae,0x1b,0x2f,0xb4,0x30,0x98,0xaf,0x1f,0x8f,0x4d,0x67,0xe8,0x3b,0x73,
0xfe,0x22,0xd0,0x5c,0x2e,0x87,0xdf,0xe7,0x65,0xed,0xb2,0x26,0x84,0x56,0xac,0xbf,
0xa2,0x8d,0x80,0x47,0xb2,0xf7,0x95,0x5e,0x6d,0xdb,0xce,0xf4,0xe0,0x60,0xef,0xb7,
0x81,0x0,0x10,0x12,0x42,0x78,0x2e,0x82,0x15,0x42,0x58,0x80,0x7f,0x7c,0xfc,0x84,
0x18,0x1a,0xdc,0xff,0xa5,0xe4,0x74,0x72,0xea,0x89,0x47,0x9f,0x52,0x7e,0x8f,0xe0,
0xfa,0xd5,0xcd,0xc5,0x91,0xd2,0x76,0xf2,0xc3,0xfc,0x42,0x7d,0xf6,0xe9,0x17,0x76,
0xf0,0xc7,0x3d,0xdb,0x39,0xe6,0x2c,0x43,0xe1,0x29,0x57,0x75,0x21,0x95,0x2b,0xfa,
0xae,0xa3,0x14,0xc6,0xc9,0x61,0x9c,0x1c,0xbd,0x3,0xd3,0xf3,0xaa,0x7b,0xec,0xc4,
0x49,0xde,0x39,0x31,0xc8,0x15,0x8b,0x1b,0x69,0xa8,0xd,0xf3,0xce,0xee,0x23,0x66,
0x6a,0x7c,0x46,0x8f,0x8d,0x1e,0xef,0x3e,0x7b,0x76,0xf7,0x54,0x1,0xd6,0xf,0xf8,
0x5d,0x85,0x4b,0x95,0xf5,0x16,0xcc,0x77,0xfa,0x74,0x62,0x7c,0x74,0xf4,0xdd,0x2f,
0x9f,0x3f,0x3d,0x68,0x9e,0x7b,0x62,0x87,0x69,0x8e,0x86,0x58,0xbf,0xac,0xae,0x18,
0xed,0xc,0x8e,0x4d,0x5e,0xe4,0xc6,0xee,0x75,0x6f,0xff,0x18,0x91,0xd6,0x95,0x18,
0x2b,0x50,0xd2,0xdf,0x4b,0x20,0x4b,0x14,0x9e,0x4f,0x55,0xed,0x38,0x79,0x50,0x95,
0x3,0x95,0xe3,0xf8,0xb8,0x2c,0x7b,0x87,0xc2,0x85,0xed,0x3b,0x35,0xc4,0xaa,0xb5,
0xd7,0xd2,0xd9,0x56,0x47,0xdf,0xa1,0x93,0xc,0xe,0xc,0x8b,0xa9,0xa9,0xb3,0xdf,
0xec,0xeb,0x7b,0xf1,0x28,0xe0,0x2b,0x31,0x6f,0x21,0xcf,0x1f,0x59,0x16,0xa4,0xf6,
0x14,0xbe,0xf0,0x0,0xde,0xbe,0xbe,0x17,0x8f,0xf8,0x7c,0xa1,0xbf,0x79,0x77,0x2f,
0x5f,0x8f,0xd4,0x45,0xd9,0x7c,0xd3,0xd5,0xf8,0x3d,0x16,0xaf,0x1f,0x1e,0xe2,0xc0,
0x10,0xac,0xef,0xb2,0xe7,0x3d,0x58,0x1a,0x1e,0x9b,0x40,0x4,0x1d,0xc0,0x5d,0xf9,
0xe4,0xb,0xee,0x52,0x6f,0x6e,0xd9,0x37,0x77,0x2a,0xa0,0x8d,0x6,0xad,0x8b,0x81,
0x41,0x7e,0xde,0x54,0xa0,0x1c,0x66,0x6c,0xc5,0xf0,0xd8,0x24,0x91,0xaa,0x40,0x71,
0x7a,0x3b,0x37,0x78,0x1e,0xed,0x8f,0xb1,0xa6,0xab,0x95,0x73,0xa7,0x86,0x38,0x7e,
0x60,0x80,0x54,0x6a,0xec,0xc9,0x23,0x47,0x9e,0xda,0x5e,0x60,0x70,0xc8,0xef,0x4e,
0x38,0xee,0xb5,0x10,0x42,0xba,0xfe,0x2c,0x1,0xab,0xc2,0x3c,0x47,0x8e,0x3c,0xf5,
0xc2,0xba,0x75,0xbf,0xb7,0xec,0xad,0x6d,0x3b,0x3f,0x3b,0x3d,0x35,0xcd,0x4d,0x77,
0x5d,0xcf,0xed,0x1f,0x5b,0xc4,0xf8,0xc8,0x10,0xb6,0x7d,0x31,0xec,0xc0,0x99,0x73,
0x4c,0xc8,0x56,0xaa,0x73,0xf9,0xbd,0x1f,0x17,0xb4,0x78,0x82,0x57,0x1,0x8a,0xd1,
0x79,0xd3,0xba,0x1c,0xd2,0x85,0x2e,0xd8,0xf9,0x71,0x9b,0xa0,0x4f,0x92,0xb5,0x6d,
0xa6,0xa7,0x67,0x39,0x3d,0x66,0xb3,0xfa,0xca,0xab,0xe9,0x3f,0x3c,0xc0,0xf1,0x3,
0x3,0x64,0x32,0x53,0x7b,0xe,0x1e,0x7c,0xfc,0xd1,0x82,0x50,0x56,0x49,0x5e,0x66,
0xa2,0x70,0xf4,0x17,0x28,0xf8,0x78,0xb0,0x60,0xa5,0xe5,0xe0,0xca,0x95,0x1f,0xbf,
0x3f,0x1a,0x5d,0xfa,0x9f,0x9a,0x97,0x2e,0xe2,0x8e,0xcf,0xdc,0x21,0x57,0xb5,0x58,
0x78,0x9c,0x99,0xe2,0x59,0x8b,0x10,0x82,0xfe,0x53,0x67,0x79,0xe2,0xc5,0x3d,0xd8,
0x8b,0x6e,0x29,0x1,0x75,0xd7,0xb4,0x14,0x94,0xd6,0x5,0xea,0x7c,0x6e,0xb4,0x6,
0xa3,0xf2,0xb0,0x46,0x17,0xe0,0x34,0xc6,0x94,0x3,0x2f,0x8f,0xcc,0x72,0xe1,0xfc,
0x0,0xe7,0x53,0x21,0xae,0xdb,0xb8,0x86,0x68,0xb4,0x81,0x77,0xde,0x3c,0x6a,0x6,
0x7,0x86,0xc5,0xf4,0xf4,0xe0,0xb3,0x47,0x8e,0x3c,0xf9,0x13,0x63,0x74,0xa,0xc8,
0x0,0xe9,0x12,0x2b,0xbd,0xce,0x5c,0xe,0x6c,0x0,0x8,0xb6,0xb7,0x5f,0xb3,0xb1,
0xad,0x6d,0xe3,0x9f,0x55,0xd7,0xd6,0xf8,0xbf,0xfc,0x5f,0xee,0x94,0xab,0xbb,0xda,
0x48,0x26,0x93,0x4c,0x4c,0x4c,0x70,0xf6,0xdc,0x10,0xff,0xf0,0xfc,0x0,0x35,0x2d,
0x2b,0xe7,0x46,0x80,0x62,0x28,0x59,0xf4,0xe5,0x5,0x60,0xf5,0x9c,0xa2,0xc6,0x75,
0x65,0x5d,0x6,0xeb,0xb5,0x4,0xcb,0x3b,0xea,0xe8,0x68,0x8e,0x91,0x4d,0x65,0xd8,
0xf7,0xda,0x3b,0x7a,0x72,0x7c,0xda,0xc,0x9f,0x3f,0xf4,0xe3,0x81,0x81,0x57,0x5f,
0xa9,0x84,0x5a,0xa0,0x9c,0x72,0x61,0x7d,0xb,0x41,0x96,0xe6,0xd1,0xe8,0xd2,0xc5,
0x5d,0xcb,0x6f,0xff,0x33,0x9f,0xd7,0xdf,0xb4,0xe9,0xc6,0x65,0xe2,0xbe,0x7b,0x36,
0xd1,0x58,0x1f,0xe5,0xfb,0xbf,0x78,0x89,0x63,0xb3,0xf5,0x64,0x72,0x25,0xab,0xa3,
0x32,0x58,0x57,0x5a,0xf7,0x5c,0xc8,0x94,0x40,0x96,0xb8,0xb2,0xab,0x6e,0x1,0xde,
0x12,0x86,0x25,0xad,0x31,0xba,0xda,0xeb,0x41,0x2b,0x6,0x8e,0x9e,0xa1,0xff,0xd0,
0x69,0x63,0xdb,0xd9,0xd4,0xa9,0x53,0x3b,0x1f,0x19,0x1e,0x3e,0x7c,0xb4,0x4,0x68,
0xa1,0xdc,0x2d,0xcf,0xba,0xb0,0xd6,0x42,0x80,0x95,0x9f,0xf9,0xfd,0xd5,0x91,0xce,
0xce,0xad,0xf7,0x46,0x6a,0xdb,0xef,0xf0,0x7a,0x3d,0xd6,0x8d,0xb7,0x5d,0x21,0x9a,
0x3a,0x97,0x23,0x3,0x11,0xde,0x1b,0x99,0xe6,0xbd,0xd1,0x69,0x86,0xc6,0x67,0xc8,
0xe5,0xd4,0xe5,0xc1,0xe6,0x37,0xa8,0xc0,0xe4,0x15,0x95,0x18,0x62,0x35,0x1,0x9a,
0x62,0x55,0xb4,0xd4,0xd7,0xe0,0xb5,0x24,0xef,0xd,0xc,0x72,0xbc,0xb7,0xdf,0x64,
0x52,0x36,0x33,0x33,0x43,0xfb,0x6,0x6,0x5e,0x7b,0x3a,0x99,0x1c,0x1d,0x29,0x40,
0xcc,0x7,0x39,0xdf,0x67,0xc9,0xe2,0xbb,0x4e,0x42,0x8,0x7f,0x5,0x60,0x25,0x70,
0x99,0x55,0x55,0x35,0x35,0x2d,0x59,0x72,0xe3,0xbd,0xd5,0xd5,0xcd,0x9b,0x83,0x55,
0x21,0xb3,0xfa,0xda,0x35,0xb2,0xbd,0xb3,0x8d,0x70,0x75,0x8,0xa5,0x35,0xe7,0xc7,
0x66,0x38,0x37,0x3a,0xcd,0xd4,0x6c,0x9a,0x74,0x26,0x47,0x26,0x9b,0x43,0x6b,0x95,
0x77,0xdf,0x2,0xac,0xc0,0xe0,0xf7,0x48,0xfc,0x5e,0xf,0x55,0x41,0x2f,0x8d,0xb1,
0x2a,0x1a,0xa2,0x61,0xbc,0x96,0x24,0x9d,0x4a,0x33,0x7c,0x6e,0x8c,0x81,0x23,0xa7,
0xcd,0xec,0x64,0x52,0xa4,0xd2,0x13,0x27,0xce,0x9c,0x7e,0xe3,0xd9,0xb,0x17,0x6,
0x4e,0x3,0xd9,0x12,0xa8,0xf9,0x2c,0x5d,0x71,0x3d,0x6b,0x8c,0x71,0x4a,0x61,0xe5,
0x42,0x60,0xcc,0x4d,0xd0,0xa5,0x65,0x3f,0xe0,0x8f,0xc5,0x96,0x76,0xb4,0x77,0x5c,
0x77,0x7f,0x28,0x18,0x5b,0x5,0x88,0xda,0xc6,0xa8,0x59,0xd4,0xd5,0x21,0x16,0x2d,
0x6d,0x21,0x12,0xad,0xc6,0x7d,0x59,0xc4,0x18,0x43,0x26,0x9b,0x23,0x9d,0xb1,0xd1,
0x5a,0xe3,0xf7,0x5a,0xf8,0x7d,0x56,0x61,0x5a,0xd2,0xa0,0xd,0xa9,0xd9,0x14,0x83,
0x67,0x46,0x18,0x3e,0x3d,0x6c,0x26,0x46,0x26,0x85,0x31,0x86,0x6c,0x76,0xe6,0xdc,
0xb9,0x73,0xfb,0x5e,0x18,0x1e,0x3e,0x74,0xac,0x0,0x59,0x69,0x2e,0xd0,0x42,0xd,
0x90,0x2,0x32,0xc6,0x98,0xf2,0x37,0xdc,0xe6,0x1,0x9e,0xf,0xd0,0x2d,0xfb,0x4a,
0x3e,0xf3,0x85,0x42,0x75,0x75,0x4d,0x4d,0x6b,0xd6,0xd7,0x44,0xda,0xd6,0x6,0x83,
0xd1,0x2e,0x81,0xb0,0x82,0xe1,0x80,0xe,0x47,0xaa,0x8,0x84,0x3,0x32,0x10,0xe,
0x10,0x8,0x5,0xf0,0x7,0xfc,0x48,0x9,0xa9,0x64,0x86,0x6c,0x32,0x43,0x26,0x9d,
0x21,0x33,0x9b,0x36,0xa9,0xd9,0xb4,0x49,0xcd,0xa4,0x25,0x60,0x32,0x99,0xa9,0xb3,
0xd3,0xd3,0xe7,0x8e,0x8c,0x8e,0x1e,0x3b,0x38,0x3d,0x3d,0x38,0x2,0xd8,0x25,0xe6,
0x42,0xba,0xe5,0xc,0xb,0x83,0x27,0x81,0x6c,0x51,0xd0,0xca,0x5,0xb8,0xc8,0x47,
0x7,0x17,0x29,0x38,0x8f,0xf9,0x4a,0x72,0x6f,0x49,0xee,0xf5,0x7a,0x43,0xe1,0xe6,
0xe6,0x75,0x6b,0xaa,0xab,0x9b,0xbb,0x3c,0x9e,0x40,0xc4,0xe3,0xd,0x44,0x3c,0x96,
0x2f,0x22,0x2d,0x6f,0x48,0x20,0xa,0xc7,0xe8,0xc6,0x28,0xed,0xa4,0x94,0x93,0x9d,
0x71,0x9c,0xec,0x94,0xe3,0x64,0xa6,0x93,0xc9,0xd1,0x33,0xe7,0xcf,0x1f,0x3a,0x9c,
0xc9,0x4c,0x4e,0x93,0xf,0x8,0x72,0x25,0x66,0x97,0xe4,0xa5,0xb0,0xb,0xd9,0x2c,
0x90,0x2b,0x13,0x73,0xa1,0xdd,0x6,0x21,0x84,0x77,0x1e,0xe0,0x52,0xc0,0xca,0x70,
0xcc,0xd,0x37,0x3d,0x25,0x56,0x3a,0xa9,0x4b,0x40,0x4,0x2,0xb5,0x55,0x52,0x7a,
0xac,0x74,0x7a,0x62,0xd6,0x18,0x6d,0xc8,0xef,0xfe,0xb9,0xb9,0x2a,0x31,0xa7,0xc4,
0xe6,0x3,0x2e,0x55,0xba,0x14,0x3c,0xd,0xa4,0xcd,0x3c,0x1b,0x67,0x97,0x7c,0x19,
0xb3,0xa0,0xb2,0xaf,0x0,0xed,0x9b,0xc7,0x4a,0x41,0x4b,0xc3,0xcd,0xca,0x28,0x46,
0x92,0x3f,0xf6,0x72,0xf3,0xd2,0xb4,0x10,0x70,0x69,0xc8,0x97,0x2b,0xc9,0xe7,0x3,
0x76,0x61,0x93,0x80,0x5a,0x50,0xc0,0xcb,0xd9,0x40,0x2b,0x40,0xbb,0x4a,0x57,0x2a,
0x79,0x39,0x8a,0xba,0x56,0xfa,0x76,0xa6,0xb,0xea,0x9a,0x2e,0xb1,0xf7,0x53,0xb8,
0x54,0xe9,0x74,0x1,0x74,0x41,0xc8,0xf,0x4,0x5b,0x1,0x2e,0x99,0x73,0xe7,0x52,
0x35,0x4b,0x41,0x3d,0xcc,0xc5,0xdb,0x95,0xb0,0x54,0xc0,0xba,0x79,0x25,0xac,0xa6,
0x5c,0xdd,0x52,0x60,0xd7,0x65,0x1d,0xf3,0x1,0x0,0xfe,0x9f,0xfe,0x17,0xaf,0xa0,
0xb8,0xc5,0x9c,0xda,0x95,0xae,0x3b,0x9f,0xb,0xcf,0xe7,0xc6,0xf3,0xb9,0x72,0xa9,
0xc2,0x6e,0xbf,0x74,0x0,0xfd,0x61,0xeb,0xfc,0x91,0xfd,0x97,0x25,0x14,0xdf,0x48,
0x75,0xc1,0x16,0x52,0xd6,0xcd,0x2f,0xe5,0xc2,0x6e,0xb9,0x70,0xcc,0xfb,0xd1,0xd4,
0xf1,0xff,0x2,0xe8,0xfb,0x2,0xc1,0x9,0x35,0xa5,0xf0,0x0,0x0,0x0,0x0,0x49,
0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/newdrone18/workspace/qtbook-master/20.02.27_Qt_Programming_Korean_v1.4_Example_Source_code/Ch03/01_BasicWidget/01_QCheckBox/resources/mail.png
0x0,0x0,0xf,0x3b,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x44,0x0,0x0,0x0,0x40,0x8,0x6,0x0,0x0,0x0,0xa3,0x82,0xd1,0xa4,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0x14,0x72,0x0,0x0,0x14,0x72,
0x1,0x39,0x38,0x12,0x6b,0x0,0x0,0x0,0x19,0x74,0x45,0x58,0x74,0x53,0x6f,0x66,
0x74,0x77,0x61,0x72,0x65,0x0,0x77,0x77,0x77,0x2e,0x69,0x6e,0x6b,0x73,0x63,0x61,
0x70,0x65,0x2e,0x6f,0x72,0x67,0x9b,0xee,0x3c,0x1a,0x0,0x0,0xe,0xb8,0x49,0x44,
0x41,0x54,0x78,0x9c,0xdd,0x5b,0x6b,0x6c,0x1c,0xd7,0x75,0xfe,0xee,0xcc,0xec,0x72,
0xdf,0x4b,0x52,0x24,0x97,0x4f,0xc9,0xa4,0xf8,0x58,0x3e,0x4c,0xae,0x42,0x2b,0x62,
0x6a,0xbd,0x6c,0xb9,0x4e,0x94,0x4,0x6,0x8c,0xc4,0x85,0x93,0x34,0x40,0x2d,0x4b,
0xb1,0x64,0x27,0x75,0x6b,0x20,0x41,0xff,0x14,0xa8,0x91,0x3a,0x92,0x25,0x91,0xa2,
0x9e,0x4e,0x6c,0xb4,0x6e,0x92,0xa2,0x41,0x1a,0x23,0x2,0x1c,0x54,0x45,0x9b,0xa2,
0x46,0x10,0xc9,0xb2,0x92,0xba,0x94,0x5a,0x52,0xb4,0x1e,0xa4,0x24,0x52,0xd4,0x86,
0xf4,0x72,0xb5,0xaf,0xd9,0xc7,0xbc,0x6e,0x7f,0xec,0xce,0x72,0xf6,0xbd,0xcb,0x5d,
0xca,0x49,0xf,0x70,0xb9,0x33,0xf7,0xdc,0xc7,0x39,0xdf,0x9c,0x73,0xee,0xb9,0x77,
0x86,0x84,0x52,0x8a,0xb5,0xa6,0x83,0xaf,0xfd,0x8d,0x99,0x52,0xfa,0x3c,0xcb,0xb2,
0xdf,0x11,0x45,0xb1,0x85,0x82,0x82,0x52,0xa,0x4a,0x91,0xf8,0xa5,0x0,0xa5,0xc9,
0x6b,0x4a,0x1,0xb5,0xd,0x0,0x11,0xc0,0x8f,0x64,0x59,0x3e,0xf4,0xfa,0xe1,0x63,
0x37,0xd7,0x5a,0x56,0xb2,0xd6,0x80,0x1c,0xfa,0xde,0xab,0x83,0xc,0xc3,0xfc,0xb,
0xcb,0xb2,0x8e,0x27,0xfe,0x78,0xb7,0xee,0xa1,0xf6,0xf6,0x8c,0x36,0xa9,0x22,0xd0,
0x94,0x7b,0xbf,0xdf,0x87,0xb3,0x3f,0xff,0x99,0xb8,0xb4,0xb4,0x8,0x59,0x96,0xf7,
0x1e,0x3e,0x32,0xfe,0xa3,0xb5,0x94,0x77,0x4d,0x1,0x39,0x74,0xf0,0xd5,0xaf,0x30,
0x84,0x79,0x7b,0xd3,0xa6,0x61,0xee,0xb1,0x5d,0x4f,0xb2,0x1c,0xc7,0x41,0x96,0x65,
0x0,0x40,0xa1,0x79,0x55,0xbe,0x4e,0xa7,0x83,0x24,0x49,0x98,0x9e,0xbe,0x8a,0x7f,
0xfc,0xf1,0xdb,0xa,0x1,0x39,0x25,0xcb,0xf2,0x2b,0x47,0x46,0x8f,0xcb,0x6b,0x21,
0xf3,0x9a,0x1,0x72,0xf8,0xf5,0xef,0xbe,0x4a,0x29,0xfd,0xeb,0xa7,0x9f,0xfe,0x13,
0xd2,0xd5,0xdd,0x3,0x59,0x96,0x11,0xe,0x87,0x21,0x8a,0xe2,0x8a,0x9b,0x0,0x5,
0xaf,0x59,0x96,0x85,0xdd,0x6e,0x87,0xc1,0x60,0xc0,0xe2,0xe2,0x22,0xce,0x9c,0x1a,
0x17,0x5,0x41,0x3c,0x2f,0x49,0xe2,0x17,0x8e,0x8e,0x9d,0x88,0x54,0x5a,0xee,0x35,
0x1,0xe4,0xc8,0xe1,0xbf,0x3d,0x8,0xe0,0xdb,0x7b,0x9e,0x3f,0xc0,0xae,0x5b,0xb7,
0xe,0xb1,0x58,0xc,0xa1,0x50,0x28,0x43,0xd9,0x7c,0x40,0xa4,0xdf,0xdb,0x6c,0x36,
0x54,0x57,0x57,0x23,0x14,0xa,0x61,0x7c,0xec,0xb0,0x10,0xc,0x6,0x2f,0x4a,0xb2,
0xb4,0x7b,0x74,0xec,0x64,0x45,0x41,0xa9,0x38,0x20,0x47,0xf,0xbf,0x36,0xa,0x42,
0x5e,0xde,0xf7,0x8d,0x17,0x59,0xbb,0xbd,0x1a,0x3c,0xcf,0x23,0x12,0x89,0xcb,0x5c,
0x8c,0xe2,0xf9,0x78,0x26,0x93,0x9,0x75,0x75,0x75,0x8,0x87,0xc3,0x18,0x3b,0x7a,
0x48,0x8,0xf1,0xa1,0x8b,0x92,0x24,0xed,0x1e,0x3b,0x76,0xaa,0x62,0xa0,0x54,0x14,
0x90,0xd1,0x23,0xdf,0x3b,0x49,0x8,0x39,0xb0,0xef,0x1b,0x2f,0xb1,0x56,0x9b,0xd,
0xc1,0x60,0x10,0xb1,0x58,0xac,0x64,0xc5,0xf3,0xf1,0x8c,0x46,0x23,0x1c,0xe,0x7,
0x78,0x9e,0xc7,0xe8,0xd1,0x43,0x2,0xcf,0x87,0xde,0x97,0x24,0xe9,0xf3,0xc7,0xc6,
0x4f,0x57,0x4,0x94,0x8a,0x0,0x32,0x76,0xf4,0x20,0x21,0x84,0xbc,0x1,0x42,0xf6,
0xee,0xdd,0x77,0x80,0xb5,0x5a,0x6d,0x8,0x4,0x2,0x88,0xc5,0x62,0x0,0x56,0xa7,
0x78,0x3e,0x9e,0xd1,0x68,0x44,0x63,0x63,0x23,0x42,0xa1,0x10,0xc6,0x46,0xf,0x9,
0x3c,0xcf,0x5f,0x90,0x24,0xe9,0xf3,0xe3,0xc7,0xcf,0x44,0xcb,0xd5,0xa5,0x6c,0x40,
0x8e,0x8d,0x1e,0x64,0x8,0x61,0xfe,0x8e,0x10,0xf2,0xa7,0x7b,0xf7,0xbd,0xc8,0x99,
0x2d,0x16,0xf8,0xfd,0x7e,0x8,0x82,0x50,0xb6,0xe2,0xf9,0x78,0x26,0x93,0x9,0x8d,
0x8d,0x8d,0x8,0x6,0x83,0x38,0x36,0xf6,0xba,0xc0,0xf3,0xfc,0x79,0x49,0x92,0xbf,
0x70,0xfc,0x44,0x79,0xa0,0x94,0x5,0xc8,0xf8,0xd8,0x21,0x86,0x10,0xf2,0x43,0x86,
0x61,0x9f,0xdd,0xb3,0x77,0x3f,0x67,0x32,0x99,0x93,0x96,0x51,0x8a,0xb2,0xc5,0xb6,
0x4b,0xbf,0x37,0x9b,0xcd,0x49,0x50,0xc6,0x46,0x5f,0x17,0xc2,0xe1,0xf0,0xaf,0x25,
0x49,0xfa,0xe2,0x89,0x93,0x6f,0xac,0x1a,0x14,0x66,0xb5,0x1d,0x1,0x80,0x61,0x98,
0x7f,0xe0,0x38,0xee,0xd9,0x3d,0x7b,0xf,0x70,0x26,0x93,0x19,0x7e,0xbf,0x1f,0xd1,
0x68,0x34,0x29,0xb0,0xa2,0x28,0x29,0xca,0x68,0xef,0x73,0x5d,0x97,0xc2,0xb,0x6,
0x83,0x70,0xbb,0xdd,0xb0,0x58,0x2c,0xf8,0xcb,0x57,0xbe,0xad,0x37,0x1a,0x4d,0xdb,
0x58,0x96,0x3d,0xfb,0xad,0x6f,0xee,0x67,0x1f,0x38,0x20,0x27,0xc6,0xf,0xbf,0x46,
0x8,0xf3,0x95,0x3f,0x7b,0xee,0x5,0xce,0x64,0x32,0xc1,0xef,0xf7,0x27,0x2d,0x63,
0x35,0xca,0x2a,0x8a,0xb2,0x2a,0xc0,0x2,0x81,0x0,0xee,0xdd,0xbb,0x7,0x8b,0xc5,
0x8a,0x3f,0x7f,0xf9,0x15,0x3d,0xc7,0x71,0xbb,0x18,0x86,0x39,0xf5,0x40,0x1,0x39,
0x31,0x7e,0x78,0x3f,0x80,0xbf,0xfa,0xda,0xd7,0xf7,0x70,0x26,0xb3,0x19,0x3e,0x9f,
0x2f,0xc5,0x32,0x2a,0x65,0x1,0xa5,0x80,0xe2,0x76,0xbb,0x61,0xb7,0xdb,0xf1,0xd2,
0x37,0xff,0x42,0x7,0x60,0xdf,0xb7,0x5e,0x7a,0xe1,0x95,0xd5,0xe8,0x56,0x72,0xc,
0x39,0x71,0xfc,0xc8,0x53,0x4,0x38,0xfb,0xe5,0x67,0xbe,0xca,0x34,0x35,0xb7,0xc0,
0xef,0xf7,0x23,0x12,0x89,0xac,0x69,0x0,0x2d,0x96,0x57,0x5b,0x5b,0x8b,0x86,0x86,
0x6,0xdc,0xb8,0x71,0x1d,0x6f,0xfd,0xe0,0x8c,0xa2,0x50,0xe5,0x99,0x53,0xa7,0xdf,
0xfc,0xf9,0x9a,0x1,0x72,0xf2,0xf8,0xd1,0x11,0x10,0xfc,0x6a,0xf7,0xee,0xa7,0x74,
0x1b,0x3b,0xbb,0x48,0x28,0x14,0xca,0x9a,0x81,0x7e,0x92,0xa0,0x34,0x36,0x36,0xc2,
0x6e,0xb7,0xe3,0xc3,0xf,0xff,0x8b,0xbe,0xf3,0xb3,0x9f,0x88,0xb2,0x2c,0x6f,0x3f,
0x7d,0xe6,0xad,0x4b,0xc5,0xea,0x58,0xb4,0xcb,0x9c,0x3a,0x71,0xb4,0x9b,0x61,0x98,
0x7f,0xfb,0xa3,0x47,0x77,0x70,0x1d,0x1b,0x3b,0x49,0x38,0x1c,0x46,0x30,0x18,0xac,
0x68,0x3c,0xa8,0x4,0xcf,0xed,0x76,0x83,0xe7,0x79,0xc,0xd,0xb9,0xc8,0xf6,0x1d,
0x8f,0xb1,0x2c,0xcb,0xfe,0xeb,0x8b,0x7,0xf6,0x65,0x6e,0xb1,0xcb,0x1,0xe4,0xf4,
0xc9,0x51,0x7,0xcb,0xb2,0xff,0x39,0x30,0x30,0x64,0x72,0xb9,0x3e,0xc5,0x8,0x82,
0x0,0xbf,0xdf,0x5f,0x50,0xe8,0xb5,0x54,0x3c,0x17,0x4f,0x51,0x14,0xcc,0xcf,0xcf,
0x43,0x92,0x24,0xec,0xdc,0xb9,0x8b,0x75,0xf6,0xe,0x58,0x38,0x8e,0xfb,0x8f,0x3,
0xfb,0xf7,0xd6,0x54,0x4,0x90,0x33,0xa7,0xc6,0xaa,0x58,0x96,0xfd,0xf7,0xb6,0xf5,
0x1b,0x1a,0x1e,0xdd,0xb6,0x83,0x93,0x65,0x19,0x5e,0xaf,0xb7,0xe8,0x40,0x58,0xe9,
0x55,0xa5,0x18,0x9e,0x24,0x49,0xb8,0x7d,0xfb,0x36,0x74,0x3a,0x1d,0xbe,0xf4,0xa5,
0x67,0x74,0xf5,0xd,0xd,0xad,0x1c,0xc7,0xfd,0x62,0xff,0xb,0xcf,0x73,0x65,0x3,
0x42,0x8,0xf9,0xae,0xd1,0x68,0x72,0x3e,0xf9,0xd9,0x2f,0xea,0x0,0x60,0x79,0x79,
0x39,0x43,0x99,0x72,0x14,0x5a,0xed,0x18,0xaa,0x95,0xce,0xcd,0xcd,0x61,0x62,0x62,
0x2,0xb3,0xb3,0xb3,0x29,0xf1,0x4c,0x92,0x24,0xdc,0xba,0x75,0xb,0x26,0x93,0x9,
0xcf,0x3d,0xb7,0x4f,0xcf,0xb2,0xdc,0x16,0x0,0xdf,0x29,0xa8,0x6f,0xbe,0xa0,0xfa,
0xc6,0xe9,0x63,0x8f,0x52,0x4a,0x7f,0xfd,0xb5,0xaf,0xef,0x21,0x36,0x9b,0x1d,0x8b,
0x8b,0x8b,0x10,0x45,0x11,0xc0,0x83,0xf,0xa0,0xb2,0x2c,0x23,0x12,0x89,0x20,0x14,
0xa,0xc1,0xe3,0xf1,0x20,0x10,0x8,0xa0,0xa3,0xa3,0x3,0xbd,0xbd,0xbd,0x68,0x6e,
0x6e,0x6,0x0,0xbc,0xf3,0xce,0x3b,0xe8,0xe8,0xe8,0x0,0x21,0x24,0xa9,0x83,0xd5,
0x6a,0xc5,0xfa,0xf5,0xeb,0x31,0x3b,0x3b,0x83,0x37,0xce,0x9c,0x94,0x14,0x45,0x19,
0xfc,0xc1,0x9b,0x7f,0x3f,0x5d,0x32,0x20,0xdf,0x3f,0x33,0x6e,0x66,0x18,0x66,0x7a,
0xeb,0xf6,0xc7,0x5b,0xfa,0xfa,0x6,0x18,0xaf,0xd7,0xb,0x9e,0xe7,0xd7,0x5c,0x71,
0xed,0x75,0x2c,0x16,0x43,0x38,0x1c,0x86,0xd7,0xeb,0x85,0xd7,0xeb,0x85,0xd1,0x68,
0xc4,0xc0,0xc0,0x0,0x3a,0x3a,0x3a,0x60,0xb5,0x5a,0x53,0x14,0x7,0x80,0xf,0x3e,
0xf8,0x0,0xa1,0x50,0x8,0x56,0xab,0x35,0xa5,0xde,0xe1,0x70,0xc0,0x6e,0xb7,0xe3,
0xdc,0xb9,0x5f,0xc8,0xef,0x5f,0x38,0x7f,0x59,0x14,0xc5,0x4f,0xbf,0xf9,0xd6,0xdb,
0x4a,0x36,0xbd,0x73,0xfa,0x14,0x21,0xe4,0x48,0x5d,0x7d,0x43,0x53,0x4f,0x4f,0x2f,
0xc3,0xf3,0x7c,0xc1,0xe5,0xb5,0x12,0xa0,0xa8,0x56,0x10,0x8,0x4,0xf0,0xf1,0xc7,
0x1f,0x23,0x1a,0x8d,0xa2,0xab,0xab,0xb,0x23,0x23,0x23,0x70,0x38,0x1c,0xe0,0xb8,
0x54,0x71,0x55,0xd7,0x95,0x65,0x19,0x7a,0xbd,0x1e,0x2e,0x97,0xb,0x67,0xcf,0x9e,
0x85,0xc5,0x62,0x49,0x1,0x6b,0x69,0x69,0x9,0x66,0xb3,0x19,0xbb,0x76,0x3d,0xc9,
0x7e,0x70,0xf1,0xfd,0x21,0x0,0x2f,0x3,0x38,0x56,0x12,0x20,0xc,0xc3,0x3e,0xbd,
0x65,0xcb,0xa3,0x1c,0x80,0x8c,0x20,0x5a,0x29,0x50,0x14,0x45,0x49,0xb1,0x2,0x8f,
0xc7,0x83,0xda,0xda,0x5a,0xf4,0xf7,0xf7,0x63,0xfb,0xf6,0xed,0x30,0x9b,0xcd,0x29,
0x32,0xa9,0xf1,0x43,0x96,0xe5,0x64,0x4c,0x51,0x49,0x14,0x45,0x18,0xc,0x6,0x34,
0x37,0x37,0x83,0xe7,0x79,0x58,0x2c,0x96,0x94,0x7e,0xb,0xb,0xb,0x68,0x6f,0x6f,
0xc7,0x97,0x9f,0x79,0x96,0xfb,0xe7,0x9f,0xfe,0xd3,0x4b,0x25,0x3,0x2,0x80,0xb0,
0x6c,0x7c,0x8f,0x24,0x88,0x2,0x58,0x86,0xad,0x88,0x5b,0xa8,0x67,0xab,0x7e,0xbf,
0x1f,0x1e,0x8f,0x7,0x92,0x24,0xa1,0xa7,0xa7,0x7,0x5b,0xb7,0x6e,0x45,0x5d,0x5d,
0x1d,0x18,0x26,0x35,0xce,0xab,0x7d,0x54,0x20,0xb4,0xf5,0x5a,0x12,0x45,0x11,0x1c,
0xc7,0xe1,0x91,0x47,0x1e,0xc1,0xbb,0xef,0xbe,0xb,0xb3,0xd9,0x9c,0x62,0x25,0x92,
0x24,0x1,0x80,0xa,0xb2,0x2e,0x97,0xd2,0x79,0x97,0x21,0xa,0xa,0x86,0x61,0x60,
0x30,0x18,0xc0,0xf3,0x3c,0x38,0x96,0x2b,0x19,0x14,0xd5,0xa,0x78,0x9e,0xc7,0xf2,
0xf2,0x32,0x3c,0x1e,0xf,0x5a,0x5b,0x5b,0xd1,0xd3,0xd3,0x83,0x9d,0x3b,0x77,0xc2,
0x68,0x34,0x66,0xcc,0xab,0x2a,0x2f,0xcb,0x72,0xca,0x78,0xd9,0xc0,0xd0,0x5e,0xb,
0x82,0x0,0xb3,0xd9,0x9c,0x3c,0x66,0xd4,0x5a,0x98,0xc3,0xe1,0xc8,0x68,0x5f,0x32,
0x20,0x2a,0xad,0xab,0x5d,0x7,0x5f,0xc0,0x7,0x4a,0x69,0x51,0x96,0x22,0x8,0x2,
0x22,0x91,0x8,0xfc,0x7e,0x3f,0x96,0x96,0x96,0xc0,0xb2,0x2c,0x7a,0x7b,0x7b,0x31,
0x38,0x38,0x88,0xea,0xea,0xea,0x8c,0x60,0xa8,0x75,0x5,0x15,0x84,0x42,0xca,0x67,
0xe3,0x9,0x82,0x0,0xbd,0x5e,0x8f,0x2d,0x5b,0xb6,0xe0,0xdc,0xb9,0x73,0x68,0x6f,
0x6f,0x7,0xa5,0x14,0x56,0xab,0x35,0xdd,0xfd,0x52,0x5,0x28,0xe,0x90,0xd4,0xc9,
0x3a,0x36,0x74,0xe0,0xf2,0xe4,0x65,0xd4,0x58,0x6b,0xc0,0x30,0x4c,0x46,0x8e,0x10,
0x8d,0x46,0x11,0xa,0x85,0xb0,0xbc,0xbc,0xc,0xbf,0xdf,0x8f,0xb6,0xb6,0x36,0xf4,
0xf5,0xf5,0xe1,0xf1,0xc7,0x1f,0x87,0x5e,0xaf,0xcf,0x1c,0x9d,0xc6,0x13,0x28,0xd5,
0x1d,0x4a,0x55,0x3e,0x17,0x2f,0x12,0x89,0xc0,0x66,0xb3,0xc1,0x6a,0xb5,0x22,0x1c,
0xe,0xc3,0x68,0x34,0xa2,0xa9,0xa9,0x49,0xf3,0xd0,0xca,0xb0,0x10,0x4a,0x53,0x27,
0xeb,0xef,0xe9,0xc7,0xa5,0xff,0xbe,0x84,0x56,0x47,0x2b,0x44,0x51,0x44,0x38,0x1c,
0xc6,0xfd,0xfb,0xf7,0xe1,0xf1,0x78,0x60,0x30,0x18,0xe0,0x74,0x3a,0xb1,0x69,0xd3,
0xa6,0xac,0x4b,0x22,0x80,0xa4,0x5,0x68,0x41,0x28,0x47,0xf9,0x6c,0x3c,0x41,0x10,
0x60,0x30,0x18,0x30,0x32,0x32,0x82,0x8b,0x17,0x2f,0xa2,0xaf,0xaf,0x2f,0xad,0x1d,
0x49,0xfe,0xc9,0x46,0x45,0xb9,0x8c,0x3a,0x20,0xc7,0x71,0x78,0xb8,0xf7,0x61,0xfc,
0x76,0xe2,0xb7,0x88,0x6,0xa3,0x68,0x6a,0x6a,0x82,0xcb,0xe5,0x42,0x7d,0x7d,0x7d,
0xc6,0x92,0xa8,0xf6,0x53,0x14,0x25,0x69,0x9,0xa5,0xc4,0x83,0x72,0x78,0xe1,0x70,
0x18,0xf3,0xf3,0xf3,0x70,0x3a,0x9d,0xe0,0x38,0x2e,0x65,0x55,0x4b,0xd0,0x2a,0x1,
0xc9,0x32,0xa9,0xd5,0x62,0x45,0x4f,0x57,0xf,0x82,0xc1,0x20,0x86,0x5d,0xc3,0x19,
0x5d,0xb4,0xb1,0x40,0x8d,0xec,0xc5,0x28,0x51,0x49,0xde,0xf4,0xf4,0x34,0xaa,0xaa,
0xaa,0x50,0x5d,0x5d,0x5d,0x30,0x88,0xa6,0x53,0x51,0xbb,0xdd,0xf4,0x49,0x9b,0x1d,
0xcd,0x90,0x64,0x9,0x53,0x1f,0x4d,0x1,0x88,0xbb,0x82,0x20,0x8,0x8,0x87,0xc3,
0x8,0x87,0xc3,0x88,0xc5,0x62,0x29,0xaf,0x2c,0xcb,0xd9,0xe4,0x95,0xca,0x9b,0x9b,
0x9b,0x43,0x34,0x1a,0x45,0x4b,0x4b,0x4b,0x52,0xde,0xd4,0x45,0x80,0x2,0x95,0x72,
0x19,0x2d,0xf5,0x75,0xf7,0xe1,0xfc,0xa5,0xf3,0xf0,0xde,0xf7,0xc2,0x35,0xe0,0xca,
0xd9,0xf6,0x41,0x59,0x5,0x0,0xb8,0xdd,0x6e,0x78,0xbd,0x5e,0xc,0xd,0xd,0x65,
0x95,0x39,0x1e,0xd7,0xf2,0xc7,0x90,0xbc,0x16,0x42,0x91,0x29,0x88,0x36,0xe,0x8c,
0x3c,0x32,0x82,0x7b,0x8b,0xf7,0x30,0x75,0x6d,0x6a,0xcd,0x9f,0x7c,0x21,0xde,0xe2,
0xe2,0x22,0x16,0x16,0x16,0xd0,0xdb,0xdb,0x9b,0x57,0xe6,0x42,0xb4,0x2a,0xb,0x51,
0xef,0x59,0x86,0xc5,0xb6,0x2d,0xdb,0xf0,0xcb,0x5f,0xfd,0x12,0x1c,0xc7,0xa1,0xf3,
0xa1,0xce,0x8c,0xf6,0xf,0xc2,0x62,0x96,0x97,0x97,0x71,0xe7,0xce,0x1d,0x74,0x75,
0x75,0x41,0xaf,0xd7,0x67,0x55,0x3e,0xa5,0x7f,0xb9,0x2e,0x93,0x4d,0x8,0xb5,0xce,
0x6c,0x32,0x63,0x64,0x78,0x4,0xe7,0x2f,0x9d,0x7,0x43,0x18,0xb4,0x35,0xb7,0x25,
0x97,0x5c,0xb5,0xf,0x21,0x24,0xa5,0x7f,0xfa,0x7d,0x39,0xc0,0x4,0x2,0x1,0xcc,
0xce,0xce,0xa2,0xb1,0xb1,0x11,0x35,0x35,0x35,0x79,0xfb,0xae,0x30,0x56,0x9,0x88,
0x3a,0x5e,0xa1,0x49,0x1c,0xf5,0xe,0xf4,0x3b,0xfb,0x31,0xf1,0xbf,0x13,0x60,0x59,
0x16,0xf5,0xb5,0xf5,0x39,0x95,0xa8,0x24,0x85,0x42,0x21,0xdc,0xbc,0x79,0x13,0x56,
0xab,0x15,0x1b,0x36,0x6c,0xc8,0x39,0x57,0x96,0x3c,0x24,0x27,0xad,0x3a,0xa8,0xa6,
0xd7,0x39,0x3b,0x9d,0xb8,0xef,0xbf,0x8f,0xf,0xaf,0x7c,0x88,0x4d,0x3,0x9b,0x50,
0x63,0x8f,0x3f,0xad,0x6c,0x9,0x9a,0xda,0x5f,0xcb,0xd3,0xde,0x17,0xc3,0x8b,0x46,
0xa3,0x98,0x99,0x99,0x81,0x4e,0xa7,0x83,0xd3,0xe9,0xcc,0x6b,0x49,0x69,0x33,0x3,
0xa0,0xe5,0xe7,0x21,0xb9,0x26,0xd1,0xd6,0x6d,0x1e,0xda,0x8c,0xf7,0x42,0xef,0xe1,
0xf2,0xd4,0x65,0xb8,0xfa,0x5d,0x30,0x1b,0xcd,0x19,0xed,0xd5,0x3e,0xd9,0xdc,0xaa,
0x18,0x1e,0x10,0xdf,0xb9,0xde,0xb9,0x73,0x7,0x0,0xe0,0x74,0x3a,0x33,0xf8,0xb9,
0xe4,0xd3,0x5c,0xaf,0x3e,0x86,0x14,0xca,0x2e,0xb5,0x75,0xc,0xc3,0x60,0x64,0x78,
0x4,0xef,0x5d,0x78,0xf,0x57,0xa6,0xaf,0xe0,0xe1,0xee,0x87,0x51,0xa5,0xaf,0x4a,
0x2a,0x95,0x2b,0x8e,0xe4,0x8b,0x39,0xe9,0xfd,0x64,0x59,0xc6,0xc2,0xc2,0x2,0x24,
0x49,0x42,0x67,0x67,0x27,0xaa,0xaa,0xaa,0x8a,0x96,0x4f,0x3b,0x57,0x2e,0x2a,0xb8,
0xfd,0x2f,0x16,0x7d,0x95,0x4c,0x46,0x13,0x36,0x6f,0xda,0x8c,0xb,0xbf,0xb9,0x80,
0xa9,0x9b,0x53,0x70,0xb6,0x3b,0xa1,0xd7,0xe9,0x73,0x82,0x91,0x4e,0xf9,0x78,0x8a,
0xa2,0x60,0x69,0x69,0x9,0x92,0x24,0xa1,0xbe,0xbe,0x1e,0xb5,0xb5,0xb5,0x79,0x65,
0xc9,0x3a,0x4e,0x81,0x70,0x56,0xb2,0x85,0x14,0x33,0x71,0xc3,0xba,0x6,0xc,0x38,
0x7,0x30,0xf9,0xd1,0x24,0xae,0xdf,0xbe,0x8e,0x8d,0xad,0x1b,0x21,0xc9,0x12,0x6e,
0xdf,0xbb,0x8d,0x98,0x10,0x2b,0x2c,0x74,0x16,0xd2,0xeb,0xf5,0xa8,0xb3,0xd4,0x41,
0x96,0x65,0x58,0x2c,0x96,0xe4,0xd6,0xbe,0x90,0x2c,0x19,0x75,0x44,0xf3,0x37,0xb,
0x15,0x88,0x21,0x2b,0x83,0x15,0x33,0xb9,0xf6,0xbe,0xf3,0xa1,0x4e,0xf8,0x83,0x7e,
0xdc,0x75,0xdf,0xc5,0xcc,0xc2,0xc,0x24,0x41,0x82,0x2,0x25,0xe3,0x44,0xac,0x58,
0x92,0x65,0x19,0x81,0x48,0x0,0x76,0xb3,0x1d,0xdd,0xdd,0xdd,0x25,0x3f,0xa4,0x62,
0xa9,0x80,0xcb,0x64,0xe,0x5e,0xa,0x30,0xae,0x3e,0x17,0xbc,0x3e,0x6f,0xfc,0x33,
0x9,0x42,0x31,0x3c,0x38,0x8c,0x1,0xe7,0x40,0x5e,0x50,0xd4,0x4d,0xa1,0x28,0x8a,
0x90,0x24,0x9,0x92,0x24,0x21,0x1a,0x8d,0xe2,0xea,0x8d,0xab,0x70,0x2f,0xb9,0xe1,
0x9,0x7a,0xb0,0xec,0x5b,0xce,0x58,0xda,0x8b,0x95,0x8d,0x94,0x65,0x21,0x25,0x4c,
0x94,0x5e,0xa7,0x28,0xa,0xa6,0xae,0x4f,0x41,0x10,0x4,0x58,0x2c,0x16,0x3c,0xb1,
0xed,0x9,0x54,0xdb,0xab,0x93,0x7c,0xf5,0x48,0x40,0x55,0x5a,0x2d,0xd9,0x2c,0x92,
0xe3,0x38,0xc,0xf6,0xe,0xa2,0xc6,0x5e,0x83,0x8f,0x66,0x3f,0xc2,0x95,0xe9,0x2b,
0xe8,0xef,0xea,0x47,0x53,0x43,0x53,0xc9,0xb2,0xa9,0xb1,0x35,0x97,0xae,0x5,0x0,
0x29,0x3d,0x7e,0x0,0x40,0x4c,0x88,0x61,0x62,0x6a,0x2,0xf7,0xfd,0xf7,0xd1,0xdb,
0xdd,0x8b,0xe1,0xc1,0x61,0xb0,0x2c,0xb,0x45,0x51,0x32,0x3e,0xc6,0x2b,0x56,0x11,
0x0,0x68,0x6d,0x6a,0x85,0xcd,0x6a,0xc3,0xe4,0xb5,0x49,0x5c,0xbd,0x71,0x15,0x82,
0x28,0x60,0x7d,0xf3,0xfa,0xa2,0x65,0x2b,0xc6,0x8d,0xa,0x64,0xaa,0xd9,0xe3,0x47,
0xbe,0xc9,0x83,0xa1,0x20,0x26,0xa6,0x26,0xa0,0x28,0xa,0x3e,0xf7,0xd8,0xe7,0xd0,
0x50,0xd7,0x0,0x20,0xfe,0xd2,0x29,0x10,0x8,0xa4,0x9c,0x9c,0x17,0x33,0x5e,0xfa,
0xbd,0xd5,0x6c,0xc5,0xe6,0xc1,0xcd,0x98,0x9e,0x99,0xc6,0xec,0xdc,0x2c,0x44,0x49,
0x44,0x47,0x5b,0x47,0xde,0xb1,0xb4,0x94,0x58,0x35,0x1f,0x4c,0x50,0x5d,0xf4,0x2c,
0x62,0xea,0xfa,0x14,0x5a,0x9a,0x5a,0x30,0xf2,0xa9,0x11,0xe8,0x74,0xba,0xe4,0x7e,
0x43,0xfd,0x78,0x37,0x9f,0xe0,0xc5,0x2,0xc3,0xb2,0x2c,0x6,0xba,0x7,0x30,0xef,
0x9e,0xc7,0xed,0x85,0xdb,0xf1,0x9c,0x64,0x43,0x67,0xc1,0x1c,0x63,0x65,0x8c,0xdc,
0xbc,0x82,0x79,0x48,0xba,0x50,0xb9,0x84,0xbe,0x35,0x7f,0xb,0x73,0xf7,0xe6,0xb0,
0xf5,0xd3,0x5b,0xd1,0xda,0xdc,0xa,0x0,0xc9,0x17,0xd2,0xf9,0x3e,0xf8,0x2f,0xa7,
0xae,0xb5,0xb1,0x15,0x36,0x8b,0xd,0xd7,0x66,0xaf,0xe1,0xda,0xec,0x35,0x74,0xb7,
0x77,0xaf,0x7a,0x15,0x53,0xa9,0xe8,0x13,0xb3,0x6c,0xf9,0x8,0xa5,0x14,0x92,0x2c,
0x61,0xf2,0xfa,0x24,0x22,0xd1,0x8,0x9e,0xfa,0xec,0x53,0x68,0x6d,0x6e,0x4d,0x5a,
0x85,0xd7,0xeb,0x4d,0x6,0xca,0x6c,0x7d,0x2b,0x51,0x67,0xb3,0xd8,0xe0,0xea,0x73,
0x41,0xa1,0xa,0xa6,0x67,0xa6,0x21,0x2b,0xf9,0xff,0x49,0x22,0x6e,0x45,0xab,0xdc,
0xcb,0x50,0x25,0x7f,0xec,0x88,0xc6,0xa2,0x98,0xba,0x31,0x5,0x67,0xa7,0x13,0xed,
0xeb,0xdb,0x41,0x8,0x81,0x28,0x8a,0xf0,0xf9,0x7c,0x79,0xcf,0x53,0x2b,0x51,0xa7,
0x25,0x1d,0xa7,0x43,0xef,0xc6,0x5e,0xdc,0xfd,0xdd,0x5d,0x5c,0xbd,0x79,0x15,0xce,
0xe,0x27,0x74,0x5c,0xce,0x97,0x73,0x0,0x40,0x72,0x65,0xc4,0x59,0x2d,0x84,0x10,
0xa2,0xa7,0x74,0x5,0xc5,0x6c,0x4f,0xc9,0x1f,0xf4,0x63,0x66,0x7e,0x6,0x3b,0x3e,
0xb3,0x3,0x1d,0x1b,0xe2,0x9f,0x20,0x4,0x83,0xc1,0xe4,0xeb,0x49,0x6d,0xbf,0x4a,
0x59,0x47,0x1,0xd,0xd1,0xd6,0xd4,0x86,0xb6,0xa6,0x36,0xdc,0xb8,0x73,0x23,0x23,
0x23,0x56,0xdb,0x24,0x2,0x8,0x1,0x60,0x21,0x84,0x64,0xbc,0x30,0xe2,0xd2,0x3a,
0x30,0x0,0xaa,0x0,0x54,0x51,0xa,0x42,0x35,0xcb,0xae,0x56,0xb0,0x45,0xcf,0x22,
0xaa,0xc,0x55,0xd8,0xf9,0x99,0x9d,0x60,0x18,0x6,0x92,0x24,0xc1,0xe7,0xf3,0x25,
0xf,0x96,0xd3,0xa9,0x52,0x96,0x50,0xc,0x55,0x5b,0xab,0x61,0xac,0x32,0x62,0xee,
0x77,0x73,0x68,0x69,0x68,0x81,0xc9,0x60,0x4a,0x6d,0x40,0x8,0x68,0xfc,0x80,0xc8,
0x4,0x80,0x23,0x84,0xb0,0x0,0x62,0x94,0x52,0x5,0xd0,0x0,0x92,0x0,0xc3,0x90,
0x28,0x55,0x0,0x25,0x6a,0xaa,0xaa,0x5,0xc5,0xfd,0xb1,0x1b,0x1d,0xf,0x75,0xa0,
0xda,0x16,0x4f,0xb2,0x78,0x9e,0x47,0x20,0x10,0x28,0x39,0xa7,0xc8,0x57,0x57,0x2e,
0x55,0xe9,0xab,0xd0,0xd9,0xd6,0x9,0xb7,0xc7,0xd,0x45,0x51,0x60,0x31,0x59,0xd2,
0x5a,0x50,0x6,0x71,0x40,0x58,0xc4,0xbd,0x84,0x10,0x42,0x22,0x94,0x52,0xaa,0xb5,
0x10,0xbd,0xa6,0x18,0xa8,0x6,0xc,0x35,0x78,0x46,0x85,0x28,0x86,0xfa,0x87,0xc0,
0xb2,0x2c,0x64,0x59,0x86,0xcf,0xe7,0x4b,0x26,0x59,0xb9,0x94,0x7b,0x50,0x20,0xa4,
0x13,0x21,0x4,0xcd,0xf5,0xcd,0xf0,0x87,0xfc,0x8,0x86,0x83,0xb0,0x9a,0xe2,0x1f,
0xd1,0x90,0x95,0x14,0xc4,0x80,0xb8,0xeb,0x50,0x0,0x4a,0xa2,0x44,0xb9,0x44,0x67,
0x6,0x71,0x6b,0xd1,0x21,0xe,0x88,0xe,0xa0,0x44,0x15,0x5b,0x10,0x5,0xc4,0xc4,
0x18,0xd6,0x55,0xaf,0x83,0xcf,0xe7,0x8b,0xd7,0xa5,0xfd,0xb7,0x83,0x96,0x3e,0x29,
0x10,0xb2,0x91,0xdd,0x62,0x87,0x20,0xa,0x88,0xc4,0x22,0x30,0x99,0x92,0xee,0x43,
0x10,0xf,0xd,0xa,0x0,0x39,0x51,0x24,0x42,0x8,0xa3,0x5a,0x88,0x6a,0x3a,0x6c,
0xa2,0x24,0x2d,0x47,0x7d,0xfd,0x67,0x31,0x5a,0x72,0xa6,0xdc,0xa5,0xd4,0x7d,0x12,
0xa4,0x9e,0xc7,0x50,0x4a,0x1,0x2,0xf5,0xd4,0x9d,0x4b,0x14,0x55,0x67,0x6,0x0,
0xa3,0x75,0x19,0xa2,0xf9,0x25,0x0,0x8,0xa5,0xa,0x58,0x96,0x85,0xa3,0xc1,0x91,
0x11,0x5c,0xb3,0x25,0x6b,0xe5,0xf2,0xd6,0x9a,0xd2,0x32,0x59,0xa2,0x29,0xea,0x7d,
0xd2,0x12,0xb4,0x7e,0xa4,0x16,0xba,0x70,0x77,0x1e,0x54,0x59,0x79,0x5d,0x15,0xbf,
0xa6,0x9a,0x2e,0x48,0xa4,0xf7,0xea,0x65,0xba,0xb,0xd1,0x94,0x1f,0x85,0x2a,0x29,
0x2c,0x9a,0xb5,0x59,0x3a,0x38,0xb4,0xc4,0xf6,0x48,0xa,0x44,0xd3,0x1a,0x53,0x0,
0xb3,0xb3,0x33,0x48,0xbc,0x86,0x48,0xd7,0x57,0x1,0x90,0xc,0xaa,0xb2,0xa6,0x48,
0x0,0xc4,0x68,0x34,0x76,0xf9,0xea,0xd4,0xff,0xec,0x98,0x9a,0xbc,0x2,0x4a,0x29,
0x89,0x9b,0x5c,0x22,0x9d,0xd7,0xe4,0x8,0xc9,0x7a,0xed,0x3d,0x34,0x39,0x44,0x3a,
0x2f,0x85,0xaf,0xc9,0x71,0xd2,0xc7,0xcb,0xd2,0x26,0x39,0x5e,0x12,0xf8,0xdc,0x72,
0x20,0xc7,0x3c,0x94,0x52,0x2a,0xcb,0xf2,0x24,0x0,0x1,0xf1,0xff,0x1a,0x97,0xb4,
0xfa,0x27,0x3f,0xcb,0x24,0x84,0xe8,0x0,0x18,0x91,0xb2,0xf4,0xa2,0xa,0xc9,0x20,
0xb,0x36,0xd1,0xa9,0xb8,0x1d,0xd4,0xef,0xf,0x29,0x88,0xeb,0xa0,0x6,0x50,0x11,
0x71,0x30,0x62,0x89,0x12,0x5,0x10,0x1,0xc0,0x53,0x4a,0x95,0x64,0xc,0xa1,0x94,
0x8a,0x64,0xc5,0xc9,0x68,0xda,0x0,0x6a,0xf0,0xf9,0x43,0x4,0x84,0x22,0xae,0x38,
0x85,0xc6,0x3,0x90,0xa,0xa,0x9f,0x91,0x98,0x1,0x0,0xa5,0x54,0x20,0x84,0x64,
0x3,0x83,0x43,0x3c,0xa,0x53,0x64,0x75,0xda,0xdf,0x6b,0x22,0x58,0x91,0x5d,0x41,
0x1c,0x10,0x15,0x94,0x28,0x80,0x8,0xd5,0x4,0xbe,0xac,0x5f,0x32,0x27,0xc,0x45,
0x87,0xb8,0xcb,0x68,0x97,0xa5,0xff,0xf,0x80,0xc8,0x48,0x58,0x87,0x6a,0x15,0x29,
0x8d,0xb,0x2d,0x79,0x9,0x37,0x4a,0xa6,0xb8,0xf8,0xc3,0x4,0x44,0x7d,0x90,0x32,
0x0,0x4a,0xf3,0x28,0xfd,0x7f,0xf2,0x6,0x74,0xf7,0xf5,0x16,0xd3,0x90,0x0,0x0,
0x0,0x0,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
// /home/newdrone18/workspace/qtbook-master/20.02.27_Qt_Programming_Korean_v1.4_Example_Source_code/Ch03/01_BasicWidget/01_QCheckBox/resources/users.png
0x0,0x0,0x14,0xe9,
0x89,
0x50,0x4e,0x47,0xd,0xa,0x1a,0xa,0x0,0x0,0x0,0xd,0x49,0x48,0x44,0x52,0x0,
0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x8,0x6,0x0,0x0,0x0,0xaa,0x69,0x71,0xde,
0x0,0x0,0x0,0x4,0x73,0x42,0x49,0x54,0x8,0x8,0x8,0x8,0x7c,0x8,0x64,0x88,
0x0,0x0,0x0,0x9,0x70,0x48,0x59,0x73,0x0,0x0,0x12,0x74,0x0,0x0,0x12,0x74,
0x1,0xde,0x66,0x1f,0x78,0x0,0x0,0x0,0x19,0x74,0x45,0x58,0x74,0x53,0x6f,0x66,
0x74,0x77,0x61,0x72,0x65,0x0,0x77,0x77,0x77,0x2e,0x69,0x6e,0x6b,0x73,0x63,0x61,
0x70,0x65,0x2e,0x6f,0x72,0x67,0x9b,0xee,0x3c,0x1a,0x0,0x0,0x14,0x66,0x49,0x44,
0x41,0x54,0x78,0x9c,0xed,0x9b,0x79,0x8c,0x5d,0xd7,0x7d,0xdf,0x3f,0xe7,0xdc,0xfd,
0xad,0x43,0xce,0xc,0x87,0xe4,0xc,0x49,0x89,0x22,0x23,0xc9,0x92,0x4c,0xd9,0x92,
0xb7,0x3a,0x96,0x23,0x19,0x56,0x14,0x39,0x8d,0x81,0xc2,0xcb,0x3f,0xdd,0xd2,0xa2,
0x29,0x10,0x20,0x89,0xb3,0x0,0x6d,0xd1,0xa6,0xaa,0x8a,0x2,0xe,0xdc,0x2d,0x70,
0x11,0x24,0x56,0x5b,0xa0,0x9,0xfc,0x47,0x92,0xc2,0x68,0x5a,0x24,0x8e,0x93,0xd4,
0x49,0xbc,0xc0,0x92,0x2a,0xd9,0x6e,0x24,0x55,0x9b,0x25,0x52,0x5c,0x67,0xe7,0x9b,
0x99,0xf7,0xde,0x7d,0x77,0x39,0xe7,0xfc,0xfa,0xc7,0xbd,0xef,0xcd,0x90,0xa2,0x14,
0xe,0x45,0x5a,0x6,0x92,0x3,0xfc,0x70,0x2f,0xde,0xbb,0xcb,0xf9,0x7e,0x7f,0xeb,
0xf9,0xdd,0x7b,0x95,0x88,0xf0,0x57,0x79,0xe8,0xb7,0x7b,0x2,0x6f,0xf7,0xf8,0x6b,
0x2,0x6e,0xe4,0xc5,0x7f,0xf1,0x47,0x1b,0x87,0x7e,0xf6,0xe1,0xc6,0xc2,0x8d,0xbc,
0xc7,0x5b,0x1d,0xea,0x7a,0xc5,0x80,0x47,0x1f,0x55,0xba,0xf7,0xad,0xc6,0xc3,0xc0,
0xfb,0x94,0x72,0xef,0x3,0xf5,0x1e,0x81,0xa9,0xea,0x2e,0xf4,0x10,0xf9,0x3f,0xa0,
0x9f,0x54,0xc2,0x13,0xbf,0xfa,0xc7,0xe9,0x57,0xe4,0x7,0x24,0xf8,0x5c,0x17,0x2,
0x7e,0xe1,0xa1,0xf8,0x98,0x43,0xff,0x16,0xf0,0x81,0x38,0xa,0x8a,0x4e,0xbb,0x19,
0x34,0x1b,0xd,0xd5,0x6a,0x36,0x70,0x38,0x6,0xfd,0x94,0xc1,0x20,0x95,0xc1,0x30,
0x2d,0xf3,0xd2,0x84,0xa,0xbe,0x8e,0x92,0xbf,0xf7,0x1f,0xff,0x70,0xf4,0xda,0x5b,
0xbe,0xf9,0x5b,0x1c,0x6f,0x89,0x0,0xa5,0x94,0xfa,0xb9,0x87,0x92,0x9f,0x51,0xc2,
0xe7,0x92,0x38,0xf6,0xee,0xb8,0xed,0xa8,0xdf,0xe9,0xb4,0x51,0x4a,0x21,0xce,0x62,
0xca,0x1c,0x27,0xe,0x94,0x8f,0x13,0x30,0xc6,0xb2,0xd9,0xdf,0xe2,0xd4,0x6b,0x8b,
0xa6,0x28,0x8b,0xd2,0x89,0xfa,0x85,0xcf,0xff,0x51,0xfa,0x85,0xb7,0xd3,0x1a,0xae,
0x99,0x80,0x47,0x1f,0x55,0xba,0xf7,0x78,0xfc,0x65,0x50,0xf,0x1e,0x9e,0xdf,0xaf,
0x8e,0xdf,0x72,0x4,0x4f,0x83,0x2d,0x6,0xe0,0x4a,0xc4,0x39,0x44,0x4,0xe7,0x1c,
0xc6,0x58,0x8c,0x13,0x1c,0x1a,0xbc,0x4,0xeb,0xe0,0xfc,0xe2,0x32,0xcb,0xab,0x3d,
0x34,0x7c,0xe9,0x3f,0x7c,0x25,0xfd,0xc4,0x75,0xc6,0x75,0xd5,0xe3,0x9a,0x83,0xe0,
0xc6,0xe3,0xc9,0xcf,0x82,0x7a,0xf0,0x5d,0x77,0xdd,0xaa,0x6e,0xbf,0xf5,0x28,0x1e,
0x25,0xe4,0x9b,0x84,0x5a,0x88,0xc2,0x90,0x24,0x8e,0x89,0xe3,0x98,0x28,0x8a,0x88,
0xa2,0x88,0x30,0xf0,0xf0,0xc4,0x60,0xb2,0x1e,0x98,0x11,0x87,0xe6,0xf,0x70,0xfc,
0xe8,0x21,0x9c,0xf0,0xb7,0x7e,0xfe,0x47,0x93,0x7f,0x70,0x3d,0x41,0xed,0x66,0x5c,
0x93,0x5,0xfc,0xdc,0x83,0xf1,0x71,0xad,0xf5,0x73,0x87,0x17,0xf6,0x87,0xb7,0x1d,
0x3f,0x8a,0xcd,0xb7,0xf0,0xb5,0x23,0xf0,0x7d,0x7c,0xdf,0x43,0xeb,0x8a,0x57,0x71,
0x82,0xb1,0x16,0x63,0xc,0x45,0x59,0x92,0x17,0x5,0x45,0x5e,0x92,0x15,0x39,0xd6,
0x69,0xe2,0xf6,0xc,0x67,0xcf,0x2f,0xb2,0xbc,0xda,0x4b,0xb1,0xdc,0xfe,0xab,0x7f,
0x92,0x9e,0xb9,0xde,0x0,0xff,0xb2,0xe1,0xef,0xf6,0x84,0x47,0x1f,0x55,0x5a,0x7b,
0xc9,0x17,0x1b,0x8d,0x58,0x1d,0x3b,0x7a,0x4,0x31,0x29,0xbe,0x76,0x44,0x61,0x40,
0x10,0x4,0x4,0xbe,0x8f,0xe7,0x79,0x0,0xb5,0xf9,0x1b,0x8a,0x31,0x21,0xb5,0x4b,
0xf8,0xd6,0xc7,0x98,0x9c,0x22,0xeb,0x33,0x7f,0x60,0x8e,0x8d,0xfe,0x30,0x28,0xb2,
0xe2,0x37,0x95,0x52,0xf,0x7c,0xbf,0xe3,0xc1,0xae,0x5d,0xe0,0xe2,0x13,0xc9,0xc7,
0x45,0x78,0xcf,0xed,0xc7,0x8e,0x6,0x5a,0x9,0x62,0x32,0x7c,0xdf,0x23,0x8,0x2,
0xa2,0x30,0x24,0x8a,0x22,0xe2,0xb8,0x96,0x28,0x22,0xc,0x43,0xc2,0xc0,0xc7,0xf,
0x7c,0x7c,0xcf,0xab,0x45,0xe3,0x79,0x9a,0x3c,0xdd,0x4,0x71,0x1c,0x3d,0x7c,0x20,
0x10,0xf8,0x91,0xcf,0x3c,0xd8,0x78,0xe8,0x46,0x80,0x7c,0xb3,0xb1,0x6b,0x2,0x94,
0xe3,0x3,0x49,0x12,0x96,0x9d,0x4e,0xb,0x9b,0xf5,0xd1,0x5a,0x4d,0x80,0x5,0x81,
0x4f,0x14,0x6,0xc4,0x51,0x44,0x12,0xc7,0x84,0x51,0x48,0x18,0x4,0xf8,0x7e,0x5,
0xde,0xf3,0x3c,0xb4,0xae,0x5c,0x44,0x6b,0x8d,0x2,0xf2,0x74,0x83,0x66,0xa3,0x49,
0x14,0x6,0x5,0x8a,0xf,0xdc,0x0,0x8c,0x6f,0x3a,0x76,0xed,0x2,0x78,0xbc,0xaf,
0xdd,0x6c,0x86,0x4a,0x81,0x75,0x25,0x5a,0x85,0x28,0x55,0x1,0xf2,0xb4,0x87,0xef,
0xfb,0x44,0x61,0x88,0xd6,0xa,0x0,0x6b,0x4c,0x5,0x58,0x69,0x94,0x52,0xdb,0x82,
0x42,0x1,0xb6,0xcc,0x1,0x68,0x25,0x49,0xb0,0x5e,0x6c,0xbe,0x17,0xe0,0xf1,0x47,
0xbb,0x7b,0xb,0xe7,0xdf,0xa3,0x44,0xee,0x11,0xe4,0x7d,0x5a,0xe9,0x77,0x20,0xee,
0x59,0x11,0xf5,0x94,0xd2,0xee,0x69,0x55,0xf0,0x9d,0x1f,0xfe,0xec,0x46,0xef,0xfb,
0x4e,0x40,0x95,0xf7,0xe3,0x77,0xb7,0x5b,0x4d,0x9c,0x35,0x70,0x99,0xbb,0xa,0x32,
0xd9,0x56,0x7f,0x8d,0x7f,0xd9,0xb9,0xb7,0xf3,0x78,0x10,0x71,0x88,0xb3,0x34,0x5a,
0xb1,0xca,0x8b,0xfe,0xfb,0xbf,0xfe,0xc8,0xf4,0xd7,0x10,0xef,0x3e,0x85,0xe0,0x7,
0x71,0x11,0xb7,0xbb,0x41,0x14,0x26,0xaa,0x18,0xd,0x8e,0x8d,0xd2,0xad,0x1f,0x37,
0x65,0x11,0x49,0x0,0xdf,0x78,0x64,0xfa,0xab,0xa5,0x75,0xff,0xf0,0x81,0x7f,0xd3,
0x3b,0x7d,0xd,0xb8,0xb7,0x31,0xed,0x26,0xe6,0xd4,0x15,0xdf,0xf7,0xde,0x79,0xfb,
0x31,0xba,0xed,0x8,0x6d,0x47,0x13,0x5f,0x1f,0x6f,0xa3,0x30,0x24,0x8,0x7c,0x94,
0x82,0xd2,0x58,0x8a,0xa2,0x20,0xcb,0xb,0xb2,0x2c,0x27,0xcb,0x73,0xb2,0x2c,0x63,
0x94,0xe5,0x64,0x59,0xce,0x28,0xcb,0x0,0x48,0xda,0xd3,0x24,0x6a,0xc0,0x5c,0x63,
0x40,0xd2,0x68,0x97,0xb3,0x87,0xef,0xc,0xe2,0xd6,0xc,0x5e,0x10,0x55,0x44,0x89,
0x1,0x71,0x60,0x4b,0x4c,0xde,0x27,0x1f,0x5c,0x64,0x65,0xf1,0x54,0x69,0x8a,0xac,
0x14,0xe1,0xe7,0xef,0xfb,0xd7,0xeb,0x8f,0x5d,0x2b,0x1,0xbb,0xb2,0x0,0xeb,0x50,
0x4a,0x83,0xa3,0x8a,0xe6,0xe2,0x2c,0xd6,0x56,0x62,0x8c,0xa1,0xac,0xa3,0xbd,0xb5,
0x16,0x14,0x58,0xeb,0x28,0xcb,0x12,0x63,0xc,0xd6,0x9a,0xfa,0x58,0x87,0x73,0x95,
0x0,0xf8,0x5a,0x98,0x4f,0x2e,0x12,0x79,0x25,0x33,0xf3,0xb7,0x31,0x7d,0xe8,0xae,
0x0,0x5,0x98,0xc,0x29,0xfa,0x88,0xcd,0x70,0xa6,0x4,0x4,0x5,0x28,0x14,0x49,
0x67,0x96,0xc3,0xad,0x3d,0x41,0x6f,0xf9,0xb5,0xa0,0xb7,0x7a,0xfe,0x37,0xbe,0xf1,
0x2f,0xa7,0x3f,0xad,0x4a,0xfb,0x89,0x6b,0x71,0x8b,0x5d,0x5,0xc1,0xcf,0xff,0x49,
0xfe,0xa,0x4a,0x86,0x83,0x41,0xa,0xca,0xc7,0x1a,0x8b,0x31,0x96,0xd2,0x18,0xca,
0x3a,0xcf,0xe7,0x79,0xa5,0xd9,0x51,0xad,0xf1,0xbc,0x28,0x28,0x8a,0x92,0xb2,0x34,
0x18,0x63,0x30,0x35,0x61,0xd6,0x59,0x0,0x16,0xa6,0x1c,0x8d,0x58,0x73,0xf3,0x5d,
0xf7,0x33,0x73,0xf3,0x3d,0x20,0x16,0x97,0x6d,0x21,0xce,0x82,0xe,0x50,0x41,0xb,
0x1d,0x75,0x50,0x7e,0x82,0x28,0x8d,0xd8,0xc,0x3b,0x5c,0x41,0x6c,0xc6,0xde,0x3,
0xc7,0x58,0x38,0x76,0x42,0x69,0xdf,0xbb,0x4f,0x2,0xfd,0x85,0xdd,0x82,0xdf,0x35,
0x1,0x22,0x22,0xa,0xf5,0x9d,0xc1,0x30,0xc5,0xa1,0x31,0xb5,0x86,0x8b,0xa2,0x24,
0x2f,0x4a,0xf2,0xbc,0xa8,0xcc,0xbc,0x36,0xf5,0x2c,0xcb,0xc9,0xf3,0xa2,0x22,0xa1,
0xdc,0x41,0x42,0x4d,0xdc,0x9e,0x86,0xa3,0x19,0x3b,0xe6,0x8f,0xbf,0x97,0xa8,0xb3,
0x1f,0x97,0x6d,0x20,0xb6,0x44,0x47,0x6d,0x74,0xd4,0xa9,0x24,0xec,0xa0,0xc3,0x76,
0x25,0x41,0x13,0x1d,0x34,0x50,0x41,0x82,0xcb,0xfb,0x98,0xfe,0x79,0xa2,0xb8,0xc9,
0xdc,0xc2,0x6d,0xbe,0xc0,0x27,0xbf,0xfe,0xc8,0xf4,0xa7,0x6f,0x28,0x1,0x0,0xe2,
0x78,0x62,0x90,0xa6,0x85,0x31,0x6,0x2b,0x9a,0xa2,0x2c,0x29,0x8a,0x62,0x2,0x7e,
0x94,0x5d,0x6a,0x1,0x59,0xbe,0x83,0x84,0xa2,0xac,0x88,0x30,0x25,0x81,0x27,0xec,
0xef,0x38,0xf6,0xce,0x1d,0xa5,0xb1,0xe7,0x10,0x2e,0xdf,0x2,0xe5,0xa1,0xc3,0x66,
0x5,0x36,0xea,0xee,0x90,0x36,0x3a,0x6c,0xa1,0xc3,0x26,0xca,0x6f,0xa0,0xfc,0x18,
0xe5,0xc7,0x88,0x58,0xcc,0x60,0x91,0x46,0x67,0x9a,0xa9,0xbd,0x73,0xa2,0x84,0xc7,
0xbe,0xf1,0xcf,0x67,0xf,0xdc,0x50,0x2,0x94,0xe6,0x89,0x2c,0x2b,0x83,0x34,0x4d,
0x51,0x41,0xa3,0xd6,0x7e,0x65,0xfa,0xe3,0x60,0x57,0x5,0xb9,0x8c,0x51,0x96,0xd5,
0x4,0xd4,0x24,0x94,0x15,0x9,0xd6,0x3a,0xe,0x74,0x1d,0x61,0x94,0x30,0x73,0xe4,
0x4,0x52,0xa6,0x80,0xa0,0x83,0x4,0x15,0x34,0x6b,0xb0,0x63,0x2b,0xd8,0xd6,0xbe,
0xf2,0x93,0xa,0xbc,0x17,0xa1,0xbc,0x10,0xa5,0x3,0x9c,0x19,0xe1,0xf2,0xd,0xa6,
0xf,0x1c,0x53,0x7e,0x18,0x26,0xce,0x33,0x9f,0xbf,0xa1,0x4,0x9c,0x6f,0x8f,0xfe,
0xa7,0x13,0x9e,0x39,0x75,0xe6,0x82,0x41,0x79,0xe0,0x27,0xb5,0xf6,0x8b,0x89,0xd9,
0x6f,0x93,0x90,0x4f,0xa2,0x7f,0x9e,0x57,0x56,0x62,0x6d,0xe5,0xfb,0xad,0xc8,0x31,
0x33,0x7f,0x1c,0xa5,0x7c,0x5c,0xd9,0x47,0xe9,0x10,0xe5,0x45,0x68,0x3f,0x46,0x5,
0xd,0x74,0xd8,0xc6,0x8b,0xba,0x95,0xb,0x8c,0xc1,0x7b,0x71,0x5,0xdc,0xb,0x50,
0xda,0xaf,0x44,0xf9,0x98,0xc1,0x12,0x4a,0x9,0x53,0xd3,0x7,0x3,0x8d,0xde,0x55,
0x35,0xb9,0x6b,0x2,0x7e,0xf7,0x77,0xc5,0xae,0xf4,0xcc,0x3f,0x4a,0x47,0xb9,0x5e,
0x5c,0x5a,0x21,0x88,0x5b,0x58,0xf4,0xc4,0xdc,0x47,0x79,0x56,0xbb,0x40,0xb6,0x4d,
0x48,0xed,0x2,0xe3,0xc8,0x1f,0xfb,0x55,0x44,0x8f,0x9b,0x7b,0x10,0x93,0x55,0xd3,
0xd0,0x1e,0x68,0x1f,0x74,0x88,0xf6,0xe2,0xca,0xdf,0xc3,0xe,0x3a,0x6c,0xd5,0x5a,
0xdf,0x9,0xda,0x3,0xe5,0x81,0xd2,0x95,0x88,0xc5,0x95,0x43,0xe2,0x66,0x7,0x41,
0x5a,0x7f,0xfa,0xcb,0x53,0xb7,0x5c,0x2d,0x9e,0x5d,0x57,0x82,0x1f,0xfd,0xa8,0xea,
0xe6,0x6d,0xff,0x5f,0x14,0xa5,0x55,0x2c,0xaf,0xd3,0x69,0x37,0x69,0x75,0x66,0x29,
0x46,0x7d,0xf2,0xd1,0x16,0x88,0x79,0xf3,0xb,0x28,0x45,0xbb,0x15,0xa3,0xd4,0x80,
0x30,0x69,0x21,0x36,0x1f,0xff,0x1,0x54,0x55,0x22,0x4a,0x81,0xf6,0x50,0x7e,0xc,
0xa5,0xdb,0x6,0xaa,0xd4,0x8e,0x63,0xab,0x6b,0x8d,0x77,0xc5,0x64,0x84,0xc9,0xc,
0xa,0xc4,0xd7,0xde,0xbd,0xc0,0xab,0x57,0x83,0x67,0x57,0x16,0xf0,0xc0,0x43,0xe1,
0x9,0xeb,0x79,0xcf,0xf9,0xa1,0x7a,0xb8,0x7d,0x6c,0xaf,0x52,0xad,0x6,0x2f,0xbe,
0x7a,0x86,0xc5,0xc5,0x55,0x82,0xb8,0x4d,0xb3,0x3b,0x87,0x1f,0xc4,0x55,0xb1,0xf0,
0x3a,0xdc,0x1a,0x3f,0x88,0x69,0x76,0xe7,0x48,0x42,0x45,0x18,0x37,0x51,0xca,0x43,
0xca,0x11,0x20,0x55,0xa1,0x53,0x57,0x85,0xe2,0xc,0x62,0x32,0x5c,0xbe,0x89,0x33,
0x23,0xb0,0x25,0x38,0x3,0x62,0xab,0x63,0xc4,0xd5,0xe7,0xc8,0xa4,0x1a,0x15,0x33,
0x42,0x69,0x9f,0x30,0x6a,0x94,0x82,0xdc,0x73,0xb5,0x98,0xae,0xda,0x2,0x1e,0x78,
0x28,0x3c,0x1,0xf2,0xf5,0xb8,0xa1,0x9b,0xef,0xb8,0xe3,0xb0,0xd7,0x48,0xf6,0xb1,
0x9c,0x2c,0x92,0x9d,0x19,0x22,0xcb,0x6b,0x5c,0xdc,0xea,0x73,0xf4,0xc8,0x3c,0x49,
0x67,0x16,0x0,0x67,0xd,0xd6,0x54,0xda,0xf5,0xfc,0x8,0xed,0x55,0xb7,0x1a,0xa5,
0x23,0xd2,0x72,0x8b,0x70,0xef,0x2c,0x22,0x16,0x67,0x72,0xb4,0xf6,0x11,0x57,0x22,
0xb6,0x40,0x6c,0x8e,0x94,0x1e,0x4e,0x4,0xa5,0x7d,0x44,0x2c,0x62,0x72,0xc4,0x64,
0xd5,0xff,0xce,0x54,0x64,0x8c,0x45,0xaa,0x98,0x22,0xb6,0x4,0x20,0x8,0x43,0x3f,
0xcb,0xd3,0x43,0xd7,0x95,0x80,0xf,0x7f,0x34,0xba,0xcb,0xf3,0xe4,0xcf,0x93,0x86,
0xd7,0xb8,0xfb,0xdd,0xc7,0xbd,0x56,0x73,0x8a,0x95,0xb5,0xd7,0x48,0xb3,0x35,0xf2,
0x8e,0x90,0x6,0xc2,0xec,0x30,0xe7,0xf9,0x17,0x4f,0x12,0xc6,0x21,0xed,0x46,0x4c,
0x23,0x49,0x68,0x34,0x63,0x0,0xd2,0xad,0x4d,0xd2,0xd1,0x88,0x7e,0x9a,0x91,0x67,
0x5,0xb7,0xdf,0x1c,0x32,0x4c,0xfb,0x15,0x18,0xad,0xb7,0x81,0xdb,0x0,0x31,0x1e,
0xe,0x41,0x39,0x53,0xfb,0xb7,0x20,0xae,0x40,0xcc,0x8,0x67,0xb2,0x8a,0x8,0x57,
0x20,0xb6,0xac,0x2c,0xc5,0x55,0x2e,0xa7,0xfc,0xea,0x5e,0xf9,0x28,0x35,0xc0,0xb3,
0xd7,0x8d,0x80,0xfb,0xef,0x57,0x53,0x5e,0xe4,0xff,0x71,0xab,0x19,0xb6,0xee,0xbe,
0xe7,0x76,0x3f,0x8a,0x43,0x96,0x56,0x5e,0x22,0x2f,0x6,0x84,0x1,0x20,0x8a,0x2,
0x61,0xd1,0x73,0xcc,0xb7,0xda,0x94,0x43,0x4b,0x9a,0xa6,0x78,0xbd,0xfe,0xc4,0x3c,
0x9d,0x82,0x32,0xf0,0x50,0xcd,0x0,0xe6,0x5a,0x6c,0xcc,0x7a,0x38,0x93,0x61,0x8b,
0xb4,0x6a,0xa0,0x9a,0xc,0xd1,0x3e,0xa2,0x34,0x4e,0x40,0x39,0x83,0xd2,0x79,0x45,
0x0,0xae,0x76,0x89,0xbc,0x26,0x61,0x54,0x5b,0x43,0x5e,0xc5,0xf,0x71,0x13,0x2,
0x9c,0xc9,0x28,0x4d,0x11,0x6a,0xa5,0xbe,0x7d,0xdd,0x8,0x50,0x51,0xf0,0x1b,0x4a,
0x33,0x7d,0xe7,0x89,0x5b,0x7c,0x3f,0xf0,0x38,0xbf,0xf8,0x3c,0xd6,0x16,0x68,0xd,
0x51,0xac,0x50,0x4a,0x50,0x4a,0xa1,0xb5,0x60,0x3a,0xd0,0x38,0xd0,0x22,0xcf,0x1d,
0xa7,0x4f,0x5e,0x84,0xdc,0x22,0x2,0x5,0xe0,0xfb,0x8e,0x9b,0x8e,0x74,0x49,0x1a,
0x1e,0xeb,0x59,0xe,0x3e,0xe4,0x69,0x8f,0x38,0x69,0x57,0xc0,0x94,0x6,0x4,0x25,
0xe,0xe5,0xa,0x94,0xe,0xaa,0x20,0x27,0x52,0x11,0x30,0x71,0x8f,0xf4,0x12,0x12,
0x26,0xf3,0xf4,0x13,0xb2,0xd1,0x0,0x0,0xab,0xcb,0xeb,0x43,0xc0,0x3,0xf,0xf9,
0x1f,0x17,0x51,0x9f,0x3e,0x7a,0xcb,0xc,0xad,0xe6,0x14,0x4b,0xab,0x2f,0x63,0x4c,
0x3e,0x59,0xeb,0x3,0x44,0x49,0x5,0xde,0xf3,0x15,0x79,0x3e,0x62,0x66,0xae,0x49,
0x91,0xe7,0x44,0xb1,0xc3,0x6,0xa,0xe7,0x84,0x6,0x55,0xb4,0x2e,0x8b,0x8c,0xe9,
0x7d,0x6d,0xce,0xad,0xc,0x29,0xf6,0xf8,0x64,0x83,0x4d,0x92,0xe6,0x5e,0xc4,0x95,
0x50,0xe,0x71,0xe2,0x6a,0xed,0x57,0x29,0x6f,0xe2,0x2,0x62,0x6b,0x2,0x2a,0x57,
0xa8,0x2c,0x21,0xbd,0x44,0xfb,0x3a,0x6c,0x91,0xad,0x2f,0x3,0x6a,0xe9,0x47,0x1e,
0xd9,0x5a,0xbb,0x2e,0x4,0x80,0x7a,0xb4,0xd5,0xf1,0xdd,0xc2,0xc2,0x61,0x3d,0x48,
0x2f,0x32,0xca,0x36,0xc7,0x4a,0xd9,0xce,0x48,0x2,0x61,0xac,0xf0,0x2d,0x94,0x85,
0x65,0x73,0x63,0x13,0xcf,0xd3,0xc4,0x31,0x38,0x1,0x11,0x5,0xf5,0xf1,0x5a,0x1b,
0xfa,0xbd,0x1,0x9e,0x6f,0x79,0xb9,0x54,0x4,0x2b,0x67,0x69,0x4f,0xcd,0xe1,0x45,
0x53,0x98,0x74,0xb9,0x2,0x6f,0xb,0x94,0x17,0x80,0xf2,0xaa,0x94,0x28,0x52,0xf7,
0xc,0x4a,0xb0,0x5,0xce,0x56,0x71,0x0,0x37,0x4e,0xb7,0xa,0xbf,0x75,0x90,0x32,
0x1f,0xd2,0x5b,0x5f,0x74,0x69,0xe1,0xfe,0xcb,0xd5,0x82,0x87,0x37,0x49,0x83,0xf,
0x3c,0x18,0x7c,0x44,0x84,0x13,0x37,0xdd,0x34,0xaf,0xb5,0xf6,0x59,0xbb,0x78,0x66,
0x47,0xff,0xa3,0x6a,0x78,0x48,0x85,0x1f,0x4,0x3c,0xf,0x92,0x86,0xc2,0x99,0x9c,
0xb2,0x18,0x91,0x34,0x14,0x71,0xa2,0x48,0x12,0x45,0xa3,0xa9,0x68,0xb6,0x14,0x8a,
0x92,0x6c,0x34,0xc4,0xf3,0xe1,0xd9,0xcc,0xb0,0x55,0x3a,0x2e,0x9c,0x79,0x1,0x15,
0x24,0x68,0xbf,0x81,0x2b,0xfa,0xb8,0x62,0xb,0x97,0x6f,0x55,0x29,0x30,0xdf,0xc4,
0x16,0x5b,0xb8,0x62,0xb3,0xfa,0xbd,0xe8,0x23,0xc5,0x60,0x7,0x78,0xf0,0x1a,0x33,
0x28,0x3f,0x64,0xf1,0xcc,0x8b,0x36,0x2f,0xe5,0xe5,0x7f,0xf5,0xa5,0x8d,0x7f,0x7b,
0x5d,0x8,0x10,0xe4,0x13,0x51,0xec,0x95,0x33,0xb3,0xfb,0xe9,0xf5,0xce,0x63,0x4d,
0x95,0x66,0x44,0x5e,0x2f,0x6e,0x2c,0xe,0xb4,0xaa,0xc8,0x88,0x62,0x45,0xa3,0xa1,
0x48,0x9a,0x8a,0x28,0x51,0x4,0x61,0x15,0x2f,0xea,0x8b,0x93,0xb9,0x84,0xc7,0x4e,
0x7d,0x90,0x3c,0x1d,0xb2,0xb1,0x7a,0x6,0xaf,0xb9,0xf,0x2f,0x9e,0xaa,0x7c,0x3c,
0xaf,0x0,0xdb,0x9,0x11,0x5b,0x48,0x31,0xb8,0xc4,0xe7,0x41,0x55,0xe7,0x34,0x66,
0xe9,0x2d,0x9f,0x21,0x4b,0x53,0xfd,0x5f,0xbf,0xb3,0xf0,0xef,0x9e,0x7c,0x85,0xd1,
0x6e,0x8,0x78,0x63,0x17,0xd0,0xea,0x44,0xab,0xd3,0x8,0x34,0x9a,0xc1,0x70,0x63,
0xa2,0xe9,0x31,0x9,0x5a,0x4b,0x15,0xde,0xab,0x2,0xe,0x14,0x88,0x2,0x75,0x59,
0x83,0x69,0x7c,0xde,0xd8,0x62,0x10,0x58,0x1f,0x1c,0xe1,0xd9,0xa5,0x4f,0xe1,0x24,
0xe0,0x9b,0x59,0xc2,0x87,0x16,0xff,0x14,0x71,0x8e,0x3d,0x73,0x87,0xd1,0x61,0x1b,
0x33,0xb8,0x50,0x97,0xc8,0x57,0x1e,0xca,0x8f,0xf1,0xdb,0xf3,0x28,0x1d,0xd0,0x5b,
0x3e,0xc5,0xfa,0xf2,0x39,0x7e,0xfb,0xd4,0xbd,0xf2,0xcd,0xec,0xee,0xff,0x74,0xe4,
0xe1,0x4f,0x6d,0x0,0x5f,0x7a,0xcb,0x4,0x28,0xe1,0xf6,0x76,0xa3,0x89,0x75,0x96,
0xb2,0xcc,0x19,0x17,0x77,0xce,0x82,0xe7,0x33,0xe9,0xf9,0xd5,0x47,0x4f,0xe2,0xc2,
0x95,0x1a,0x6c,0x32,0x21,0x4e,0x58,0xee,0xdf,0xc6,0x5f,0x2c,0x7e,0x8a,0x6e,0xb7,
0xcb,0xad,0xc7,0x17,0xf8,0x76,0x7a,0x13,0xb6,0x6c,0xf1,0xa1,0xe5,0xdf,0x67,0x6b,
0xe3,0x22,0x7,0xf,0x1f,0x27,0x98,0x3a,0x5a,0x45,0x79,0x93,0x21,0x36,0x43,0x4c,
0x8e,0xf2,0xa3,0x7a,0x41,0x14,0xa1,0xfc,0x98,0x62,0xd4,0xe7,0xc2,0xe9,0xe7,0xc8,
0x8b,0x9c,0x6f,0x16,0x3f,0xc1,0xe9,0xf6,0xbb,0x74,0x73,0x2a,0x8d,0xf3,0x82,0xff,
0x7e,0xf4,0x63,0xbf,0xf2,0x53,0x27,0xff,0xe0,0x9f,0x5e,0x55,0x2c,0xb8,0x62,0x4f,
0xf0,0xfe,0xfb,0xd5,0xc,0xa1,0xbf,0x7a,0xc7,0x9d,0xb7,0xd0,0xee,0x34,0xb8,0xb0,
0xf4,0x42,0x15,0xf4,0x4,0xac,0x85,0x30,0xaa,0xcb,0xf0,0x5a,0xf3,0x6a,0x47,0x69,
0x3e,0x29,0xce,0xb7,0xe1,0x4f,0x48,0x58,0x19,0xdc,0xc6,0x33,0x8b,0x9f,0x64,0x66,
0x76,0x96,0xdb,0x6f,0xbb,0x99,0xac,0x14,0x4e,0x9e,0xbe,0xc0,0x4c,0x4b,0x71,0xa4,
0xb1,0xcc,0x3,0xfc,0x16,0x73,0xde,0x22,0x53,0x7b,0x67,0x89,0x9b,0x1d,0xe2,0xa4,
0x45,0x10,0x37,0x1,0xf,0xc4,0x50,0x66,0x29,0x59,0x36,0x24,0x1b,0xf6,0xd8,0xe8,
0xad,0x71,0xa1,0x98,0xe7,0x7f,0xdb,0x4f,0xb3,0x6a,0xe6,0x40,0x34,0x8d,0xce,0x5e,
0x5e,0x7c,0x75,0x91,0xcd,0x8b,0x5b,0xa2,0x34,0x7f,0xf7,0xe4,0xef,0xff,0x93,0x2f,
0x5e,0x13,0x1,0x1f,0xfe,0x48,0x70,0x9f,0xf6,0xf9,0xda,0x3d,0xf7,0xde,0x81,0x50,
0xb0,0xba,0x7e,0xaa,0x6a,0x72,0x16,0x42,0x10,0x2a,0xb4,0xb7,0x4d,0xc0,0x18,0xf3,
0x15,0xb1,0xef,0x18,0x1b,0xa3,0x5,0xbe,0x7d,0xfe,0x27,0x39,0x78,0x60,0x3f,0xc7,
0x8f,0x1f,0x61,0x63,0x58,0xb2,0x78,0x31,0xc5,0x1a,0x43,0x2b,0x34,0x1c,0x9a,0x9,
0x28,0xd2,0x2d,0x6e,0x33,0x5f,0xe5,0xce,0xe8,0x19,0x66,0xbd,0x15,0x94,0x18,0x50,
0xa,0x2f,0x68,0x60,0xcb,0xb4,0xca,0x8,0xca,0x67,0xc5,0xec,0xe3,0x2f,0x46,0x77,
0xf2,0xa2,0xfa,0x10,0x61,0xa3,0xc3,0xda,0x46,0x49,0x2f,0x85,0xa3,0x87,0x66,0xf1,
0x35,0x3c,0xff,0xbd,0x33,0x6c,0x5c,0xec,0x3b,0x71,0xf2,0x37,0x5f,0xfb,0xc3,0x7f,
0xf6,0xe5,0x5d,0x13,0xf0,0xfe,0xf,0x85,0xf7,0x24,0xd,0x79,0xfa,0xae,0x77,0x1e,
0x23,0x69,0x24,0x5c,0x58,0x7a,0x1,0x71,0x50,0x5a,0x21,0x8e,0xab,0x7e,0xfe,0x95,
0xb5,0x5f,0xef,0xef,0xb8,0x96,0x0,0xd6,0x45,0x3c,0x79,0xf6,0xa7,0x89,0x9a,0x7,
0x79,0xf7,0xdd,0xb7,0xb3,0xdc,0xcb,0x58,0xdb,0xca,0x41,0x57,0xcf,0xa,0x5c,0x99,
0x71,0xc7,0x4d,0x2d,0x6c,0x91,0x32,0x1a,0x6e,0x91,0x6e,0xf5,0xf9,0xc9,0xfb,0xf,
0x62,0xb7,0x5e,0xc3,0x4f,0x4f,0xe1,0xe7,0xcb,0x14,0xe1,0x3e,0xca,0xe4,0x26,0x74,
0xeb,0x30,0x8f,0x7d,0xe5,0x55,0x9a,0xdd,0x3d,0xb4,0xbb,0x5d,0xa2,0xa4,0xc5,0xf3,
0xa7,0xd6,0xb1,0x2a,0x41,0x29,0xe1,0xf0,0x6c,0x8b,0x24,0xf4,0x78,0xee,0xc5,0xd3,
0xb2,0xb9,0x35,0x5c,0x1e,0x95,0xde,0xb1,0xa5,0x3f,0xfa,0xa5,0xe1,0x1b,0x11,0xf0,
0xba,0x2c,0xa0,0x94,0xf2,0x9f,0xfc,0x66,0x79,0x52,0x14,0xe9,0xe6,0xe6,0x80,0x28,
0x6a,0x20,0x2,0x59,0x2e,0x68,0xa5,0x10,0xb7,0x1d,0xf1,0xc5,0x5d,0xba,0xbd,0x7c,
0x7f,0x2c,0x2f,0xad,0xfe,0x18,0xa5,0x74,0xb8,0xf5,0x87,0x8e,0x32,0xc8,0xc,0xab,
0x5b,0xd9,0xb6,0xd5,0xa0,0xf0,0xc2,0x26,0x9b,0x99,0x47,0xdc,0x68,0xb3,0x99,0x5,
0x9c,0xdb,0xf4,0x58,0xcb,0x63,0xa6,0x16,0x4e,0x10,0xdd,0xfc,0x31,0xd4,0xf,0xfd,
0x7d,0xa2,0x9b,0x1e,0x66,0x6a,0xfe,0x9d,0xac,0x65,0x21,0x4b,0x3,0xcd,0xea,0x40,
0x88,0x9b,0x1d,0x32,0x9,0x71,0xaa,0x1,0x80,0x73,0xc2,0xe9,0xe5,0x4d,0xf2,0xd2,
0x70,0xec,0xa6,0xfd,0x4a,0xc1,0x4c,0xe2,0x99,0x5f,0x7e,0x33,0xb,0xb8,0x52,0x1a,
0xf4,0x0,0xed,0x2c,0xdf,0xed,0xf,0x86,0xa2,0x94,0x26,0x8,0x1a,0x20,0xa0,0xf5,
0x36,0x48,0x91,0xab,0x3,0x9f,0x16,0xd3,0x2c,0xf,0x4e,0x70,0xe4,0xc8,0x61,0xe2,
0x38,0xe0,0xc2,0xfa,0x58,0x19,0x97,0xfa,0xcb,0xf2,0x86,0x60,0xfd,0x16,0x5,0xd,
0xfc,0x46,0x97,0xff,0xb7,0xe8,0x98,0x99,0x99,0x61,0x76,0x76,0x96,0xd9,0xd9,0x59,
0xf6,0xed,0xdb,0xc7,0xcc,0xcc,0xc,0x27,0xd7,0x84,0x20,0xee,0x90,0xdb,0x80,0xb0,
0xb5,0x97,0x33,0x4b,0xd9,0x25,0xe6,0x27,0x2,0xe7,0xd7,0x6,0x34,0x92,0x90,0x85,
0x83,0x33,0xbe,0x28,0x7e,0xf1,0xe8,0x8f,0x7d,0xee,0xd6,0xdd,0x10,0xa0,0x0,0x65,
0xa,0x9e,0xde,0xdc,0x18,0xda,0xa2,0xcc,0xe9,0xb6,0xe,0xe2,0x79,0x6a,0x72,0x9f,
0x31,0x78,0xf7,0x97,0x80,0x77,0xe,0x4e,0x6f,0x7e,0x90,0x24,0xf1,0x59,0x38,0x38,
0xcd,0xea,0xc6,0x88,0xa2,0x30,0x8c,0x4b,0xa8,0x6d,0xe7,0x13,0x9c,0x38,0x4e,0x2d,
0xa6,0x94,0xba,0x45,0x10,0x77,0x79,0xf6,0xbc,0xa5,0xd5,0xee,0x32,0x35,0x35,0x75,
0x89,0xbc,0xb8,0xe2,0x8,0x9a,0x7b,0x9,0x1a,0x7b,0x79,0xe1,0xe4,0x3a,0x45,0x59,
0xbe,0xe,0x40,0x96,0x1b,0x56,0x37,0x52,0x16,0xe6,0xa7,0x49,0xa2,0x10,0xd1,0xf6,
0xd7,0x77,0x43,0x80,0x0,0x72,0xe1,0x82,0xf9,0x1d,0x67,0x9c,0x79,0xf5,0xd5,0x57,
0x9,0xc3,0x16,0xdd,0xee,0xde,0x2b,0x5e,0x60,0x52,0xc,0x5d,0x1,0x7c,0x69,0x3,
0x56,0x86,0x27,0x58,0x58,0x38,0x48,0x69,0x1c,0x6b,0x9b,0xe9,0xa5,0x27,0x89,0xd4,
0xd,0x8e,0x6a,0x3b,0xca,0x4a,0x9c,0x73,0x28,0x3f,0x20,0x57,0x9,0x67,0xb7,0xfc,
0x89,0x5,0xcc,0xcd,0xcd,0xe1,0x82,0xe,0xeb,0xa3,0x10,0x2f,0x88,0x41,0x29,0xd2,
0x51,0x5e,0x4f,0xb8,0xae,0x49,0x27,0xc5,0x6,0xac,0xf4,0x52,0x9c,0x75,0xdc,0x7c,
0x64,0x9f,0xf,0xdc,0x7f,0xf3,0xc7,0x7e,0xe5,0x8a,0xbd,0xc2,0x2b,0x11,0x60,0x1,
0x7b,0xfa,0x15,0xce,0xe,0x7,0x7c,0x76,0x75,0x69,0x53,0x7a,0xbd,0x15,0xe,0xec,
0x3f,0xca,0x9e,0xa9,0x5d,0x75,0x9c,0x19,0x99,0x19,0x44,0x34,0xdd,0x76,0x83,0xad,
0x61,0x8e,0x38,0xa9,0xc1,0xca,0x4,0xf4,0xf6,0xb6,0xee,0x6,0x89,0xad,0x8a,0xd,
0x67,0xf9,0xda,0xb3,0xcb,0x58,0x6b,0x11,0x11,0x8c,0x31,0x3c,0xf9,0xe2,0xca,0x8e,
0x73,0x2e,0x95,0x2a,0x98,0xcb,0x84,0xc,0x27,0x8e,0xe5,0xde,0x80,0xbd,0xdd,0x26,
0x41,0x10,0x14,0xa,0xf5,0xd1,0xab,0x22,0x40,0x44,0xc,0xd5,0xa,0xb6,0x78,0xea,
0x71,0xf3,0x45,0x6b,0x79,0xfa,0xe4,0xab,0xe7,0xcc,0xd2,0xe2,0x79,0xf6,0xee,0x99,
0x67,0x61,0xfe,0xe,0xa6,0xba,0xfb,0x9,0x83,0xa4,0x5a,0xac,0xbc,0x29,0x1,0xb3,
0x68,0xa5,0x88,0xa3,0x80,0x51,0x5e,0x5e,0x2,0x5a,0x9c,0xb9,0xc,0x7c,0xdd,0xea,
0x72,0xb6,0xda,0x77,0x8e,0x27,0x5e,0x58,0x65,0x94,0xe5,0x14,0x45,0x41,0x51,0x14,
0x3c,0xfd,0xf2,0x7a,0x75,0xcc,0xe,0x12,0x64,0x1c,0x90,0x2e,0x27,0x43,0x84,0xfe,
0xb0,0x40,0x29,0xa1,0xd3,0x4a,0x42,0x70,0xf7,0x5d,0x69,0x8e,0x6f,0x54,0x9,0x66,
0xf5,0x7f,0xfe,0xb,0xcf,0x9b,0x9f,0xbe,0xf5,0x56,0xff,0x73,0x2f,0xbf,0x74,0xf6,
0xfe,0x8b,0xeb,0x1b,0xcc,0x2f,0x1c,0x64,0xcf,0xd4,0x1,0xa6,0xf7,0x1e,0xaa,0x9,
0x73,0xb8,0xfa,0x31,0xd7,0xe5,0x63,0xe3,0xcc,0x3b,0x68,0x97,0x21,0x4a,0x43,0x9a,
0x97,0xd5,0xc4,0xd1,0x28,0xb1,0x38,0x5b,0xa2,0x43,0xcd,0x76,0xd,0xad,0x50,0x52,
0x3f,0x1,0xac,0x79,0xdd,0x1a,0x5a,0x9e,0x39,0x79,0x91,0x77,0x1c,0x6a,0x21,0xc0,
0xb3,0xa7,0x7a,0x97,0x0,0x1e,0xef,0x8f,0x7b,0x84,0x82,0xe0,0x4c,0x8e,0xaa,0x4b,
0x55,0x63,0x1c,0x79,0x6e,0x68,0xb7,0x23,0xd6,0x7b,0xea,0xc4,0xbd,0xf7,0x3e,0x16,
0x3c,0xfd,0xf4,0x4f,0x5d,0x12,0x34,0xae,0x48,0x80,0x88,0x38,0xa5,0x54,0xa,0xe8,
0xb5,0x45,0x16,0xd7,0x16,0xcd,0x3f,0x7e,0xd7,0x7b,0xfc,0xbf,0xed,0xe8,0x7f,0x66,
0x6d,0xed,0xa5,0x8e,0xe7,0x69,0xd3,0xed,0xb6,0xfc,0x20,0xf4,0x9,0x82,0x0,0xcf,
0xd3,0x97,0x3f,0x29,0x7,0x60,0x69,0xfd,0x4,0x8d,0x4e,0x3,0xe7,0x1c,0x45,0x51,
0x42,0xfd,0x4e,0x80,0x29,0x33,0x74,0x10,0x81,0xd8,0x6a,0xb9,0xac,0x14,0x4a,0xd4,
0x36,0xf8,0x1d,0xd7,0x7a,0xe9,0xdc,0x26,0xc7,0xe6,0x42,0x56,0x36,0xb,0x86,0x59,
0x51,0x1,0x46,0x5e,0x4f,0x2,0x35,0x31,0xa,0x6c,0x31,0x42,0xfb,0x21,0xe0,0x18,
0x64,0x5,0x9d,0x56,0xc,0x10,0xf4,0x66,0x2f,0xde,0xd,0x3c,0x75,0x35,0x16,0x80,
0x88,0x18,0xa5,0x54,0x1f,0x70,0x80,0xfd,0xee,0x53,0xe6,0x37,0xc3,0x90,0x2f,0x1d,
0xb9,0xd9,0xbb,0xa7,0xb3,0xc7,0x7e,0x38,0x1d,0x6e,0x1d,0xf7,0x3c,0xa6,0x94,0x96,
0x8e,0x52,0x44,0x48,0xe5,0x4e,0x32,0xd6,0x9f,0xa0,0x6,0xa1,0x6a,0xb7,0x5b,0xd6,
0xaf,0x6a,0x26,0xa9,0xdf,0x11,0xaa,0xba,0xbe,0x8a,0x18,0x71,0x6e,0x1b,0xfc,0xb8,
0x94,0xbc,0x8c,0xc8,0x57,0x2e,0xf4,0x29,0xee,0xea,0x72,0x72,0x71,0xeb,0x52,0xed,
0x4f,0x48,0x70,0xdb,0xfe,0x2f,0xe,0xa5,0x3c,0x6c,0xb1,0x51,0x4d,0x40,0xfb,0x58,
0x6b,0x88,0x82,0x0,0x0,0xa7,0x64,0xfe,0xaa,0x9,0xa8,0x49,0xb0,0xc0,0x96,0x52,
0xaa,0x4,0xca,0xa2,0xa0,0xf8,0xde,0x4b,0xf6,0x1b,0xc0,0xd3,0x40,0x4,0xc4,0x40,
0x58,0xef,0x7,0xb5,0xf8,0xd4,0xb5,0xc4,0xfe,0xf7,0xdb,0x4f,0xaa,0x24,0x7d,0x18,
0x11,0x3f,0x9,0x34,0xc3,0xdc,0x60,0xf2,0x21,0x9e,0x1f,0xd7,0x66,0x5b,0x9b,0xbd,
0xaa,0xdd,0x60,0x32,0xb6,0xbb,0x2d,0xa7,0x96,0x6,0xe4,0x79,0xce,0xa9,0xa5,0x7e,
0x15,0x1f,0xaa,0x89,0x5d,0xa2,0xf5,0x49,0x50,0x64,0x1c,0x5f,0x2c,0x26,0xeb,0xe3,
0xc7,0x6d,0x2,0x4f,0x53,0x16,0x55,0xff,0x40,0x7c,0x79,0xdd,0x5b,0x68,0x57,0xd5,
0x15,0x16,0x91,0x91,0x52,0x2a,0xab,0xc1,0x36,0x6b,0xe0,0x63,0xf0,0x63,0xd9,0x9,
0xde,0x3,0xb4,0x19,0xae,0x3f,0x9d,0xe5,0xe6,0x27,0xca,0xd2,0x10,0x85,0x1e,0xfd,
0x34,0x5,0x67,0x51,0x5a,0x57,0xd1,0xbe,0x36,0xff,0x9,0xf8,0x2b,0x2c,0x28,0x56,
0xb7,0x32,0x86,0x99,0xe1,0xec,0xda,0xa8,0xa,0x96,0xb2,0x33,0xe5,0x6d,0x5b,0xc2,
0x38,0xa0,0x82,0xa0,0xbd,0x90,0x62,0xb8,0xe,0x28,0x2,0x6f,0xf,0xc3,0xb4,0x72,
0x7b,0xe5,0x95,0x27,0xaf,0x89,0x80,0x9a,0x4,0x1,0x72,0x20,0x57,0x4a,0x79,0x54,
0x5a,0x6f,0x5c,0x6,0x7e,0xa2,0x7d,0x40,0xf,0xd6,0x5e,0xf8,0x5a,0xeb,0xd0,0x7b,
0xe8,0xf,0x52,0xa6,0x5a,0x11,0x2b,0x2b,0x19,0x68,0xaf,0x9a,0xb4,0x73,0x55,0x47,
0x58,0x6a,0xd0,0x8a,0xcb,0xac,0x60,0x7b,0x9c,0x5e,0xcb,0x38,0xb7,0x3a,0xaa,0xde,
0x19,0xa8,0xe6,0xf2,0x6,0x24,0x54,0x16,0xa1,0x83,0xa8,0x7a,0xde,0x60,0x53,0xa2,
0x40,0xb1,0x9c,0xe6,0x28,0x25,0x83,0x93,0xff,0xe3,0x91,0x8d,0x6b,0x26,0xe0,0x32,
0x32,0x2c,0x90,0x2,0xa9,0xaa,0x72,0xe1,0x58,0xeb,0xfe,0x8e,0xad,0x9f,0x2d,0xbe,
0xb0,0x29,0x77,0x15,0xff,0xf7,0xf4,0xd9,0xd5,0x3b,0xdf,0x79,0xc7,0x61,0x7f,0xaa,
0xe9,0xb3,0x99,0x6b,0xc4,0xb9,0xba,0xb7,0x38,0x5e,0x51,0x6d,0x83,0xbf,0xd2,0x62,
0xfa,0xa5,0x73,0x7d,0xd6,0xb6,0x46,0x3b,0x7a,0x10,0x63,0x8d,0xb3,0xbd,0x7f,0x89,
0x3b,0x80,0x52,0x1e,0x7b,0x9b,0x9a,0xcd,0xad,0xd,0x96,0x56,0x87,0xc6,0xe4,0xf9,
0xff,0x52,0x4a,0x75,0x81,0x41,0x3d,0xff,0x6b,0x27,0xe0,0x32,0x32,0x4,0x30,0xb5,
0x4c,0x7a,0x56,0x4a,0xa9,0x8,0x70,0x83,0xa5,0xef,0xfe,0x12,0xfe,0x7b,0xbf,0x72,
0xfe,0xfc,0x1a,0xfb,0xa6,0x9a,0x94,0x9b,0x86,0x51,0x6e,0x5e,0x7,0x7e,0x3b,0x6,
0x5e,0xb6,0x96,0x14,0x78,0xfc,0x85,0xf5,0xfa,0xc1,0xea,0xf6,0xa3,0xb0,0x6d,0x12,
0x76,0x10,0x52,0xff,0xaf,0x95,0x62,0xff,0x4c,0x97,0x24,0x52,0x2c,0xad,0x65,0x88,
0x73,0x66,0xe3,0x7b,0x5f,0xfe,0x35,0xa0,0x55,0xcf,0xad,0x2f,0x55,0x10,0xba,0x31,
0x1f,0x4c,0xd4,0x56,0x11,0x2,0xe1,0xfa,0x33,0xbf,0x77,0xb6,0xec,0x2f,0xfd,0xfa,
0xb9,0xe5,0xd,0x97,0x16,0x8e,0xa3,0x7,0xa7,0x98,0xee,0xc4,0x68,0x55,0xb7,0xbb,
0xeb,0xaa,0xaf,0xda,0x1f,0x3f,0x1b,0x1c,0x4b,0x55,0x1c,0xf5,0x6,0x59,0x5d,0x20,
0xd9,0xed,0x8a,0xb1,0xae,0xb7,0xc7,0x45,0x14,0xe2,0xd0,0xc0,0x54,0x2b,0xe6,0x96,
0x85,0x69,0xba,0x9d,0x36,0x6b,0xa3,0x84,0x5e,0xdf,0x48,0xbe,0x75,0xe1,0xbf,0xf5,
0x4f,0x3f,0x35,0xa0,0x72,0xdb,0xb1,0xcb,0x56,0x73,0xbd,0x11,0x6f,0xa6,0xd6,0x4,
0xb4,0x80,0x36,0xd0,0x22,0x68,0x74,0x17,0x7e,0xf8,0x67,0x3e,0x1b,0x34,0xba,0x1f,
0x39,0x7c,0x60,0x2f,0x7,0xe7,0xa6,0x50,0x9e,0x66,0x94,0x95,0x94,0xc6,0x62,0x9d,
0x54,0xb,0x2a,0xa4,0xae,0x14,0xae,0x34,0xc6,0x9d,0x25,0xa9,0xbb,0x53,0x93,0x9e,
0x74,0xf5,0xa2,0xa6,0xaf,0x69,0xc4,0x1,0xa0,0xe8,0xf,0x47,0xbc,0x76,0xb6,0x27,
0x83,0x34,0x53,0xf9,0xc6,0xd9,0x2f,0x2e,0x7e,0xeb,0x3f,0x7f,0x1,0xcc,0x16,0x30,
0x0,0xfa,0xc0,0x86,0x88,0x94,0x37,0x8c,0x80,0x9a,0x84,0xb8,0x26,0x61,0x22,0x73,
0xf7,0xfc,0x9d,0x8f,0x27,0xfb,0x6e,0xfb,0x8c,0xe7,0x7b,0xe1,0x54,0x27,0x61,0xaa,
0x93,0xe8,0xc0,0xf7,0xf1,0x7c,0xf,0xad,0x14,0x7a,0xdc,0x60,0x65,0xc7,0x5a,0xf1,
0x4d,0xa6,0x37,0x9e,0xbb,0x31,0x8e,0xa2,0xb4,0x8c,0xf2,0x92,0xb5,0xde,0xc0,0x15,
0xb9,0xd1,0xe2,0xec,0xa0,0x7f,0xee,0xdb,0xff,0xfe,0xe2,0x73,0xbf,0xf7,0x67,0x35,
0xf0,0xb1,0x6c,0x8a,0xc8,0x60,0x32,0xcf,0x1b,0xf9,0x6e,0xb2,0x52,0x2a,0x0,0x3a,
0x54,0x4,0x34,0x81,0x66,0x63,0xfa,0x96,0xf9,0xf6,0x4d,0x7f,0xe3,0x1,0xbf,0x73,
0xf0,0x83,0x41,0xd2,0xbd,0x13,0x54,0x78,0x7d,0xee,0x26,0x88,0xb3,0x43,0x93,0x5e,
0x7c,0x2e,0x5b,0x7b,0xe5,0xab,0x1b,0x2f,0x7d,0xf5,0x5b,0xd6,0xa6,0x9b,0xc0,0xb0,
0x96,0x2d,0xa0,0x27,0x22,0x3b,0x7b,0xeb,0x37,0x96,0x80,0xc9,0x4d,0x2a,0x6b,0xe8,
0x52,0xa5,0xcd,0x6,0x90,0x8c,0xc5,0x4b,0xba,0x5d,0xbf,0x31,0x3d,0x13,0xc6,0x9d,
0x3d,0x82,0x8a,0x45,0x5c,0x0,0xe2,0x23,0xe2,0x81,0x78,0x22,0xec,0x2c,0x14,0x44,
0x29,0x1c,0x28,0x8b,0xd2,0x46,0x29,0x65,0x50,0xba,0xb0,0x79,0xbf,0x57,0x5c,0x3c,
0xb7,0x6c,0xed,0x68,0x8,0x8c,0x76,0x48,0x4a,0x65,0xf2,0x3d,0x11,0xb9,0xe2,0xf3,
0x82,0xef,0xb,0x1,0x93,0x9b,0x55,0xf5,0xc3,0xd8,0x35,0xc6,0x5,0x55,0xc4,0xa5,
0xc1,0x69,0x67,0x4d,0xa1,0x6b,0x19,0xaf,0x10,0xea,0x7c,0x87,0xa3,0xca,0x3a,0xe5,
0xe,0xc9,0x6b,0xc9,0xa8,0x40,0xf,0x80,0x6c,0xec,0xeb,0x6f,0x38,0xa7,0xb7,0xf3,
0xe3,0xad,0x9a,0x90,0x71,0x29,0xbd,0xb3,0xa2,0x8c,0xd8,0x2e,0xa8,0x76,0x44,0x86,
0x9,0x1,0x96,0x7a,0xc9,0xce,0x36,0xf8,0xc,0x28,0x76,0xe6,0xf8,0xab,0x9a,0xc3,
0xf,0xc8,0xd7,0x6b,0x57,0x1c,0x75,0x36,0xb9,0xa4,0x30,0xb8,0xde,0x1f,0x54,0xfc,
0x40,0x13,0xf0,0xfd,0x18,0x7f,0xfd,0xe9,0xec,0xdb,0x3d,0x81,0xb7,0x7b,0xfc,0x95,
0x27,0xe0,0xff,0x3,0xba,0x7f,0x66,0x53,0x52,0x1d,0xd3,0x49,0x0,0x0,0x0,0x0,
0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82,
};
static const unsigned char qt_resource_name[] = {
// resources
0x0,0x9,
0xa,0x6c,0x78,0x43,
0x0,0x72,
0x0,0x65,0x0,0x73,0x0,0x6f,0x0,0x75,0x0,0x72,0x0,0x63,0x0,0x65,0x0,0x73,
// editor.png
0x0,0xa,
0xb,0x68,0x21,0x47,
0x0,0x65,
0x0,0x64,0x0,0x69,0x0,0x74,0x0,0x6f,0x0,0x72,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// chat.png
0x0,0x8,
0xe,0x87,0x5a,0x67,
0x0,0x63,
0x0,0x68,0x0,0x61,0x0,0x74,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// calendar.png
0x0,0xc,
0x7,0xb5,0xf,0xc7,
0x0,0x63,
0x0,0x61,0x0,0x6c,0x0,0x65,0x0,0x6e,0x0,0x64,0x0,0x61,0x0,0x72,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// browser.png
0x0,0xb,
0x9,0x16,0x7a,0x87,
0x0,0x62,
0x0,0x72,0x0,0x6f,0x0,0x77,0x0,0x73,0x0,0x65,0x0,0x72,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// mail.png
0x0,0x8,
0x7,0xff,0x59,0x27,
0x0,0x6d,
0x0,0x61,0x0,0x69,0x0,0x6c,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
// users.png
0x0,0x9,
0xc,0x96,0xae,0x67,
0x0,0x75,
0x0,0x73,0x0,0x65,0x0,0x72,0x0,0x73,0x0,0x2e,0x0,0x70,0x0,0x6e,0x0,0x67,
};
static const unsigned char qt_resource_struct[] = {
// :
0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x1,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
// :/resources
0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x6,0x0,0x0,0x0,0x2,
0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,
// :/resources/calendar.png
0x0,0x0,0x0,0x48,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x1d,0x8b,
0x0,0x0,0x1,0x2a,0xfa,0xe3,0xb0,0x40,
// :/resources/mail.png
0x0,0x0,0x0,0x82,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x46,0x25,
0x0,0x0,0x1,0x2a,0xfa,0xe3,0xb0,0x40,
// :/resources/browser.png
0x0,0x0,0x0,0x66,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x2d,0x39,
0x0,0x0,0x1,0x2a,0xfa,0xe3,0xb0,0x40,
// :/resources/editor.png
0x0,0x0,0x0,0x18,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,
0x0,0x0,0x1,0x2a,0xfa,0xe3,0xb0,0x40,
// :/resources/users.png
0x0,0x0,0x0,0x98,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x55,0x64,
0x0,0x0,0x1,0x2a,0xfa,0xe3,0xb0,0x40,
// :/resources/chat.png
0x0,0x0,0x0,0x32,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x12,0x8e,
0x0,0x0,0x1,0x2a,0xfa,0xe3,0xb0,0x40,
};
#ifdef QT_NAMESPACE
# define QT_RCC_PREPEND_NAMESPACE(name) ::QT_NAMESPACE::name
# define QT_RCC_MANGLE_NAMESPACE0(x) x
# define QT_RCC_MANGLE_NAMESPACE1(a, b) a##_##b
# define QT_RCC_MANGLE_NAMESPACE2(a, b) QT_RCC_MANGLE_NAMESPACE1(a,b)
# define QT_RCC_MANGLE_NAMESPACE(name) QT_RCC_MANGLE_NAMESPACE2( \
QT_RCC_MANGLE_NAMESPACE0(name), QT_RCC_MANGLE_NAMESPACE0(QT_NAMESPACE))
#else
# define QT_RCC_PREPEND_NAMESPACE(name) name
# define QT_RCC_MANGLE_NAMESPACE(name) name
#endif
#ifdef QT_NAMESPACE
namespace QT_NAMESPACE {
#endif
bool qRegisterResourceData(int, const unsigned char *, const unsigned char *, const unsigned char *);
bool qUnregisterResourceData(int, const unsigned char *, const unsigned char *, const unsigned char *);
#ifdef QT_NAMESPACE
}
#endif
int QT_RCC_MANGLE_NAMESPACE(qInitResources_resources)();
int QT_RCC_MANGLE_NAMESPACE(qInitResources_resources)()
{
int version = 3;
QT_RCC_PREPEND_NAMESPACE(qRegisterResourceData)
(version, qt_resource_struct, qt_resource_name, qt_resource_data);
return 1;
}
int QT_RCC_MANGLE_NAMESPACE(qCleanupResources_resources)();
int QT_RCC_MANGLE_NAMESPACE(qCleanupResources_resources)()
{
int version = 3;
QT_RCC_PREPEND_NAMESPACE(qUnregisterResourceData)
(version, qt_resource_struct, qt_resource_name, qt_resource_data);
return 1;
}
namespace {
struct initializer {
initializer() { QT_RCC_MANGLE_NAMESPACE(qInitResources_resources)(); }
~initializer() { QT_RCC_MANGLE_NAMESPACE(qCleanupResources_resources)(); }
} dummy;
}
| [
"ds.jeong@smsoft.co.kr"
] | ds.jeong@smsoft.co.kr |
a9c88b54495ab22f7d4a70215fb49b334c5ca420 | 147576df33595ae4fc7cd02567b273ba63ed3b30 | /lab11.3B/lab_11_3_B.cpp | 7d70e70cb1cdb2e4cc063091672bbe5cf24ce572 | [] | no_license | sasha-1337/lab11.3B | 14306a7f5e38375cf180802dff81aff53197c807 | c29e2d0755ba2af7e43099c52dd9f3b9d280b819 | refs/heads/master | 2023-02-02T02:45:50.134146 | 2020-12-14T11:01:39 | 2020-12-14T11:01:39 | 321,308,729 | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 7,893 | cpp | #include <iostream>
#include <iomanip>
#include <string>
#include <Windows.h>
#include <fstream>
using namespace std;
enum Specialty { PROGRAMMER, ENGINEER, PHYSICIAN };
string specStr[] = { "КН", "ІК", "ФЛ" };
struct Student
{
char prizv[64];
int kurs;
Specialty spec;
int physics;
int math;
int inform;
union {
int inform;
int NumericalMethods;
int pedagogy;
};
};
void Create(char* fname);
void Print(char* fname);
int fRead(fstream& f, const int i);
char SRead(fstream& f, const int i);
int TRead(fstream& f, const int i);
void fChange(fstream& f, const int i, const int j);
void sortBin(char* fname);
int main()
{
SetConsoleCP(1251);
SetConsoleOutputCP(1251);
char fname[61];
double MinAve = 0.0;
int countPhysics = 0;
int countMathematics = 0;
int countInformatics = 0;
int choice;
do {
cout << endl << endl;
cout << "Оберіть номер команди:" << endl;
cout << "[1] - Створити список студентів" << endl;
cout << "[2] - Вивести список на екран" << endl;
cout << "[3] - Фізично впорядкувати файл"
<< endl << endl;
cout << " [0] - Вийти із програми" << endl << endl;
cout << "Введіть номер команди: "; cin >> choice;
cout << endl << endl << endl;
switch (choice)
{
case 1:
cin.get(); cin.sync();
cout << "Введіть ім'я файлу: "; cin.getline(fname, sizeof(fname));
Create(fname);
break;
case 2:
cin.get(); cin.sync();
cout << "Введіть ім'я файлу: "; cin.getline(fname, sizeof(fname));
Print(fname);
break;
case 3:
cin.get(); cin.sync();
cout << "Введіть ім'я файлу: "; cin.getline(fname, sizeof(fname));
sortBin(fname);
break;
default:
cout << "Ви ввели неправильну команду" << endl;
break;
}
} while (choice != 0);
}
void Create(char* fname)
{
ofstream f(fname, ios::binary | ios::trunc);
if (!f)
{
cerr << "Неможливо відкрити файл '" << fname << "'" << endl;
exit(1);
}
Student s;
int spec;
char ch;
int i = 0;
do {
cout << endl;
cout << "Студент № " << i + 1 << ":" << endl;
++i;
cin.get(); cin.sync();
cout << "Прізвище: "; cin.getline( s.prizv, sizeof(s.prizv));
do {
cout << "Курс: "; cin >> s.kurs;
} while (!(s.kurs > 0));
do {
cout << "Спеціальність (0 - КН, 1 - ІК, 2 - ФЛ): "; cin >> spec;
s.spec = (Specialty)spec;
} while (!(spec >= 0 && spec <= 2));
cout << "Бал із фізики: "; cin >> s.physics;
cout << "Бал із математики: "; cin >> s.math;
switch (s.spec)
{
case PROGRAMMER:
cout << "Бал із інформатики: "; cin >> s.inform;
break;
case ENGINEER:
cout << "Бал із чисельних методів: "; cin >> s.NumericalMethods;
break;
case PHYSICIAN:
cout << "Бал із педагогіки: "; cin >> s.pedagogy;
break;
}
cout << endl;
if (!f.write((char*)&s, sizeof(Student)))
{
cout << " Error of writing " << endl;
}
cout << "Хочете додати ще одного студента? (Y/N): "; cin >> ch;
} while (ch == 'Y' || ch == 'y');
}
void Print(char* fname)
{
ifstream f(fname, ios::binary | ios::in);
if (!f)
{
cerr << "Неможливо відкрити файл" << endl;
exit(1);
}
Student s;
int i = 0;
cout << "============================================================================================================"
<< endl;
cout << "| № | Прізвище | Курс | Спеціальність | Фізика | Математика | Інформатика | Чисельні методи | Педагогіка |"
<< endl;
cout << "------------------------------------------------------------------------------------------------------------"
<< endl;
while (f.read((char*)&s, sizeof(Student)))
{
cout << "| " << setw(2) << right << i + 1
<< "| " << setw(9) << right << s.prizv
<< "| " << setw(5) << right << s.kurs
<< "| " << setw(14) << right << specStr[s.spec];
switch (s.spec)
{
case 0:
cout << "|" << setw(8) << setprecision(2) << fixed << s.physics << "|" << s.math << setw(12) << right
<< "|" << s.inform << setw(13) << "|" << setw(18) << "|" << setw(15)
<< setprecision(2) << " |" << endl;
break;
case 1:
cout << "|" << setw(8) << setprecision(2) << fixed << s.physics << "|" << s.math << setw(12) << right << "|"
<< setw(14) << "|" << s.NumericalMethods << setw(17) << "|" << setw(15) << "|" << endl;
break;
case 2:
cout << "|" << setw(8) << setprecision(2) << fixed << s.physics << "|" << s.math << setw(12) << right << "|"
<< setw(14) << "|" << setw(18) << "|" << s.pedagogy << setw(14) << "|" << endl;
break;
}
cout << "------------------------------------------------------------------------------------------------------------"
<< endl;
i++;
}
cout << endl;
}
void sortBin(char* fname)
{
fstream f(fname, ios::binary | ios::in | ios::out);
if (!f)
{
cerr << "Неможливо відкрити файл" << endl;
exit(1);
}
f.seekg(0 * (long)sizeof(Student), ios::end);
int size = f.tellg() / (sizeof(Student));
f.seekg(0, ios::beg);
for (int i0 = 1; i0 < size; i0++)
for (int i1 = 0; i1 < size - i0; i1++)
{
int specialty1 = fRead(f, i1);
int specialty2 = fRead(f, i1 + 1);
char prizv1 = SRead(f, i1);
char prizv2 = SRead(f, i1 + 1);
int kurs1 = TRead(f, i1);
int kurs2 = TRead(f, i1 + 1);
if ((specialty1 > specialty2)
||
(specialty1 == specialty2 && prizv1 < prizv2)
||
(specialty1 == specialty2 && prizv1 == prizv2 && kurs1 > kurs2))
fChange(f, i1, i1 + 1);
}
f.seekp(0, ios::end);
}
int fRead(fstream& f, const int i)
{
Student student;
f.seekg(i * 1.*(long)sizeof(Student));
f.read((char*)&student, sizeof(Student));
int specialty = student.spec;
return specialty;
}
char SRead(fstream& f, const int i)
{
Student student;
f.seekg(i * 1.*(long)sizeof(Student));
f.read((char*)&student, sizeof(Student));
char prizv[64];
strcpy_s(prizv, sizeof(prizv), student.prizv);
return *prizv;
}
int TRead(fstream& f, const int i)
{
Student student;
f.seekg(i * 1.*(long)sizeof(Student));
f.read((char*)&student, sizeof(Student));
int kurs = student.kurs;
return kurs;
}
void fChange(fstream& f, const int i, const int j)
{
Student si, sj, temp;
f.seekg(i * 1.*(long)sizeof(Student));
f.read((char*)&si, sizeof(Student));
temp = si;
f.seekg(j * 1.*(long)sizeof(Student));
f.read((char*)&sj, sizeof(Student));
f.seekp(i * 1.*(long)sizeof(Student));
f.write((char*)&sj, sizeof(Student));
f.seekp(j * 1.*(long)sizeof(Student));
f.write((char*)&temp, sizeof(Student));
} | [
"kolymbia97@gmail.com"
] | kolymbia97@gmail.com |
d0db409cb8018c3ca1439e6f74a6fcf08ba24b31 | bd75df2a6d81b1023b0fd23c3bec2dfa4a1fa8a3 | /exercise/Codeforce/1324B.cpp | f5eeac3446e7dc6728a77081af384626519c377e | [] | no_license | jongwuner/ps-study | 596215ed2f3405197eabb4251dbfb3bff1b09352 | a3f198dcf2467f1637aa8e1efdce81662d6b62ef | refs/heads/master | 2021-07-18T15:54:51.622618 | 2020-05-10T11:53:11 | 2020-05-10T11:53:11 | 156,563,729 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 647 | cpp | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> Pair;
const int MAX = 5001;
map<int, int> Map;
vector<int> vi;
int N;
int main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int T; cin >> T; while (T--) {
vi.clear();
Map.clear();
bool ans = false;
cin >> N;
vi.resize(N + 1);
for (int i = 1; i <= N; i++)
cin >> vi[i];
for (int i = 1; i <= N; i++) {
if (Map.find(vi[i]) == Map.end()) {
Map[vi[i]] = i;
}
else {
if (i - Map[vi[i]] >= 2) {
ans = true;
break;
}
}
}
if (ans) cout << "YES\n";
else cout << "NO\n";
}
return 0;
} | [
"jklh0202@naver.com"
] | jklh0202@naver.com |
475268c32502d81684178b5a25d6d667b1d00e66 | 76eec1682f1b4dfd51218205b6f0dc2827fdd17e | /src/cpu/x64/lrn/jit_uni_lrn_kernel.cpp | 3b14d4007d56965986ab3fddaf68a30cd4f7d672 | [
"BSD-3-Clause",
"Intel",
"MIT",
"BSL-1.0",
"Apache-2.0"
] | permissive | N-Dekker/oneDNN | 5b80966848c56113651f4c800ecd9f0cf5e7dba1 | 49dcdb1d76bc43c058380f5697b75e2f7f2552a6 | refs/heads/master | 2022-11-30T18:52:20.081536 | 2020-07-20T16:40:34 | 2020-07-21T00:48:16 | 280,428,330 | 0 | 0 | Apache-2.0 | 2020-07-20T17:38:28 | 2020-07-17T13:14:39 | null | UTF-8 | C++ | false | false | 49,662 | cpp | /*******************************************************************************
* Copyright 2016-2020 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
#include <array>
#include <cmath>
#include "common/c_types_map.hpp"
#include "common/nstl.hpp"
#include "common/utils.hpp"
#include "cpu/x64/jit_avx512_core_bf16cvt.hpp"
#include "cpu/x64/lrn/jit_uni_lrn_kernel.hpp"
namespace dnnl {
namespace impl {
namespace cpu {
namespace x64 {
using namespace dnnl::impl::format_tag;
#define IRB_LOOP(statement) \
if (1 == reg_block) { \
const int irb_off = 0; \
const int irb = this->reg_block_idx_ % vsum.size(); \
statement; \
MAYBE_UNUSED(irb_off); \
} else { \
for (int irb = 0; irb < reg_block; irb++) { \
const int irb_off = irb * single_pixel_offset_; \
statement; \
MAYBE_UNUSED(irb_off); \
} \
}
using namespace Xbyak;
template <cpu_isa_t isa, data_type_t d_type>
void jit_uni_lrn_fwd_kernel<isa, d_type>::load_data(
Vmm reg, const Xbyak::Address p) {
this->uni_vmovups(reg, p);
}
template <>
void jit_uni_lrn_fwd_kernel<avx512_common,
dnnl::impl::data_type::bf16>::load_data(Vmm reg,
const Xbyak::Address p) {
this->vpmovzxwd(reg, p);
this->vpslld(reg, reg, 0x10);
}
template <cpu_isa_t isa, data_type_t d_type>
void jit_uni_lrn_fwd_kernel<isa, d_type>::store_data(
const Xbyak::Address addr, Vmm reg) {
this->uni_vmovups(addr, reg);
}
template <>
void jit_uni_lrn_fwd_kernel<avx512_common,
dnnl::impl::data_type::bf16>::store_data(const Xbyak::Address addr,
Zmm zr) {
const Ymm yr = Ymm(zr.getIdx());
if (mayiuse(avx512_core_bf16))
vcvtneps2bf16(yr, zr);
else
bf16_emu_->vcvtneps2bf16(yr, zr);
vmovdqu16(addr, yr);
}
//////////////////////////////////////////////////////////////////////////////
// forward kernel
template <cpu_isa_t isa, data_type_t d_type>
void jit_uni_lrn_fwd_kernel<isa, d_type>::within_body(int hoff, int Hoff,
int woff, int Woff, int stride, prop_kind_t pk, const int reg_block,
int pixel_offset) {
static const bool emulateBfloat
= (isa == avx512_common && d_type == dnnl::impl::data_type::bf16
&& !mayiuse(avx512_core_bf16));
static const std::array<Vmm, 3> vsum {{Vmm(2), Vmm(11), Vmm(20)}};
static const std::array<Vmm, 3> vsum2 {{Vmm(3), Vmm(12), Vmm(21)}};
static const std::array<Vmm, 3> vdst {{Vmm(4), Vmm(13), Vmm(22)}};
static const std::array<std::array<Vmm, 6u>, 3u> vtmp {
{{{Vmm(5), Vmm(6), Vmm(7), Vmm(8), Vmm(9), Vmm(14)}},
{{Vmm(18), Vmm(15), Vmm(16), Vmm(17), Vmm(29), Vmm(30)}},
{{Vmm(23), Vmm(24), Vmm(25), Vmm(26), Vmm(28), Vmm(31)}}}};
static const std::array<Vmm, 3> vscratch = {{Vmm(10), Vmm(19), Vmm(27)}};
MAYBE_UNUSED(
emulateBfloat); // workaround for gcc8.1 compiler unused variable
static const std::size_t used_tmp_regs
= emulateBfloat ? vtmp[0].size() - 2 : vtmp[0].size();
IRB_LOOP(uni_vxorps(vsum[irb], vsum[irb], vsum[irb]));
for (int i = hoff; i <= Hoff; ++i) {
for (int j = woff; j <= Woff; ++j) {
if (i == 0 && j == 0) {
IRB_LOOP(load_data(
vdst[irb], ptr[src_ + pixel_offset + irb_off]));
IRB_LOOP(vfmadd231ps(vsum[irb], vdst[irb], vdst[irb]));
} else {
const auto idx = tempIdx_ % used_tmp_regs;
IRB_LOOP(load_data(vtmp[irb][idx],
ptr[(src_ + pixel_offset + irb_off)
+ (i * stride + j) * single_pixel_offset_]));
IRB_LOOP(
vfmadd231ps(vsum[irb], vtmp[irb][idx], vtmp[irb][idx]));
++tempIdx_;
}
}
}
tempIdx_ = tempIdx_ % used_tmp_regs;
IRB_LOOP(vfmadd132ps(vsum[irb], vk_, valpha_)); // ysum <- ysum*valpha_+yk_
IRB_LOOP(vmovaps(vscratch[irb], vsum[irb]));
if (pk != prop_kind::forward_inference) {
IRB_LOOP(store_data(ptr[scratch_], vscratch[irb]));
}
IRB_LOOP(vmulps(vsum2[irb], vsum[irb], vsum[irb]));
IRB_LOOP(vmulps(
vsum[irb], vsum[irb], vsum2[irb])); // ysum = (ysum*valpha_+yk_)^3;
IRB_LOOP(vsqrtps(vsum[irb], vsum[irb]));
IRB_LOOP(vsqrtps(vsum[irb], vsum[irb])); // ysum = (ysum*valpha_+yk_)^0.75
IRB_LOOP(vdivps(vdst[irb], vdst[irb], vsum[irb])); // ydst <- ydst / ysum
IRB_LOOP(store_data(ptr[dst_ + pixel_offset + irb_off], vdst[irb]));
if (isa == avx512_common)
this->reg_block_idx_ = (this->reg_block_idx_ % vsum.size()) + 1;
}
template <>
void jit_uni_lrn_fwd_kernel<sse41, dnnl::impl::data_type::f32>::within_body(
int hoff, int Hoff, int woff, int Woff, int stride, prop_kind_t pk,
int reg_block, int pixel_offset) {
const Xbyak::Xmm &xtmp_lo = this->xmm2;
const Xbyak::Xmm &xtmp_hi = this->xmm3;
const Xbyak::Xmm &xsum_lo = this->xmm4;
const Xbyak::Xmm &xsum_hi = this->xmm5;
const Xbyak::Xmm &xdst_lo = this->xmm6;
const Xbyak::Xmm &xdst_hi = this->xmm7;
const Xbyak::Xmm &xsum2_lo = this->xmm8;
const Xbyak::Xmm &xsum2_hi = this->xmm9;
xorps(xsum_lo, xsum_lo);
xorps(xsum_hi, xsum_hi);
for (int i = hoff; i <= Hoff; ++i) {
for (int j = woff; j <= Woff; ++j) {
if (i == 0 && j == 0) {
movups(xdst_lo, ptr[src_ + pixel_offset]);
movups(xdst_hi, ptr[src_ + pixel_offset + 4 * sizeof(float)]);
mulps(xdst_lo, xdst_lo);
mulps(xdst_hi, xdst_hi);
addps(xsum_lo, xdst_lo);
addps(xsum_hi, xdst_hi);
} else {
movups(xtmp_lo,
ptr[src_ + pixel_offset
+ (i * stride + j) * single_pixel_offset_]);
movups(xtmp_hi,
ptr[src_ + pixel_offset
+ (i * stride + j) * single_pixel_offset_
+ 4 * sizeof(float)]);
mulps(xtmp_lo, xtmp_lo);
mulps(xtmp_hi, xtmp_hi);
addps(xsum_lo, xtmp_lo);
addps(xsum_hi, xtmp_hi);
}
}
}
mulps(xsum_lo, xalpha_);
mulps(xsum_hi, xalpha_);
addps(xsum_lo, xk_);
addps(xsum_hi, xk_); // xsum <- xsum*xalpha_+xk_
movaps(xtmp_lo, xsum_lo);
movaps(xtmp_hi, xsum_hi);
if (pk != prop_kind::forward_inference) {
movups(ptr[scratch_ + pixel_offset], xtmp_lo);
movups(ptr[scratch_ + pixel_offset + 4 * sizeof(float)], xtmp_hi);
}
movaps(xsum2_lo, xsum_lo);
movaps(xsum2_hi, xsum_hi);
mulps(xsum2_lo, xsum_lo);
mulps(xsum2_hi, xsum_hi);
mulps(xsum_lo, xsum2_lo);
mulps(xsum_hi, xsum2_hi); // xsum = (xsum*xalpha_+xk_)^3;
sqrtps(xsum_lo, xsum_lo);
sqrtps(xsum_hi, xsum_hi);
sqrtps(xsum_lo, xsum_lo);
sqrtps(xsum_hi, xsum_hi); // xsum = (xsum*xalpha_+xk_)^0.75
movups(xdst_lo, ptr[src_ + pixel_offset]);
movups(xdst_hi, ptr[src_ + pixel_offset + 4 * sizeof(float)]);
divps(xdst_lo, xsum_lo);
divps(xdst_hi, xsum_hi); // xdst <- xdst / xsum
movups(ptr[dst_ + pixel_offset], xdst_lo);
movups(ptr[dst_ + pixel_offset + 4 * sizeof(float)], xdst_hi);
}
template <cpu_isa_t isa, data_type_t d_type>
void jit_uni_lrn_fwd_kernel<isa, d_type>::move_data_pointers(
int pixel_count, prop_kind_t pk) {
const int pixel_offset = single_pixel_offset_ * pixel_count;
add(src_, pixel_offset);
add(dst_, pixel_offset);
if (pk != prop_kind::forward_inference) add(scratch_, pixel_offset);
}
template <cpu_isa_t isa, data_type_t d_type>
void jit_uni_lrn_fwd_kernel<isa, d_type>::within_body_reg_blocked(
int loop_count, int max_reg_blocks, int hoff, int Hoff, int woff,
int Woff, int stride, prop_kind_t pk) {
Label label_t;
const auto res = std::div(loop_count, max_reg_blocks);
if (res.quot) {
mov(w_, res.quot);
L(label_t);
within_body(hoff, Hoff, woff, Woff, stride, pk, max_reg_blocks, 0);
move_data_pointers(max_reg_blocks, pk);
dec(w_);
cmp(w_, 0);
jne(label_t, T_NEAR);
}
if (res.rem) {
within_body(hoff, Hoff, woff, Woff, stride, pk, res.rem, 0);
move_data_pointers(res.rem, pk);
}
}
template <cpu_isa_t isa, data_type_t d_type>
void jit_uni_lrn_fwd_kernel<isa, d_type>::load_constant(
float constant, Vmm v_constant, Xbyak::Xmm x_constant) {
mov(imm_addr64_, float2int(constant));
uni_vmovq(x_constant, imm_addr64_);
vbroadcastss(v_constant, x_constant);
}
template <>
void jit_uni_lrn_fwd_kernel<sse41, dnnl::impl::data_type::f32>::load_constant(
float constant, Vmm v_constant, Xbyak::Xmm x_constant) {
mov(imm_addr64_, float2int(constant));
uni_vmovq(x_constant, imm_addr64_);
shufps(x_constant, x_constant, 0);
}
template <cpu_isa_t isa, data_type_t d_type>
jit_uni_lrn_fwd_kernel<isa, d_type>::jit_uni_lrn_fwd_kernel(
const within_config &J, float A, float K, prop_kind_t pk,
void *code_ptr, size_t code_size)
: jit_generator(code_ptr, code_size)
, alpha_(A)
, k_(K)
, single_pixel_offset_(J.dat_tag == nhwc
? J.C * sizeof(typename prec_traits<d_type>::type)
: VECTOR_LENGTH
* sizeof(typename prec_traits<d_type>::type)) {
if (isa == avx512_common && d_type == dnnl::impl::data_type::bf16
&& !mayiuse(avx512_core_bf16)) {
bf16_emu_ = utils::make_unique<bf16_emulation_t>(this,
bf16_emu_reserv_1_, bf16_emu_reserv_2_, bf16_emu_reserv_3_,
bf16_emu_scratch_, bf16_emu_reserv_4_);
bf16_emu_->init_vcvtneps2bf16();
}
static const int max_reg_blocks = isa == avx512_common ? 3 : 1;
this->preamble();
#define GET_OFF(field) offsetof(jit_args_fwd_t, field)
mov(src_, ptr[this->param1 + GET_OFF(src)]);
mov(dst_, ptr[this->param1 + GET_OFF(dst)]);
if (pk != prop_kind::forward_inference)
mov(scratch_, ptr[this->param1 + GET_OFF(scratch)]);
#undef GET_OFF
load_constant(alpha_, valpha_, xalpha_);
load_constant(k_, vk_, xk_);
const int s2 = (J.size - 1) / 2, S2 = J.size - s2 - 1;
int pixel_count = 0;
for (int i = 0; i < s2; ++i) {
pixel_count = 0;
for (int j = 0; j < s2; ++j)
within_body(-i, S2, -j, S2, J.W, pk, 1,
pixel_count++ * single_pixel_offset_);
move_data_pointers(pixel_count, pk);
within_body_reg_blocked(
J.W - J.size + 1, max_reg_blocks, -i, S2, -s2, S2, J.W, pk);
pixel_count = 0;
for (int j = J.W - S2; j < J.W; ++j)
within_body(-i, S2, -s2, J.W - 1 - j, J.W, pk, 1,
pixel_count++ * single_pixel_offset_);
move_data_pointers(pixel_count, pk);
}
mov(h_, J.H - J.size + 1);
Label lrn_loop_h;
L(lrn_loop_h);
pixel_count = 0;
for (int j = 0; j < s2; ++j)
within_body(-s2, S2, -j, S2, J.W, pk, 1,
pixel_count++ * single_pixel_offset_);
move_data_pointers(pixel_count, pk);
within_body_reg_blocked(
J.W - J.size + 1, max_reg_blocks, -s2, S2, -s2, S2, J.W, pk);
pixel_count = 0;
for (int j = J.W - S2; j < J.W; ++j)
within_body(-s2, S2, -s2, J.W - 1 - j, J.W, pk, 1,
pixel_count++ * single_pixel_offset_);
move_data_pointers(pixel_count, pk);
dec(h_);
cmp(h_, 0);
jne(lrn_loop_h, T_NEAR);
for (int i = J.H - S2; i < J.H; ++i) {
pixel_count = 0;
for (int j = 0; j < s2; ++j)
within_body(-s2, J.H - 1 - i, -j, S2, J.W, pk, 1,
pixel_count++ * single_pixel_offset_);
move_data_pointers(pixel_count, pk);
within_body_reg_blocked(J.W - J.size + 1, max_reg_blocks, -s2,
J.H - 1 - i, -s2, S2, J.W, pk);
pixel_count = 0;
for (int j = J.W - S2; j < J.W; ++j)
within_body(-s2, J.H - 1 - i, -s2, J.W - 1 - j, J.W, pk, 1,
pixel_count++ * single_pixel_offset_);
move_data_pointers(pixel_count, pk);
}
this->postamble();
ker = reinterpret_cast<decltype(ker)>(
const_cast<uint8_t *>(this->getCode()));
}
template <cpu_isa_t isa, data_type_t d_type>
jit_uni_lrn_fwd_kernel<isa, d_type>::jit_uni_lrn_fwd_kernel(
const struct nchw8c_across &J, float A, float K, prop_kind_t pk,
void *code_ptr, size_t code_size)
: jit_generator(code_ptr, code_size), bf16_emu_(nullptr), alpha_(A), k_(K) {
Xbyak::Reg64 t = rsp;
Xbyak::Reg64 hw = r9;
Xbyak::Xmm xsrc_prev = xmm2;
Xbyak::Ymm ysrc = ymm3;
Xbyak::Ymm yc = ymm3;
Xbyak::Xmm xsrc_next = xmm4;
Xbyak::Ymm ya = ymm5;
Xbyak::Ymm yb = ymm6;
Xbyak::Ymm yd = ymm7;
Xbyak::Ymm ye = ymm8;
Xbyak::Ymm ysum = ymm9;
Xbyak::Ymm ysum2 = ymm10;
Xbyak::Ymm ydst = ymm11;
Xbyak::Ymm ybase = ymm12;
this->preamble();
mov(src_, ptr[this->param1 + 0]);
mov(dst_, ptr[this->param1 + 8]);
if (pk != prop_kind::forward_inference)
mov(scratch_, ptr[this->param1 + 16]);
sub(t, 64);
mov(imm_addr64_, float2int(this->alpha_));
movq(xalpha_, imm_addr64_);
vbroadcastss(valpha_, xalpha_);
mov(imm_addr64_, float2int(this->k_));
movq(xk_, imm_addr64_);
vbroadcastss(yk_, xk_);
if (J.version == -1) {
vxorps(xsrc_prev, xsrc_prev, xsrc_prev);
vmovups(ptr[t + 0], xsrc_prev);
}
if (J.version == +1) {
vxorps(xsrc_next, xsrc_next, xsrc_next);
vmovups(ptr[t + 48], xsrc_next);
}
mov(hw, J.H * J.W);
Label lrn_loop;
L(lrn_loop);
if (J.version != -1) vmovups(xsrc_prev, ptr[src_ - J.H * J.W * 32 + 16]);
vmovups(ysrc, ptr[src_]);
if (J.version != +1) vmovups(xsrc_next, ptr[src_ + J.H * J.W * 32]);
if (J.version != -1) vmovups(ptr[t + 0], xsrc_prev);
vmovups(ptr[t + 16], ysrc);
if (J.version != +1) vmovups(ptr[t + 48], xsrc_next);
vmovups(ya, ptr[t + 16 - 8]);
vmovups(yb, ptr[t + 16 - 4]);
vmovups(yd, ptr[t + 16 + 4]);
vmovups(ye, ptr[t + 16 + 8]);
vmulps(ysum, yc, yc);
vfmadd231ps(ysum, ya, ya); // ysum <- ysum + ya*ya
vfmadd231ps(ysum, yb, yb);
vfmadd231ps(ysum, yd, yd);
vfmadd231ps(ysum, ye, ye);
vfmadd132ps(ysum, yk_, valpha_); // ysum <- ysum*valpha_+yk_
vmovaps(ybase, ysum);
if (pk != prop_kind::forward_inference) vmovups(ptr[scratch_], ybase);
vmulps(ysum2, ysum, ysum);
vmulps(ysum, ysum, ysum2); // ysum = ybase^3;
vsqrtps(ysum, ysum);
vsqrtps(ysum, ysum); // ysum = ybase^0.75
vdivps(ydst, ysrc, ysum); // ydst = ysrc / ysum
vmovups(ptr[dst_], ydst);
add(src_, 32);
add(dst_, 32);
if (pk != prop_kind::forward_inference) add(scratch_, 32);
dec(hw);
cmp(hw, 0);
jne(lrn_loop, T_NEAR);
add(t, 64);
this->postamble();
ker = reinterpret_cast<decltype(ker)>(
const_cast<uint8_t *>(this->getCode()));
}
template <>
jit_uni_lrn_fwd_kernel<sse41, dnnl::impl::data_type::f32>::
jit_uni_lrn_fwd_kernel(const struct nchw8c_across &J, float A, float K,
prop_kind_t pk, void *code_ptr, size_t code_size)
: jit_generator(code_ptr, code_size), bf16_emu_(nullptr), alpha_(A), k_(K) {
Xbyak::Reg64 t = rsp;
Xbyak::Reg64 hw = r9;
Xbyak::Xmm xsrc_lo = xmm2;
Xbyak::Xmm xsrc_hi = xmm3;
Xbyak::Xmm xc_lo = xmm4;
Xbyak::Xmm xc_hi = xmm5;
Xbyak::Xmm xsum_lo = xc_lo;
Xbyak::Xmm xsum_hi = xc_hi;
Xbyak::Xmm xsrc_prev = xmm6;
Xbyak::Xmm xsrc_next = xmm7;
Xbyak::Xmm xa_lo = xmm8;
Xbyak::Xmm xa_hi = xmm9;
Xbyak::Xmm xb_lo = xmm10;
Xbyak::Xmm xb_hi = xmm11;
Xbyak::Xmm xd_lo = xmm12;
Xbyak::Xmm xd_hi = xmm13;
Xbyak::Xmm xe_lo = xmm14;
Xbyak::Xmm xe_hi = xmm15;
Xbyak::Xmm xbase_lo = xmm14;
Xbyak::Xmm xbase_hi = xmm15;
this->preamble();
mov(src_, ptr[this->param1 + 0]);
mov(dst_, ptr[this->param1 + 8]);
if (pk != prop_kind::forward_inference)
mov(scratch_, ptr[this->param1 + 16]);
sub(t, 64);
mov(imm_addr64_, float2int(this->alpha_));
movq(xalpha_, imm_addr64_);
shufps(xalpha_, xalpha_, 0);
mov(imm_addr64_, float2int(this->k_));
movq(xk_, imm_addr64_);
shufps(xk_, xk_, 0);
if (J.version == -1) {
xorps(xsrc_prev, xsrc_prev);
movups(ptr[t + 0], xsrc_prev);
}
if (J.version == +1) {
xorps(xsrc_next, xsrc_next);
movups(ptr[t + 48], xsrc_next);
}
mov(hw, J.H * J.W);
Label lrn_loop;
L(lrn_loop);
if (J.version != -1) movups(xsrc_prev, ptr[src_ - J.H * J.W * 32 + 16]);
movups(xsrc_lo, ptr[src_]);
movups(xsrc_hi, ptr[src_ + 4 * sizeof(float)]);
if (J.version != +1) movups(xsrc_next, ptr[src_ + J.H * J.W * 32]);
if (J.version != -1) movups(ptr[t + 0], xsrc_prev);
movups(ptr[t + 16], xsrc_lo);
movups(ptr[t + 16 + 4 * sizeof(float)], xsrc_hi);
if (J.version != +1) movups(ptr[t + 48], xsrc_next);
movups(xa_lo, ptr[t + 16 - 8]);
movups(xa_hi, ptr[t + 16 - 8 + 4 * sizeof(float)]);
movups(xb_lo, ptr[t + 16 - 4]);
movups(xb_hi, ptr[t + 16 - 4 + 4 * sizeof(float)]);
movups(xd_lo, ptr[t + 16 + 4]);
movups(xd_hi, ptr[t + 16 + 4 + 4 * sizeof(float)]);
movups(xe_lo, ptr[t + 16 + 8]);
movups(xe_hi, ptr[t + 16 + 8 + 4 * sizeof(float)]);
movaps(xc_lo, xsrc_lo);
movaps(xc_hi, xsrc_hi);
mulps(xsum_lo, xc_lo);
mulps(xsum_hi, xc_hi);
mulps(xa_lo, xa_lo);
mulps(xa_hi, xa_hi);
addps(xsum_lo, xa_lo);
addps(xsum_hi, xa_hi); // xsum <- xsum + xa*xa
mulps(xb_lo, xb_lo);
mulps(xb_hi, xb_hi);
addps(xsum_lo, xb_lo);
addps(xsum_hi, xb_hi);
mulps(xd_lo, xd_lo);
mulps(xd_hi, xd_hi);
addps(xsum_lo, xd_lo);
addps(xsum_hi, xd_hi);
mulps(xe_lo, xe_lo);
mulps(xe_hi, xe_hi);
addps(xsum_lo, xe_lo);
addps(xsum_hi, xe_hi);
mulps(xsum_lo, xalpha_);
mulps(xsum_hi, xalpha_);
addps(xsum_lo, xk_);
addps(xsum_hi, xk_); // xsum <- xsum*xalpha_+xk_
movaps(xbase_lo, xsum_lo);
movaps(xbase_hi, xsum_hi);
if (pk != prop_kind::forward_inference) {
movups(ptr[scratch_], xbase_lo);
movups(ptr[scratch_ + 4 * sizeof(float)], xbase_hi);
}
mulps(xsum_lo, xsum_lo);
mulps(xsum_hi, xsum_hi);
mulps(xsum_lo, xbase_lo);
mulps(xsum_hi, xbase_hi); // xsum = xbase^3;
sqrtps(xsum_lo, xsum_lo);
sqrtps(xsum_hi, xsum_hi);
sqrtps(xsum_lo, xsum_lo);
sqrtps(xsum_hi, xsum_hi); // xsum = xbase^0.75
divps(xsrc_lo, xsum_lo);
divps(xsrc_hi, xsum_hi); // xdst = xsrc / xsum
movups(ptr[dst_], xsrc_lo);
movups(ptr[dst_ + 4 * sizeof(float)], xsrc_hi);
add(src_, 32);
add(dst_, 32);
if (pk != prop_kind::forward_inference) add(scratch_, 32);
dec(hw);
cmp(hw, 0);
jne(lrn_loop, T_NEAR);
add(t, 64);
this->postamble();
ker = reinterpret_cast<decltype(ker)>(
const_cast<uint8_t *>(this->getCode()));
}
template <cpu_isa_t isa, data_type_t d_type>
jit_uni_lrn_fwd_kernel<isa, d_type>::jit_uni_lrn_fwd_kernel(
const struct nhwc_across &J, float A, float K, prop_kind_t pk,
void *code_ptr, size_t code_size)
: jit_generator(code_ptr, code_size), bf16_emu_(nullptr), alpha_(A), k_(K) {
static const uint32_t mask[] = {0, 0, 0x80000000, 0x80000000, 0x80000000,
0x80000000, 0x80000000, 0x80000000, 0x80000000, 0, 0};
Xbyak::Reg64 c = r9;
Xbyak::Ymm ya = ymm2;
Xbyak::Ymm yb = ymm3;
Xbyak::Ymm yc = ymm4;
Xbyak::Ymm yd = ymm5;
Xbyak::Ymm ye = ymm6;
Xbyak::Ymm ysum = ymm7;
Xbyak::Ymm ydst = ymm8;
Xbyak::Ymm ybase = ymm9;
Xbyak::Ymm ymask = ymm10;
this->preamble();
mov(src_, ptr[this->param1 + 0]);
mov(dst_, ptr[this->param1 + 8]);
if (pk != prop_kind::forward_inference)
mov(scratch_, ptr[this->param1 + 16]);
mov(imm_addr64_, float2int(this->alpha_));
movq(xalpha_, imm_addr64_);
vbroadcastss(valpha_, xalpha_);
mov(imm_addr64_, float2int(this->k_));
movq(xk_, imm_addr64_);
vbroadcastss(yk_, xk_);
vxorps(ysum, ysum, ysum);
mov(imm_addr64_, reinterpret_cast<size_t>(&mask[0]));
vmovups(ymask, ptr[imm_addr64_]);
vmaskmovps(ya, ymask, ptr[src_ - 8]);
vfmadd231ps(ysum, ya, ya); // ysum <- ysum + ya^2+yb^2+yc^2+yd^2+ye^2
mov(imm_addr64_, reinterpret_cast<size_t>(&mask[1]));
vmovups(ymask, ptr[imm_addr64_]);
vmaskmovps(yb, ymask, ptr[src_ - 4]);
vfmadd231ps(ysum, yb, yb);
mov(c, J.C / 8 - 1);
Label lrn_loop;
L(lrn_loop);
vmovups(yc, ptr[src_]);
vmovups(yd, ptr[src_ + 4]);
vmovups(ye, ptr[src_ + 8]);
vfmadd231ps(ysum, yc, yc);
vfmadd231ps(ysum, yd, yd);
vfmadd231ps(ysum, ye, ye);
vmovups(ydst, ysum);
vfmadd132ps(ydst, yk_, valpha_); // ydst <- ysum*valpha_+yk_
vmovaps(ybase, ydst);
if (pk != prop_kind::forward_inference) vmovups(ptr[scratch_], ybase);
vmulps(ydst, ydst, ydst);
vmulps(ydst, ydst, ybase); // ydst = (ysum*valpha_+yk_)^3;
vsqrtps(ydst, ydst);
vsqrtps(ydst, ydst); // ydst = (ysum*valpha_+yk_)^0.75
vdivps(ydst, yc, ydst); // ydst = ysrc / (ysum*valpha_+yk_)^0.75
vmovups(ptr[dst_], ydst);
vxorps(ysum, ysum, ysum);
add(src_, 32);
add(dst_, 32);
if (pk != prop_kind::forward_inference) add(scratch_, 32);
vmovups(ya, ptr[src_ - 8]);
vfmadd231ps(ysum, ya, ya);
vmovups(yb, ptr[src_ - 4]);
vfmadd231ps(ysum, yb, yb);
dec(c);
cmp(c, 0);
jne(lrn_loop, T_NEAR);
vmovups(yc, ptr[src_]);
vfmadd231ps(ysum, yc, yc);
mov(imm_addr64_, reinterpret_cast<size_t>(&mask[2]));
vmovups(ymask, ptr[imm_addr64_]);
vmaskmovps(yd, ymask, ptr[src_ + 4]);
vfmadd231ps(ysum, yd, yd); // ysum <- ysum + ya^2+yb^2+yc^2+yd^2+ye^2
mov(imm_addr64_, reinterpret_cast<size_t>(&mask[3]));
vmovups(ymask, ptr[imm_addr64_]);
vmaskmovps(ye, ymask, ptr[src_ + 8]);
vfmadd231ps(ysum, ye, ye);
vmovups(ydst, ysum);
vfmadd132ps(ydst, yk_, valpha_); // ydst <- ysum*valpha_+yk_
vmovaps(ybase, ydst);
if (pk != prop_kind::forward_inference) vmovups(ptr[scratch_], ybase);
vmulps(ydst, ydst, ydst);
vmulps(ydst, ydst, ybase); // ydst = (ysum*valpha_+yk_)^3;
vsqrtps(ydst, ydst);
vsqrtps(ydst, ydst); // ydst = (ysum*valpha_+yk_)^0.75
vdivps(ydst, yc, ydst); // ydst = ysrc / (ysum*valpha_+yk_)^0.75
vmovups(ptr[dst_], ydst);
this->postamble();
ker = reinterpret_cast<decltype(ker)>(
const_cast<uint8_t *>(this->getCode()));
}
template <>
jit_uni_lrn_fwd_kernel<sse41, dnnl::impl::data_type::f32>::
jit_uni_lrn_fwd_kernel(const struct nhwc_across &J, float A, float K,
prop_kind_t pk, void *code_ptr, size_t code_size)
: jit_generator(code_ptr, code_size), bf16_emu_(nullptr), alpha_(A), k_(K) {
static uint32_t store[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
Xbyak::Reg64 c = r9;
Xbyak::Xmm xdst_lo = xmm0;
Xbyak::Xmm xdst_hi = xmm1;
Xbyak::Xmm xa_lo = xmm2;
Xbyak::Xmm xa_hi = xmm3;
Xbyak::Xmm xb_lo = xmm2;
Xbyak::Xmm xb_hi = xmm3;
Xbyak::Xmm xc_lo = xmm4;
Xbyak::Xmm xc_hi = xmm5;
Xbyak::Xmm xd_lo = xmm6;
Xbyak::Xmm xd_hi = xmm7;
Xbyak::Xmm xe_lo = xmm8;
Xbyak::Xmm xe_hi = xmm9;
Xbyak::Xmm xsum_lo = xmm10;
Xbyak::Xmm xsum_hi = xmm11;
// unused: xmm12, xmm13;
Xbyak::Xmm xbase_lo = xmm14;
Xbyak::Xmm xbase_hi = xmm15;
this->preamble();
mov(src_, ptr[this->param1 + 0]);
mov(dst_, ptr[this->param1 + 8]);
if (pk != prop_kind::forward_inference)
mov(scratch_, ptr[this->param1 + 16]);
mov(imm_addr64_, float2int(this->alpha_));
movq(xalpha_, imm_addr64_);
shufps(xalpha_, xalpha_, 0);
mov(imm_addr64_, float2int(this->k_));
movq(xk_, imm_addr64_);
shufps(xk_, xk_, 0);
mov(store_addr_, reinterpret_cast<size_t>(&store[0]));
and_(store_addr_, -15);
movups(ptr[store_addr_], xalpha_);
movups(ptr[store_addr_ + 4 * sizeof(float)], xk_);
xorps(xsum_lo, xsum_lo);
xorps(xsum_hi, xsum_hi);
/* load the 2 first blocks of channels
* block: | -- low -- | -- hi -- |
* C: [c1,c2,c3,c4,c5,c6,c7,c8]
* xa_lo << 2 [0,0,c1,c2]
* xa_hi [c3,c4,c5,c6]
* xb_lo << 1 [0,c1,c2,c3]
* xb_hi [c4,c5,c6,c7]
* | -- data -- (...)
* ^ memory boundary
*/
movups(xa_lo, ptr[src_]);
movups(xa_hi, ptr[src_ + 2 * sizeof(float)]);
pslldq(xa_lo, 2 * sizeof(float));
mulps(xa_lo, xa_lo);
mulps(xa_hi, xa_hi);
addps(xsum_lo, xa_lo);
addps(xsum_hi, xa_hi); // xsum <- xsum + xa^2+xb^2+xc^2+xd^2+xe^2
movups(xb_lo, ptr[src_]);
movups(xb_hi, ptr[src_ + 3 * sizeof(float)]);
pslldq(xb_lo, 1 * sizeof(float));
mulps(xb_lo, xb_lo);
mulps(xb_hi, xb_hi);
addps(xsum_lo, xb_lo);
addps(xsum_hi, xb_hi);
mov(c, J.C / 8 - 1);
Label lrn_loop;
L(lrn_loop);
movups(xc_lo, ptr[src_]);
movups(xc_hi, ptr[src_ + 4 * sizeof(float)]);
movups(xd_lo, ptr[src_ + 4]);
movups(xd_hi, ptr[src_ + 4 + 4 * sizeof(float)]);
movups(xe_lo, ptr[src_ + 8]);
movups(xe_hi, ptr[src_ + 8 + 4 * sizeof(float)]);
mulps(xc_lo, xc_lo);
mulps(xc_hi, xc_hi);
addps(xsum_lo, xc_lo);
addps(xsum_hi, xc_hi);
mulps(xd_lo, xd_lo);
mulps(xd_hi, xd_hi);
addps(xsum_lo, xd_lo);
addps(xsum_hi, xd_hi);
mulps(xe_lo, xe_lo);
mulps(xe_hi, xe_hi);
addps(xsum_lo, xe_lo);
addps(xsum_hi, xe_hi);
movaps(xdst_lo, xsum_lo);
movaps(xdst_hi, xsum_hi);
// xdst <- xsum*xalpha_+xk_
mulps(xdst_lo, ptr[store_addr_]);
mulps(xdst_hi, ptr[store_addr_]);
addps(xdst_lo, ptr[store_addr_ + 4 * sizeof(float)]);
addps(xdst_hi, ptr[store_addr_ + 4 * sizeof(float)]);
movaps(xbase_lo, xdst_lo);
movaps(xbase_hi, xdst_hi);
if (pk != prop_kind::forward_inference) {
movups(ptr[scratch_], xbase_lo);
movups(ptr[scratch_ + 4 * sizeof(float)], xbase_hi);
}
mulps(xdst_lo, xdst_lo);
mulps(xdst_hi, xdst_hi);
mulps(xdst_lo, xbase_lo);
mulps(xdst_hi, xbase_hi); // xdst = (xsum*xalpha_+xk_)^3;
sqrtps(xdst_lo, xdst_lo);
sqrtps(xdst_hi, xdst_hi);
sqrtps(xdst_lo, xdst_lo);
sqrtps(xdst_hi, xdst_hi); // xdst = (xsum*xalpha_+xk_)^0.75
movups(xc_lo, ptr[src_]);
movups(xc_hi, ptr[src_ + 4 * sizeof(float)]);
divps(xc_lo, xdst_lo);
divps(xc_hi, xdst_hi); // xdst = xsrc / (xsum*xalpha_+xk_)^0.75
movups(ptr[dst_], xc_lo);
movups(ptr[dst_ + 4 * sizeof(float)], xc_hi);
xorps(xsum_lo, xsum_lo);
xorps(xsum_hi, xsum_hi);
add(src_, 32);
add(dst_, 32);
if (pk != prop_kind::forward_inference) add(scratch_, 32);
movups(xa_lo, ptr[src_ - 8]);
movups(xa_hi, ptr[src_ - 8 + 4 * sizeof(float)]);
mulps(xa_lo, xa_lo);
mulps(xa_hi, xa_hi);
addps(xsum_lo, xa_lo);
addps(xsum_hi, xa_hi);
movups(xb_lo, ptr[src_ - 4]);
movups(xb_hi, ptr[src_ - 4 + 4 * sizeof(float)]);
mulps(xb_lo, xb_lo);
mulps(xb_hi, xb_hi);
addps(xsum_lo, xb_lo);
addps(xsum_hi, xb_hi);
dec(c);
cmp(c, 0);
jne(lrn_loop, T_NEAR);
/* compute last 3 blocks of channels:
* block: | -- low -- | -- hi -- |
* C: [c1,c2,c3,c4,c5,c6,c7,c8]
* xc_lo|xc_hi [c1,c2,c3,c4|c5,c6,c7,c8]
* xd_lo [c2,c3,c4,c5]
* xd_hi >> 1 [c6,c7,c8, 0]
* xe_lo [c3,c4,c5,c6]
* xe_hi >> 2 [c7,c8, 0, 0]
* (...) -- data -- | -- illegal reading -- (...)
* ^ memory boundary
*/
movups(xc_lo, ptr[src_]);
movups(xc_hi, ptr[src_ + 4 * sizeof(float)]);
mulps(xc_lo, xc_lo);
mulps(xc_hi, xc_hi);
addps(xsum_lo, xc_lo);
addps(xsum_hi, xc_hi);
movups(xd_lo, ptr[src_ + 1 * sizeof(float)]);
movups(xd_hi, ptr[src_ + 4 * sizeof(float)]);
psrldq(xd_hi, 1 * sizeof(float));
mulps(xd_lo, xd_lo);
mulps(xd_hi, xd_hi);
addps(xsum_lo, xd_lo);
addps(xsum_hi, xd_hi); // xsum <- xsum + xa^2+xb^2+xc^2+xd^2+xe^2
movups(xe_lo, ptr[src_ + 2 * sizeof(float)]);
movups(xe_hi, ptr[src_ + 4 * sizeof(float)]);
psrldq(xe_hi, 2 * sizeof(float));
mulps(xe_lo, xe_lo);
mulps(xe_hi, xe_hi);
addps(xsum_lo, xe_lo);
addps(xsum_hi, xe_hi);
movups(xdst_lo, xsum_lo);
movups(xdst_hi, xsum_hi);
// xdst <- xsum*xalpha_+xk_
mulps(xdst_lo, ptr[store_addr_]);
mulps(xdst_hi, ptr[store_addr_]);
addps(xdst_lo, ptr[store_addr_ + 4 * sizeof(float)]);
addps(xdst_hi, ptr[store_addr_ + 4 * sizeof(float)]);
movaps(xbase_lo, xdst_lo);
movaps(xbase_hi, xdst_hi);
if (pk != prop_kind::forward_inference) {
movups(ptr[scratch_], xbase_lo);
movups(ptr[scratch_ + 4 * sizeof(float)], xbase_hi);
}
mulps(xdst_lo, xdst_lo);
mulps(xdst_hi, xdst_hi);
mulps(xdst_lo, xbase_lo);
mulps(xdst_hi, xbase_hi); // xdst = (xsum*xalpha_+xk_)^3;
sqrtps(xdst_lo, xdst_lo);
sqrtps(xdst_hi, xdst_hi);
sqrtps(xdst_lo, xdst_lo);
sqrtps(xdst_hi, xdst_hi); // xdst = (xsum*xalpha_+xk_)^0.75
movups(xc_lo, ptr[src_]);
movups(xc_hi, ptr[src_ + 4 * sizeof(float)]);
divps(xc_lo, xdst_lo);
divps(xc_hi, xdst_hi); // xdst = xsrc / (xsum*xalpha_+xk_)^0.75
movups(ptr[dst_], xc_lo);
movups(ptr[dst_ + 4 * sizeof(float)], xc_hi);
this->postamble();
ker = reinterpret_cast<decltype(ker)>(
const_cast<uint8_t *>(this->getCode()));
}
template <>
void jit_uni_lrn_fwd_kernel<sse41, dnnl::impl::data_type::f32>::nchw_body(
int tail, int HW, prop_kind_t pk, Xbyak::Ymm ymask, Xbyak::Ymm ya,
Xbyak::Ymm yb, Xbyak::Ymm yc, Xbyak::Ymm yd, Xbyak::Ymm ye,
Xbyak::Ymm ysum) {}
template <cpu_isa_t isa, data_type_t d_type>
void jit_uni_lrn_fwd_kernel<isa, d_type>::nchw_body(int tail, int HW,
prop_kind_t pk, Xbyak::Ymm ymask, Xbyak::Ymm ya, Xbyak::Ymm yb,
Xbyak::Ymm yc, Xbyak::Ymm yd, Xbyak::Ymm ye, Xbyak::Ymm ysum) {
Xbyak::Ymm ydst = ymm14;
Xbyak::Ymm ybase = ymm15;
vfmadd231ps(ysum, ye, ye);
vmovups(ydst, ysum);
vfmadd132ps(ydst, yk_, valpha_); // ydst <- ysum*valpha_+yk_
vmovaps(ybase, ydst);
if (pk != prop_kind::forward_inference) {
if (tail != 0)
vmaskmovps(ptr[scratch_], ymask, ybase);
else
vmovups(ptr[scratch_], ybase);
}
vmulps(ydst, ydst, ydst);
vmulps(ydst, ydst, ybase); // ydst = (ysum*valpha_+yk_)^3;
vsqrtps(ydst, ydst);
vsqrtps(ydst, ydst); // ydst = (ysum*valpha_+yk_)^0.75
vdivps(ydst, yc, ydst); // ydst = ysrc / (ysum*valpha_+yk_)^0.75
if (tail != 0)
vmaskmovps(ptr[dst_], ymask, ydst);
else
vmovups(ptr[dst_], ydst);
vfnmadd231ps(ysum, ya, ya);
vmovups(ya, yb);
vmovups(yb, yc);
vmovups(yc, yd);
vmovups(yd, ye);
}
template <cpu_isa_t isa, data_type_t d_type>
void jit_uni_lrn_fwd_kernel<isa, d_type>::nchw_tail_sse41(int tail,
Xbyak::Reg64 reg_dst, Xbyak::Xmm xtail_lo, Xbyak::Xmm xtail_hi) {}
template <>
void jit_uni_lrn_fwd_kernel<sse41, dnnl::impl::data_type::f32>::nchw_tail_sse41(
int tail, Xbyak::Reg64 reg_dst, Xbyak::Xmm xtail_lo,
Xbyak::Xmm xtail_hi) {
Xbyak::Xmm xmm_tmp = xmm10;
movaps(xmm_tmp, xtail_hi);
if (tail > 3) {
/* Store upper-half directly */
movups(ptr[reg_dst + (tail - 4) * sizeof(float)], xtail_hi);
movaps(xmm_tmp, xtail_lo);
tail -= 4;
}
if (tail > 0) {
/* Store on a single-element basis when 'tail' overlaps
* with 'src_' */
psrldq(xmm_tmp, (4 - tail) * sizeof(float));
movss(ptr[reg_dst], xmm_tmp);
for (int i = 1; i < tail; i++) {
psrldq(xmm_tmp, sizeof(float));
movss(ptr[reg_dst + i * sizeof(float)], xmm_tmp);
}
}
}
template <>
void jit_uni_lrn_fwd_kernel<sse41, dnnl::impl::data_type::f32>::nchw_body_sse41(
int tail, int HW, prop_kind_t pk, Xbyak::Xmm xe_lo, Xbyak::Xmm xe_hi,
Xbyak::Xmm xsum_lo, Xbyak::Xmm xsum_hi) {
Xbyak::Xmm xdst_lo = xmm0;
Xbyak::Xmm xdst_hi = xmm1;
Xbyak::Xmm xbase_lo = xmm6;
Xbyak::Xmm xbase_hi = xmm7;
Xbyak::Xmm xtmp_lo = xmm8;
Xbyak::Xmm xtmp_hi = xmm9;
Xbyak::Xmm xa_lo = xmm6;
Xbyak::Xmm xa_hi = xmm7;
Xbyak::Xmm xb_lo = xmm8;
Xbyak::Xmm xb_hi = xmm9;
Xbyak::Xmm xc_lo = xmm10;
Xbyak::Xmm xc_hi = xmm11;
Xbyak::Xmm xd_lo = xmm12;
Xbyak::Xmm xd_hi = xmm13;
// store xe
movaps(ptr[store_addr_ + 10 * 4 * sizeof(float)], xe_lo);
movaps(ptr[store_addr_ + 11 * 4 * sizeof(float)], xe_hi);
mulps(xe_lo, xe_lo);
mulps(xe_hi, xe_hi);
addps(xsum_lo, xe_lo);
addps(xsum_hi, xe_hi);
// xdst <- xsum*xalpha_+xk_
movaps(xdst_lo, xsum_lo);
movaps(xdst_hi, xsum_hi);
mulps(xdst_lo, ptr[store_addr_ + 0 * 4 * sizeof(float)]);
mulps(xdst_hi, ptr[store_addr_ + 0 * 4 * sizeof(float)]);
addps(xdst_lo, ptr[store_addr_ + 1 * 4 * sizeof(float)]);
addps(xdst_hi, ptr[store_addr_ + 1 * 4 * sizeof(float)]);
movaps(xbase_lo, xdst_lo);
movaps(xbase_hi, xdst_hi);
if (pk != prop_kind::forward_inference) {
if (tail != 0) {
nchw_tail_sse41(tail, scratch_, xbase_lo, xbase_hi);
} else {
movups(ptr[scratch_], xbase_lo);
movups(ptr[scratch_ + 4 * sizeof(float)], xbase_hi);
}
}
mulps(xdst_lo, xdst_lo);
mulps(xdst_hi, xdst_hi);
mulps(xdst_lo, xbase_lo);
mulps(xdst_hi, xbase_hi); // xdst = (xsum*xalpha_+xk_)^3;
sqrtps(xdst_lo, xdst_lo);
sqrtps(xdst_hi, xdst_hi);
sqrtps(xdst_lo, xdst_lo);
sqrtps(xdst_hi, xdst_hi); // xdst = (xsum*xalpha_+xk_)^0.75
movaps(xtmp_lo, ptr[store_addr_ + 6 * 4 * sizeof(float)]);
movaps(xtmp_hi, ptr[store_addr_ + 7 * 4 * sizeof(float)]);
divps(xtmp_lo, xdst_lo);
divps(xtmp_hi, xdst_hi); // xdst = xsrc / (xsum*xalpha_+xk_)^0.75
movaps(xdst_lo, xtmp_lo);
movaps(xdst_hi, xtmp_hi);
if (tail != 0) {
nchw_tail_sse41(tail, dst_, xdst_lo, xdst_hi);
} else {
movups(ptr[dst_], xdst_lo);
movups(ptr[dst_ + 4 * sizeof(float)], xdst_hi);
}
movaps(xa_lo, ptr[store_addr_ + 2 * 4 * sizeof(float)]);
movaps(xa_hi, ptr[store_addr_ + 3 * 4 * sizeof(float)]);
mulps(xa_lo, xa_lo);
mulps(xa_hi, xa_hi);
subps(xsum_lo, xa_lo);
subps(xsum_hi, xa_hi);
// xa <- xb
movaps(xb_lo, ptr[store_addr_ + 4 * 4 * sizeof(float)]);
movaps(xb_hi, ptr[store_addr_ + 5 * 4 * sizeof(float)]);
movaps(ptr[store_addr_ + 2 * 4 * sizeof(float)], xb_lo);
movaps(ptr[store_addr_ + 3 * 4 * sizeof(float)], xb_hi);
// xb <- xc
movaps(xc_lo, ptr[store_addr_ + 6 * 4 * sizeof(float)]);
movaps(xc_hi, ptr[store_addr_ + 7 * 4 * sizeof(float)]);
movaps(ptr[store_addr_ + 4 * 4 * sizeof(float)], xc_lo);
movaps(ptr[store_addr_ + 5 * 4 * sizeof(float)], xc_hi);
// xc <- xd
movaps(xd_lo, ptr[store_addr_ + 8 * 4 * sizeof(float)]);
movaps(xd_hi, ptr[store_addr_ + 9 * 4 * sizeof(float)]);
movaps(ptr[store_addr_ + 6 * 4 * sizeof(float)], xd_lo);
movaps(ptr[store_addr_ + 7 * 4 * sizeof(float)], xd_hi);
// xd <- xe
movaps(xe_lo, ptr[store_addr_ + 10 * 4 * sizeof(float)]);
movaps(xe_hi, ptr[store_addr_ + 11 * 4 * sizeof(float)]);
movaps(ptr[store_addr_ + 8 * 4 * sizeof(float)], xe_lo);
movaps(ptr[store_addr_ + 9 * 4 * sizeof(float)], xe_hi);
}
template <cpu_isa_t isa, data_type_t d_type>
void jit_uni_lrn_fwd_kernel<isa, d_type>::nchw_body_sse41(int tail, int HW,
prop_kind_t pk, Xbyak::Xmm xe_lo, Xbyak::Xmm xe_hi, Xbyak::Xmm xsum_lo,
Xbyak::Xmm xsum_hi) {}
template <cpu_isa_t isa, data_type_t d_type>
jit_uni_lrn_fwd_kernel<isa, d_type>::jit_uni_lrn_fwd_kernel(
const nchw_across &J, float A, float K, prop_kind_t pk, void *code_ptr,
size_t code_size)
: jit_generator(code_ptr, code_size), alpha_(A), k_(K) {
static const uint32_t mask[]
= {0x80000000, 0x80000000, 0x80000000, 0x80000000, 0x80000000,
0x80000000, 0x80000000, 0, 0, 0, 0, 0, 0, 0};
Xbyak::Reg64 c = r10;
Xbyak::Ymm ymask = ymm2;
Xbyak::Ymm ye = ymm3;
Xbyak::Ymm ya = ymm4;
Xbyak::Ymm yb = ymm5;
Xbyak::Ymm yc = ymm6;
Xbyak::Ymm yd = ymm7;
Xbyak::Ymm ysum = ymm8;
this->preamble();
if (J.tail != 0) {
mov(imm_addr64_, reinterpret_cast<size_t>(&mask[7 - J.tail]));
vmovups(ymask, ptr[imm_addr64_]);
}
mov(imm_addr64_, float2int(this->alpha_));
movq(xalpha_, imm_addr64_);
vbroadcastss(valpha_, xalpha_);
mov(imm_addr64_, float2int(this->k_));
movq(xk_, imm_addr64_);
vbroadcastss(yk_, xk_);
mov(src_, ptr[this->param1 + 0]);
mov(dst_, ptr[this->param1 + 8]);
if (pk != prop_kind::forward_inference)
mov(scratch_, ptr[this->param1 + 16]);
vxorps(ya, ya, ya);
vxorps(yb, yb, yb);
if (J.tail != 0)
vmaskmovps(yc, ymask, ptr[src_ + J.HW * 0]);
else
vmovups(yc, ptr[src_ + J.HW * 0]);
if (J.tail != 0)
vmaskmovps(yd, ymask, ptr[src_ + J.HW * 4]);
else
vmovups(yd, ptr[src_ + J.HW * 4]);
vxorps(ysum, ysum, ysum);
vfmadd231ps(ysum, yc, yc); // ysum <- ysum + ya^2+yb^2+yc^2+yd^2+ye^2
vfmadd231ps(ysum, yd, yd);
mov(c, J.C - 2);
Label lrn_loop;
L(lrn_loop);
if (J.tail != 0)
vmaskmovps(ye, ymask, ptr[src_ + J.HW * 8]);
else
vmovups(ye, ptr[src_ + J.HW * 8]);
nchw_body(J.tail, J.HW, pk, ymask, ya, yb, yc, yd, ye, ysum);
add(src_, J.HW * 4);
add(dst_, J.HW * 4);
if (pk != prop_kind::forward_inference) add(scratch_, J.HW * 4);
dec(c);
cmp(c, 0);
jne(lrn_loop, T_NEAR);
vxorps(ye, ye, ye);
nchw_body(J.tail, J.HW, pk, ymask, ya, yb, yc, yd, ye, ysum);
add(src_, J.HW * 4);
add(dst_, J.HW * 4);
if (pk != prop_kind::forward_inference) add(scratch_, J.HW * 4);
nchw_body(J.tail, J.HW, pk, ymask, ya, yb, yc, yd, ye, ysum);
this->postamble();
ker = reinterpret_cast<decltype(ker)>(
const_cast<uint8_t *>(this->getCode()));
}
template <cpu_isa_t isa, data_type_t d_type>
jit_uni_lrn_fwd_kernel<isa, d_type>::~jit_uni_lrn_fwd_kernel() = default;
template <>
jit_uni_lrn_fwd_kernel<sse41,
dnnl::impl::data_type::f32>::jit_uni_lrn_fwd_kernel(const nchw_across
&J,
float A, float K, prop_kind_t pk, void *code_ptr, size_t code_size)
: jit_generator(code_ptr, code_size), alpha_(A), k_(K) {
/* Load from within the memory boundary of 'src_' and apply a zero-mask to
* the 'x_hi' register:
* block: src_ |tail = 3
* src_: [x,x,x,x|a,b,c]
* x_hi: [x,a,b,c]
* mask: [0,1,1,1]
* (...) -- data -- | -- illegal reading -- (...)
* ^ memory boundary
*
* 'x_lo' is loaded with the elements between 'src_' and 'x_hi' when
* tail.size is between [5:7]. The register is then left-shifted to
* clear the overlapping elements with 'x_hi'.
* block: - src_ - | tail = 7
* src_: (...) [x,|a,b,c,d,e,f,g]
* x_hi [d,e,f,g]
* x_lo [a,b,c,d]
* x_lo >> 1: [0,a,b,c]
* (...) -- data -- | -- illegal reading -- (...)
* ^ memory boundary
*
* - seg-fault happens if read occurs anywhere outside the
* memory boundary.
* */
static const uint32_t mask[]
= {0, 0, 0, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff};
assert(J.HW > 3);
Xbyak::Reg64 c = r10;
// unused: xmm2
Xbyak::Xmm xmask_hi = xmm3;
Xbyak::Xmm xsum_lo = xmm4;
Xbyak::Xmm xsum_hi = xmm5;
Xbyak::Xmm xa_lo = xmm6;
Xbyak::Xmm xa_hi = xmm7;
Xbyak::Xmm xb_lo = xmm8;
Xbyak::Xmm xb_hi = xmm9;
Xbyak::Xmm xc_lo = xmm10;
Xbyak::Xmm xc_hi = xmm11;
Xbyak::Xmm xd_lo = xmm12;
Xbyak::Xmm xd_hi = xmm13;
Xbyak::Xmm xe_lo = xmm14;
Xbyak::Xmm xe_hi = xmm15;
const int vlen = cpu_isa_traits<sse41>::vlen / sizeof(float);
bool compute_tail = J.tail != 0;
bool load_lo = J.tail == 0 || J.tail > 4;
size_t h_offset = vlen;
size_t l_shift = 0;
this->preamble();
mov(src_, ptr[this->param1 + 0]);
mov(dst_, ptr[this->param1 + 8]);
if (pk != prop_kind::forward_inference)
mov(scratch_, ptr[this->param1 + 16]);
sub(rsp, stack_space_needed_);
mov(store_addr_, rsp);
and_(store_addr_, -15);
mov(imm_addr64_, float2int(this->alpha_));
movq(xalpha_, imm_addr64_);
shufps(xalpha_, xalpha_, 0);
mov(imm_addr64_, float2int(this->k_));
movq(xk_, imm_addr64_);
shufps(xk_, xk_, 0);
// put alpha_ and k_ into store (free up regs)
movaps(ptr[store_addr_ + 0 * 4 * sizeof(float)], xalpha_);
movaps(ptr[store_addr_ + 1 * 4 * sizeof(float)], xk_);
if (compute_tail) {
assert(J.tail > 0 && J.tail < 2 * vlen);
h_offset = J.tail - vlen;
l_shift = nstl::min(2 * vlen - J.tail, vlen);
/* if 'tail' is between [1:3], need to zero-mask for underflow */
size_t m_off = nstl::min(J.tail - 1, 3);
mov(imm_addr64_, reinterpret_cast<size_t>(&mask[m_off]));
movups(xmask_hi, ptr[imm_addr64_]);
}
// init xa, xb
xorps(xa_lo, xa_lo);
xorps(xa_hi, xa_hi);
xorps(xb_lo, xb_lo);
xorps(xb_hi, xb_hi);
// read xc, xd
if (load_lo) movups(xc_lo, ptr[src_ + J.HW * 0]);
movups(xc_hi, ptr[src_ + J.HW * 0 + h_offset * sizeof(float)]);
if (compute_tail) {
pslldq(xc_lo, l_shift * sizeof(float));
andps(xc_hi, xmask_hi);
}
if (load_lo) movups(xd_lo, ptr[src_ + J.HW * 4]);
movups(xd_hi, ptr[src_ + J.HW * 4 + h_offset * sizeof(float)]);
if (compute_tail) {
pslldq(xd_lo, l_shift * sizeof(float));
andps(xd_hi, xmask_hi);
}
// put xa, xb, xc, xd into store to free-up regs
movaps(ptr[store_addr_ + 2 * 4 * sizeof(float)], xa_lo);
movaps(ptr[store_addr_ + 3 * 4 * sizeof(float)], xa_hi);
movaps(ptr[store_addr_ + 4 * 4 * sizeof(float)], xb_lo);
movaps(ptr[store_addr_ + 5 * 4 * sizeof(float)], xb_hi);
movaps(ptr[store_addr_ + 6 * 4 * sizeof(float)], xc_lo);
movaps(ptr[store_addr_ + 7 * 4 * sizeof(float)], xc_hi);
movaps(ptr[store_addr_ + 8 * 4 * sizeof(float)], xd_lo);
movaps(ptr[store_addr_ + 9 * 4 * sizeof(float)], xd_hi);
xorps(xsum_lo, xsum_lo);
xorps(xsum_hi, xsum_hi);
mulps(xc_lo, xc_lo);
mulps(xc_hi, xc_hi);
addps(xsum_lo, xc_lo);
addps(xsum_hi, xc_hi);
mulps(xd_lo, xd_lo);
mulps(xd_hi, xd_hi);
addps(xsum_lo, xd_lo);
addps(xsum_hi, xd_hi); // xsum <- xsum + xa^2+xb^2+xc^2+xd^2+xe^2
mov(c, J.C - 2);
Label lrn_loop;
L(lrn_loop);
if (load_lo) movups(xe_lo, ptr[src_ + J.HW * 8]);
movups(xe_hi, ptr[src_ + J.HW * 8 + h_offset * sizeof(float)]);
if (compute_tail) {
pslldq(xe_lo, l_shift * sizeof(float));
andps(xe_hi, xmask_hi);
}
nchw_body_sse41(J.tail, J.HW, pk, xe_lo, xe_hi, xsum_lo, xsum_hi);
add(src_, J.HW * 4);
add(dst_, J.HW * 4);
if (pk != prop_kind::forward_inference) add(scratch_, J.HW * 4);
dec(c);
cmp(c, 0);
jne(lrn_loop, T_NEAR);
xorps(xe_lo, xe_lo);
xorps(xe_hi, xe_hi);
nchw_body_sse41(J.tail, J.HW, pk, xe_lo, xe_hi, xsum_lo, xsum_hi);
add(src_, J.HW * 4);
add(dst_, J.HW * 4);
if (pk != prop_kind::forward_inference) add(scratch_, J.HW * 4);
nchw_body_sse41(J.tail, J.HW, pk, xe_lo, xe_hi, xsum_lo, xsum_hi);
add(rsp, stack_space_needed_);
this->postamble();
ker = reinterpret_cast<decltype(ker)>(
const_cast<uint8_t *>(this->getCode()));
}
//////////////////////////////////////////////////////////////////////////////
// backward kernel
template <cpu_isa_t isa>
jit_uni_lrn_bwd_kernel_f32<isa>::jit_uni_lrn_bwd_kernel_f32(
const struct nchw8c_across &J, float A, float B, int use_h_parallel,
void *code_ptr, size_t code_size)
: jit_generator(code_ptr, code_size)
, nalphabeta(-2 * A * B)
, use_h_parallelizm(use_h_parallel) {
Xbyak::Reg64 t = rsp;
Xbyak::Reg64 hw = r10;
Xbyak::Xmm xsrc_prev = xmm1;
Xbyak::Xmm xws_prev = xmm2;
Xbyak::Xmm xdiffdst_prev = xmm3;
Xbyak::Ymm ysrc = ymm4;
Xbyak::Ymm yws = ymm5;
Xbyak::Ymm ydiffdst = ymm6;
Xbyak::Xmm xsrc_next = xmm7;
Xbyak::Xmm xws_next = xmm8;
Xbyak::Xmm xdiffdst_next = xmm9;
Xbyak::Ymm ya = ymm10;
Xbyak::Xmm xa = xmm10;
Xbyak::Ymm yb = ymm11;
Xbyak::Ymm yd = ymm12;
Xbyak::Ymm ye = ymm13;
Xbyak::Ymm ysum = ymm14;
Xbyak::Ymm ydiffsrc = ymm15;
this->preamble();
mov(src_, ptr[this->param1 + 0]);
mov(diffdst, ptr[this->param1 + 8]);
mov(workspace, ptr[this->param1 + 16]);
mov(diffsrc, ptr[this->param1 + 24]);
sub(t, 64);
mov(imm_addr64_, float2int(this->nalphabeta));
movq(xnalphabeta, imm_addr64_);
vbroadcastss(ynalphabeta, xnalphabeta);
bool is_single = J.version == 3;
bool is_first = J.version == -1 || J.version == -2;
bool is_last = J.version == +1 || J.version == -2;
if (is_first || is_single) {
vxorps(xsrc_prev, xsrc_prev, xsrc_prev);
vmovups(ptr[t + 0], xsrc_prev);
}
if (is_last || is_single) {
vxorps(xsrc_next, xsrc_next, xsrc_next);
vmovups(ptr[t + 48], xsrc_next);
}
mov(hw, this->use_h_parallelizm ? J.W : J.H * J.W);
Label lrn_loop;
L(lrn_loop);
{
if (!is_first && !is_single) {
vmovups(xws_prev, ptr[workspace - J.H * J.W * 32 + 16]);
vmovups(xsrc_prev, ptr[src_ - J.H * J.W * 32 + 16]);
vmovups(xdiffdst_prev, ptr[diffdst - J.H * J.W * 32 + 16]);
vmulps(xa, xws_prev, xws_prev);
vmulps(xa, xa, xws_prev);
vsqrtps(xa, xa);
vsqrtps(xa, xa);
vmulps(xa, xa, xws_prev);
vdivps(xsrc_prev, xsrc_prev, xa);
vmulps(xdiffdst_prev, xdiffdst_prev, xsrc_prev);
}
vmovups(ysrc, ptr[src_]);
vmovups(yws, ptr[workspace]);
vmovups(ydiffdst, ptr[diffdst]);
vmulps(ya, yws, yws);
vmulps(ya, ya, yws);
vsqrtps(ya, ya);
vsqrtps(ya, ya);
vdivps(ydiffsrc, ydiffdst, ya);
vdivps(ysum, ydiffsrc, yws);
vmulps(ysum, ysum, ysrc);
if (!is_last && !is_single) {
vmovups(xws_next, ptr[workspace + J.H * J.W * 32]);
vmovups(xsrc_next, ptr[src_ + J.H * J.W * 32]);
vmovups(xdiffdst_next, ptr[diffdst + J.H * J.W * 32]);
vmulps(xa, xws_next, xws_next);
vmulps(xa, xa, xws_next);
vsqrtps(xa, xa);
vsqrtps(xa, xa);
vmulps(xa, xa, xws_next);
vdivps(xsrc_next, xsrc_next, xa);
vmulps(xdiffdst_next, xdiffdst_next, xsrc_next);
}
if (!is_first && !is_single) vmovups(ptr[t + 0], xdiffdst_prev);
vmovups(ptr[t + 16], ysum);
if (!is_last && !is_single) vmovups(ptr[t + 48], xdiffdst_next);
vmovups(ya, ptr[t + 16 - 8]);
vmovups(yb, ptr[t + 16 - 4]);
vaddps(ysum, ysum, ya);
vmulps(ysrc, ysrc, ynalphabeta);
vaddps(ysum, ysum, yb);
vmovups(yd, ptr[t + 16 + 4]);
vmovups(ye, ptr[t + 16 + 8]);
vaddps(ysum, ysum, yd);
vaddps(ysum, ysum, ye);
vfmadd231ps(ydiffsrc, ysum, ysrc);
vmovups(ptr[diffsrc], ydiffsrc);
add(src_, 32);
add(diffsrc, 32);
add(diffdst, 32);
add(workspace, 32);
dec(hw);
cmp(hw, 0);
jne(lrn_loop, T_NEAR);
}
add(t, 64);
this->postamble();
ker = reinterpret_cast<decltype(ker)>(
const_cast<uint8_t *>(this->getCode()));
}
template struct jit_uni_lrn_fwd_kernel<sse41, dnnl::impl::data_type::f32>;
template struct jit_uni_lrn_fwd_kernel<avx2, dnnl::impl::data_type::f32>;
template struct jit_uni_lrn_fwd_kernel<avx512_common,
dnnl::impl::data_type::f32>;
template struct jit_uni_lrn_fwd_kernel<avx512_common,
dnnl::impl::data_type::bf16>;
template struct jit_uni_lrn_bwd_kernel_f32<avx2>;
} // namespace x64
} // namespace cpu
} // namespace impl
} // namespace dnnl
// vim: et ts=4 sw=4 cindent cino+=l0,\:4,N-s
| [
"piotr.chmiel@intel.com"
] | piotr.chmiel@intel.com |
5874f2594832077fa4ec94481d2ab4d302b09365 | 6c3d396136e3b218dd4aaeed1276342dd3d3585d | /src/planner/robot/robot_state.cc | 126427bb787f13baf1da376272053f8d1fc5161c | [] | no_license | pjsdream/planner | 4dc8120d516ae03349091792673afff427e64723 | 56100adbc9e5ea0af1bfbe252c1073acf7eb47b6 | refs/heads/master | 2021-09-14T18:55:01.906412 | 2018-01-29T12:40:53 | 2018-01-29T12:40:53 | 114,855,947 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,291 | cc | #include "planner/robot/robot_state.h"
#include <iostream>
namespace planner
{
RobotState::RobotState(const std::shared_ptr<LinearRobotModel>& robot_model)
: robot_model_(robot_model)
{
joint_values_.resize(robot_model_->GetJoints().size());
joint_values_.setZero();
link_poses_.resize(robot_model_->GetLinks().size());
forward_kinematics_derivatives_.resize(robot_model_->GetJoints().size());
}
void RobotState::SetJointValue(int index, double joint_value)
{
const auto& joint = robot_model_->GetJoint(index);
if (joint.HasLimits())
joint_values_(index) = std::min(joint.GetUpperLimit(), std::max(joint.GetLowerLimit(), joint_value));
else
joint_values_(index) = joint_value;
}
void RobotState::PerformForwardKinematics()
{
link_poses_[0] = Eigen::Affine3d::Identity();
const auto& links = robot_model_->GetLinks();
const auto& joints = robot_model_->GetJoints();
for (int i = 1; i < links.size(); i++)
{
const auto& link = links[i];
link_poses_[i] = link_poses_[i - 1] * joints[i - 1].Transform(GetJointValue(i - 1));
}
}
void RobotState::PerformDerivativeForwardKinematics()
{
PerformForwardKinematics();
const auto& links = robot_model_->GetLinks();
const auto& joints = robot_model_->GetJoints();
VectorMatrix4d forward_accumulations(joints.size());
VectorMatrix4d backward_accumulations(joints.size());
for (int i = 0; i < joints.size(); i++)
{
const auto& joint = joints[i];
if (i == 0)
forward_accumulations[i] = joint.Transform(GetJointValue(i)).matrix();
else
forward_accumulations[i] = forward_accumulations[i - 1] * joint.Transform(GetJointValue(i)).matrix();
}
for (int i = joints.size() - 1; i >= 0; i--)
{
const auto& joint = joints[i];
if (i == joints.size() - 1)
backward_accumulations[i] = joint.Transform(GetJointValue(i)).matrix();
else
backward_accumulations[i] = joint.Transform(GetJointValue(i)).matrix() * backward_accumulations[i + 1];
}
for (int i = 0; i < joints.size(); i++)
{
const auto& joint = joints[i];
if (i == 0)
forward_kinematics_derivatives_[i] = Eigen::Matrix4d::Identity();
else
forward_kinematics_derivatives_[i] = forward_accumulations[i - 1];
forward_kinematics_derivatives_[i] *= joint.TransformDerivative(GetJointValue(i));
if (i != joints.size() - 1)
forward_kinematics_derivatives_[i] *= backward_accumulations[i + 1];
}
}
Eigen::Affine3d RobotState::GetLinkPose(int link_index)
{
return link_poses_[link_index];
}
Eigen::Affine3d RobotState::GetEndeffectorLinkPose()
{
return link_poses_.back() * robot_model_->GetEndeffectorTransform();
}
void RobotState::MoveToGripPose(const Eigen::Affine3d& link_pose)
{
Eigen::Vector3d target_position = link_pose.translation();
Eigen::Vector3d target_normal = -link_pose.linear().col(2);
constexpr int max_iterations = 10;
constexpr double alpha = 0.1;
for (int iteration = 0; iteration < max_iterations; iteration++)
{
PerformDerivativeForwardKinematics();
auto ee_pose = GetEndeffectorLinkPose();
Eigen::Vector3d ee_position = ee_pose.translation();
Eigen::Vector3d ee_normal = ee_pose.linear().col(0);
Eigen::Vector3d position_difference = target_position - ee_position;
Eigen::Vector3d normal_difference = target_normal - ee_normal;
Eigen::Matrix<double, 3, -1> jacobian;
jacobian.resize(Eigen::NoChange, robot_model_->GetJoints().size());
Eigen::Matrix<double, 3, 1> b;
b = position_difference;
for (int i = 0; i < robot_model_->GetJoints().size(); i++)
{
const auto& derivative_matrix = forward_kinematics_derivatives_[i];
jacobian.col(i) = derivative_matrix.block(0, 3, 3, 1);
}
Eigen::VectorXd solution = jacobian.jacobiSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(b);
for (int i = 0; i < robot_model_->GetJoints().size(); i++)
SetJointValue(i, GetJointValue(i) + solution(i));
}
for (int iteration = 0; iteration < max_iterations; iteration++)
{
PerformDerivativeForwardKinematics();
auto ee_pose = GetEndeffectorLinkPose();
Eigen::Vector3d ee_position = ee_pose.translation();
Eigen::Vector3d ee_normal = ee_pose.linear().col(0);
Eigen::Vector3d position_difference = target_position - ee_position;
Eigen::Vector3d normal_difference = target_normal - ee_normal;
Eigen::Matrix<double, 6, -1> jacobian;
jacobian.resize(Eigen::NoChange, robot_model_->GetJoints().size());
Eigen::Matrix<double, 6, 1> b;
b.block(0, 0, 3, 1) = position_difference;
b.block(3, 0, 3, 1) = normal_difference;
for (int i = 0; i < robot_model_->GetJoints().size(); i++)
{
const auto& derivative_matrix = forward_kinematics_derivatives_[i];
jacobian.block(0, i, 3, 1) = derivative_matrix.block(0, 3, 3, 1);
jacobian.block(3, i, 3, 1) = derivative_matrix.block(0, 0, 3, 1);
}
Eigen::VectorXd solution = jacobian.jacobiSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(b);
for (int i = 0; i < robot_model_->GetJoints().size(); i++)
SetJointValue(i, GetJointValue(i) + solution(i));
}
/*
for (int i = 0; i < robot_model_->GetJoints().size(); i++)
std::cout << "joint[" << i << "] = " << GetJointValue(i) << "\n";
*/
}
}
| [
"pjsdream2001@gmail.com"
] | pjsdream2001@gmail.com |
1971a7d55339ca03f50b7e846d6c5d6c7d34e4e6 | 78513fdfdb619403e5bad21860d504c507e9cf3f | /ProcessorA.cpp | 8685b79d7506d6f77aa01636b5af0f918d8e31c3 | [] | no_license | PeopleCF/Boudjelida_Amin | 1ea610bc397eae5e62c34542e078cb4f495acebb | 2e572baec36b6b750d1a98b3f2eab5ebb1188a9e | refs/heads/master | 2021-06-26T06:33:04.911938 | 2020-11-10T11:03:33 | 2020-11-10T11:03:33 | 148,983,040 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 627 | cpp | #include "stdafx.h"
#include "ProcessorA.h"
#include <iostream>
ProcessorA::ProcessorA()
{
}
std::string ProcessorA::Process(std::string s)
{
std::string reversed;
int prev = -1;
for (int i = s.length() - 1; i >=0 ; i--) {
if (i < 0) continue;
if (s[i] != ' ' && (s[i + 1] == ' ' || i == s.length() - 1)) prev = i;
if (s[i] == ' ' && prev!=-1 ) {
for (int j = i + 1; j <= prev; j++) {
reversed += s[j];
}
reversed += ' ';
prev = -1;
}
}
for (int i = 0; i <= prev; i++) reversed += s[i];
return reversed;
}
ProcessorA::~ProcessorA()
{
}
char ProcessorA::getType()
{
return 'A';
} | [
"32578115+PeopleCF@users.noreply.github.com"
] | 32578115+PeopleCF@users.noreply.github.com |
8968f28335dbdf0154257b1a65d96140e3ad416f | b66715c97e48731ebba2afb8d81d02beb695c691 | /SPOJ/MUL - Fast Multiplication.cpp | 918d15b51c7ec0215c61760fa475a982a0dd958a | [] | no_license | justHusam/Competitive-Programming | c105b982108db914d80c759741302a9828b123b4 | 4c86037370774dc18beb1f2b302a59f2e84979d4 | refs/heads/master | 2020-03-19T10:26:12.874772 | 2018-09-14T12:24:41 | 2018-09-14T12:24:41 | 136,369,844 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,850 | cpp | #include <bits/stdc++.h>
using namespace std;
const double PI = 4.0 * atan(1.0);
const complex<double> I(0, 1);
void FFT(double theta, vector<complex<double> > &a) {
int n = a.size();
for (int m = n; m >= 2; m >>= 1) {
int mh = m >> 1;
for (int i = 0; i < mh; i++) {
complex<double> w = exp(i * theta * I);
for (int j = i; j < n; j += m) {
int k = j + mh;
complex<double> x = a[j] - a[k];
a[j] += a[k];
a[k] = w * x;
}
}
theta *= 2;
}
int i = 0;
for (int j = 1; j < n - 1; j++) {
for (int k = n >> 1; k > (i ^= k); k >>= 1)
;
if (j < i)
swap(a[i], a[j]);
}
}
void FFT(vector<complex<double> > &a) {
int n = ceil(log(a.size()) / log(2) + 1e-9);
a.resize(1 << n);
FFT(2 * PI / a.size(), a);
}
void iFFT(vector<complex<double> > &a) {
FFT(-2 * PI / a.size(), a);
for (size_t i = 0; i < a.size(); i++)
a[i] /= a.size();
}
const int N = 1e4 + 10;
char a[N], b[N], c[2 * N];
vector<complex<double> > A, B, C;
void solve() {
int sa = strlen(a);
int sb = strlen(b);
int sc = sa + sb + 1;
A.clear();
A.resize(sc);
B.clear();
B.resize(sc);
for (int i = sa - 1, j = 0; i >= 0; i--)
A[j++] = a[i] - '0';
for (int i = sb - 1, j = 0; i >= 0; i--)
B[j++] = b[i] - '0';
FFT(A);
FFT(B);
C.clear();
C.resize(A.size());
for (size_t i = 0; i < A.size(); i++)
C[i] = A[i] * B[i];
iFFT(C);
for (size_t i = 0; i < C.size() - 1; i++) {
int cr = round(C[i].real()) / 10;
C[i] = fmod(round(C[i].real()), 10);
C[i + 1] += cr;
}
int i = C.size() - 1, j;
while (i >= 0 && fabs(C[i].real()) < 0.5)
i--;
if (i < 0) {
c[0] = '0', c[1] = 0;
return;
}
for (j = 0; i >= 0; j++, i--)
c[j] = round(C[i].real()) + '0';
c[j] = 0;
}
int main(int argc, char **argv) {
int t;
scanf("%d", &t);
while (t-- != 0) {
scanf("%s%s", a, b);
solve();
printf("%s\n", c);
}
return 0;
}
| [
"husam.sa3@gmail.com"
] | husam.sa3@gmail.com |
ceab46473d8f76f4a5c2450128a8fb048504bade | 12297984495f808a57ff61557eeecda2e08d5c3d | /makedepend/BuildDepend.cpp | 53a0574e29e37e0b4dc251f46aea0b688a563e9f | [] | no_license | alzwded/makedepend-wnt | 2f24f36f3eeb9d16745d6c878832a22e7f83d7dd | 50fddce8342698c80498d1b26073394774aff613 | refs/heads/master | 2021-01-18T19:30:00.438497 | 2012-09-24T13:18:41 | 2012-09-24T13:18:41 | 5,899,229 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 483 | cpp | #include "BuildDepend.h"
#include "DependencyGenerator.h"
#include "Path.h"
#include <fstream>
#include <string>
void BuildDepend::operator()(const std::string& _infile, const std::string& _outfile)
{
std::string outfile = _outfile;
if(outfile.empty()) {
Path outpath(_infile);
outfile = outpath.RHead() + ".d";
}
std::fstream fout(outfile.c_str(), std::ios::out);
if(!fout.is_open()) { return; }
fout << gDep_(_infile);
fout.close();
}
| [
"alzwded@gmail.com"
] | alzwded@gmail.com |
9284203a65e4795b5ea7e2881fca831794d1cf78 | 95dc70a29e3ccdfb5cecce1cd8099691d5b6bb5d | /leetcode/binary_tree_level_order_traversal.cpp | e422cebc0c2973c71e5250b8d1a02afeef5b1bf5 | [] | no_license | hotbig/letmetry | b19ba07e551aabb58c405695f5ed2a7fc0f57fd7 | 1418022a0d63c2cad41435d30d54b5a01773b0e5 | refs/heads/master | 2020-05-22T06:54:50.252554 | 2016-11-01T14:26:25 | 2016-11-01T14:26:25 | 36,932,799 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,421 | cpp | #include<iostream>
#include<string>
#include<vector>
using namespace std;
struct TreeNode{
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x):val(x), left(NULL), right(NULL){}
};
void printVV(vector<vector<int> > vv)
{
for(int i = 0; i < vv.size(); i++)
{
for(int j = 0; j < vv[i].size(); j++)
{
cout << vv[i][j] << " ";
}
cout<< endl;
}
}
class Solution{
vector<vector<int> >res;
public:
void DFS(TreeNode* root, int level)
{
if(root == NULL) return;
if(level == res.size())
{
res.push_back(vector<int>());
}
res[level].push_back(root->val);
DFS(root->left, level+1);
DFS(root->right, level+1);
}
vector<vector<int> > levelOrderBottom(TreeNode* root)
{
DFS(root, 0);
return vector<vector<int> >(res.begin(), res.end());
}
};
int main()
{
Solution s;
TreeNode a(0);
TreeNode b(-3);
TreeNode c(-9);
TreeNode d(-8);
TreeNode e(2);
TreeNode f(-5);
TreeNode g(5);
TreeNode h(-2);
#if 0
1
2 5
3 4 6 7
#endif
a.left = &b;
// a.right = &h;
// b.left = &c;
// b.right = &d;
// c.left = &e;
// e.left = &g;
// d.right=&f;
printVV(s.levelOrderBottom(&a));
return 0;
}
| [
"randyn.yang@gmail.com"
] | randyn.yang@gmail.com |
78a1afda36dc2098f548fe29bf69b437d2eda214 | c507645952553f2a7e93c14ec19ff3246feca49b | /src/GBuffer.h | 15c5adcd551edf4477831c0f64f98e609b76a656 | [] | no_license | LeifNode/KinectProject | 33a6fc002b7a513245ce0202829c55b3365f0b86 | 68b9fe0279dbf672670ae2b6ed92a0656dc5732d | refs/heads/master | 2021-03-12T23:19:26.096556 | 2015-01-13T23:57:41 | 2015-01-13T23:57:41 | 20,317,533 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 820 | h | #pragma once
#include "d3dStd.h"
#include "Texture.h"
class GBuffer
{
friend class D3DRenderer;
public:
GBuffer();
~GBuffer();
void bindRenderTargets();
void bindTextures();
void bindSampler();
void clearRenderTargets();
private:
void Initialize(int width, int height);
void DeInit();
void OnResize(int width, int height);
private:
Texture* mpDiffuseTexture;
Texture* mpDepthStencilTexture;
Texture* mpNormalTexture;
Texture* mpSpecularTexture;
Texture* mpEmissiveTexture;
ID3D11DepthStencilView* mpDepthStencilTargetView;
ID3D11RenderTargetView* mpDiffuseTargetView;
ID3D11RenderTargetView* mpNormalTargetView;
ID3D11RenderTargetView* mpSpecularTargetView;
ID3D11RenderTargetView* mpEmissiveTargetView;
ID3D11DepthStencilState* mpDepthStencilState;
ID3D11SamplerState* mpSamplerState;
}; | [
"LErkenbrach@gmail.com"
] | LErkenbrach@gmail.com |
8ed4bdf83ad5671cebf9b4072a3d1dd40fbcd409 | c58bed4b1a7d21417f85f2bb7ad825c9de97c3b6 | /SRM 542/WorkingRabbits.cpp | cfde403a25a05ea0685f774c0a0391e579342634 | [] | no_license | vlad2901/topcoder | 0aa759007ed24b2185664294da4c67af8fbea418 | 97856c3dd2a5b8ee875cfda7dc3b6f93d142e10b | refs/heads/master | 2021-01-20T02:47:47.757151 | 2012-05-23T11:33:15 | 2012-05-23T11:33:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 690 | cpp | #include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
using namespace std;
class WorkingRabbits {
public:
double getEfficiency(vector <string> profit) {
int n = profit.size();
double sum = 0;
for(int i=0;i<n;++i) {
for(int j=0;j<i;++j) {
sum += profit[i][j]-'0';
}
}
return 2*sum / (n*(n-1));
}
};
// Powered by FileEdit
// Powered by TZTester 1.01 [25-Feb-2003]
// Powered by CodeProcessor
| [
"vlad.berindei@gmail.com"
] | vlad.berindei@gmail.com |
b3c1e00b00ee2901d973edda38b9ad9fccdba9c3 | a49ac9e119b891c7307b8b02a5e4fa3cf5ec6f6c | /Facebook/copyConnections.cpp | a4dd93831cda7610ec3b56d135d0bfc0c912c741 | [] | no_license | EdgeLord836/problem-solving | c4adae209a4f8f21a2bbc4ece47024031ee54ba6 | e10655f197f45ce473acf9cc5f014bc25c5dca48 | refs/heads/main | 2023-08-14T17:38:17.189139 | 2021-10-09T01:16:17 | 2021-10-09T01:16:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,982 | cpp | using namespace std;
#include <iostream>
#include <vector>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <random>
#include <utility>
class Node {
public:
int data;
vector<Node*> friends;
Node(int d) {
data = d;
}
~Node() {
for (int i = 0; i < friends.size(); i++) {
delete friends[i];
}
friends.clear();
}
};
void shuffle(vector<pair<int, int>> &vec) {
random_device rd;
default_random_engine rng( rd() );
shuffle(vec.begin(), vec.end(), rng);
}
class CloneGraph {
public:
static vector<Node*> createTestGraphDirected(int nodes_count, int edges_count) {
vector<Node*> vertices;
for (int i = 0; i < nodes_count; i++) {
vertices.push_back(new Node(i));
}
vector<pair<int, int>> all_edges;
for (int i = 0; i < vertices.size(); i++) {
for (int j = i + 1; j < vertices.size(); j++) {
all_edges.push_back(make_pair(i, j));
}
}
shuffle(all_edges);
for (int i = 0; i < edges_count && i < all_edges.size(); i++) {
pair<int, int> edge = all_edges[i];
vertices[edge.first]->friends.push_back(vertices[edge.second]);
vertices[edge.second]->friends.push_back(vertices[edge.first]);
}
return vertices;
}
static void printGraph(vector<Node*> vertices) {
for (auto n : vertices) {
cout << to_string(n->data) + ": {";
for (auto t : n->friends) {
cout << to_string(t->data) + " ";
}
cout << "}" << endl;
}
}
static void printGraph(Node* root, unordered_set<Node*> &visited_nodes) {
if (root == nullptr || visited_nodes.find(root) != visited_nodes.end()) {
return;
}
visited_nodes.insert(root);
cout << to_string(root->data) + ": {";
for (auto n : root->friends) {
cout << to_string(n->data) + " ";
}
cout << "}" << endl;
for (auto n : root->friends) {
printGraph(n, visited_nodes);
}
}
static void printGraph(Node* root) {
unordered_set<Node*> visited_nodes;
printGraph(root, visited_nodes);
}
static bool areGraphsEqualRec(Node* root1, Node* root2, unordered_set<Node*> &visited) {
if (root1 == nullptr && root2 == nullptr) {
return true;
}
if (root1 == nullptr || root2 == nullptr) {
return false;
}
if (root1->data != root2->data) {
return false;
}
if (root1->friends.size() != root2->friends.size()) {
return false;
}
for (Node* nbr1 : root1->friends) {
bool found = false;
for (Node* nbr2 : root2->friends) {
if (nbr1->data == nbr2->data) {
if (visited.find(nbr1) != visited.end()) {
visited.insert(nbr1);
areGraphsEqualRec(nbr1, nbr2, visited);
}
found = true;
break;
}
}
if (!found) {
return false;
}
}
return true;
}
};
Node* cloneRec(Node* root, unordered_map<Node*, Node*> &nodesCompleted) {
if (root == nullptr) {
return nullptr;
}
Node* newNode = new Node(root->data);
nodesCompleted[root] = newNode;
for (auto p : root->friends) {
Node* x = nodesCompleted[p];
if (x == nullptr) {
newNode->friends.push_back(cloneRec(p, nodesCompleted));
} else {
newNode->friends.push_back(x);
}
}
return newNode;
}
Node* clone(Node* root) {
unordered_map<Node*, Node*> nodesCompleted;
return cloneRec(root, nodesCompleted);
}
int main() {
vector<Node*> vertices = CloneGraph::createTestGraphDirected(7, 18);
CloneGraph::printGraph(vertices[0]);
Node* cp = clone(vertices[0]);
cout << endl;
cout << "After copy." << endl;
CloneGraph::printGraph(cp);
unordered_set<Node*> set;
cout << boolalpha << CloneGraph::areGraphsEqualRec(vertices[0], cp, set) << endl;
} | [
"imhantran@gmail.com"
] | imhantran@gmail.com |
25d8f955812312a79c724e4f04c70c2e49d72a79 | 5e2bef5a3f06fc33d37ddee00b9b9f647e9ba05e | /c_how_to_program/lessons/18.14/Date.cpp | 195f747bb0c9db2e22cb871c3535a1d9fbab35f4 | [] | no_license | xoptov/learning_c_and_cpp | 29c4ea111cdf1f4891c81facc8916f7efbdececa | a70c116fe07cd9b763dc69916a28d1a213e5bee6 | refs/heads/master | 2020-06-26T08:12:40.721234 | 2019-09-17T06:01:00 | 2019-09-17T06:01:00 | 199,580,694 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 994 | cpp | #include <iostream>
using std::cout;
using std::endl;
#include "Date.h"
Date::Date(int mn, int dy, int yr)
{
if (mn > 0 && mn <= 12)
month = mn;
else {
month = 1;
cout << "Invalid month (" << mn << ") set to 1." << endl;
}
year = yr;
day = checkDay(dy);
cout << "Date object constructor for date ";
print();
cout << endl;
}
void Date::print() const
{
cout << month << '/' << day << '/' << year;
}
Date::~Date()
{
cout << "Date object destructor for date ";
print();
cout << endl;
}
int Date::checkDay(int testDay) const
{
static const int daysPerMonth[13] = {
0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
};
if (testDay > 0 && testDay <= daysPerMonth[month])
return testDay;
if (month == 2 && testDay == 29 && (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)))
return testDay;
cout << "Invalid day (" << testDay << ") set to 1.\n";
return 1;
}
| [
"xoptov@mail.ru"
] | xoptov@mail.ru |
b55f1726efd112b95eeecd749ad50c96dc4efbfa | ab831d976e3cc012e362b7b520f25ae5a127d799 | /third/behaviac-3.5.9/inc/behaviac/base/core/singleton.h | 5c44b93418c775ccfc2f856815b6d05a45aa2e73 | [
"LicenseRef-scancode-unknown-license-reference",
"Zlib",
"BSD-2-Clause",
"BSD-3-Clause",
"MIT"
] | permissive | bohge/Hades | 7b8c04695cd6e7ecb38e6fd554f0e6f7aa59ca1d | 472d72ef095048d080e1b4fcf0f846d0e57b8b22 | refs/heads/master | 2021-01-02T22:16:05.573728 | 2018-08-04T02:04:37 | 2018-08-04T02:04:37 | 99,313,890 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,831 | h | /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Tencent is pleased to support the open source community by making behaviac available.
//
// Copyright (C) 2015 THL A29 Limited, a Tencent company. All rights reserved.
//
// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except in compliance with
// the License. You may obtain a copy of the License at http://opensource.org/licenses/BSD-3-Clause
//
// 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 BEHAVIAC_BASE_CORE_SINGLETON_H
#define BEHAVIAC_BASE_CORE_SINGLETON_H
#include "behaviac/base/core/config.h"
#include "behaviac/base/core/assert_t.h"
#include "behaviac/base/core/memory/memory.h"
/*
class CSequenceManager
{
BEHAVIAC_DELCARE_SINGLETON(CSequenceManager);
//...
};
in cpp:
BEHAVIAC_IMPLEMNT_SINGLETON(CSequenceManager);
*/
#define BEHAVIAC_DELCARE_SINGLETON(T) \
protected: \
static T* ms_singleton; \
static T* GetInstance_(); \
static void SetInstance_(T*); \
T(const T&); \
const T& operator=(const T&); \
public: \
static inline T* GetInstance() \
{ \
if (!GetInstance_()) \
{ \
CreateInstance(); \
} \
\
return GetInstance_(); \
} \
\
static T* CreateInstance() \
{ \
if (!GetInstance_()) \
{ \
T* p = BEHAVIAC_NEW T; \
SetInstance_(p); \
} \
\
return GetInstance_(); \
} \
\
static void DestroyInstance() \
{ \
T* p = GetInstance_(); \
if (p) \
{ \
BEHAVIAC_DELETE(p); \
SetInstance_(0); \
} \
}
#define BEHAVIAC_IMPLEMNT_SINGLETON(T) \
T* T::ms_singleton = 0; \
T* T::GetInstance_() \
{ \
return ms_singleton; \
} \
void T::SetInstance_(T* p) \
{ \
ms_singleton = p; \
}
#endif//BEHAVIAC_BASE_CORE_SINGLETON_H
| [
"zhaopeng_wj@cyou-inc.com"
] | zhaopeng_wj@cyou-inc.com |
46765d5545005280effe0d26c16ca2ae167c89a8 | 0a1f7719e13c0abc90088a8ef193c0dec227fe04 | /BK-Algorithm/StackApplication.h | e0dfc56c254f7a0f47b077d6cdd9b8bfef9db2bc | [] | no_license | BK927/BK-FromDataStructure-ToAlgorithm | 28880762a3a63b0e6ba55caeb6e3fffebed07cfb | fc39ec7133dfa6b8e0bc6b3c9b71310a6edd97ee | refs/heads/master | 2020-06-19T01:04:46.097427 | 2019-07-21T06:31:53 | 2019-07-21T06:31:53 | 196,513,274 | 1 | 0 | null | null | null | null | UHC | C++ | false | false | 2,361 | h | #pragma once
#include <algorithm>
#include <iostream>
#include <fstream>
#include "Stack.h"
#include "Location2D.h"
#include "MazeManager.h"
using namespace std;
namespace algorithm
{
class StackApplication
{
public:
static void CheckMatching(const char* filename);
template<typename unsigned int HEIGHT, unsigned int WIDTH>
static void ExploreMaze(const char maze[][WIDTH]);
private:
enum class eCheckMatchingError
{
Missing_Single_Quotation_Mark,
Missing_Double_Quotation_Mark,
Missing_Bracket
};
static void checkMatchingErrMsg(const unsigned int nLine, const unsigned int nChar, const eCheckMatchingError err);
};
template<typename unsigned int HEIGHT, unsigned int WIDTH>
inline static void StackApplication::ExploreMaze(const char maze[][WIDTH])
{
char copiedMaze[HEIGHT][WIDTH];
memcpy_s(copiedMaze, sizeof(char) * HEIGHT * WIDTH, maze, sizeof(char) * HEIGHT * WIDTH);
bkDS::Stack<Location2D> stack;
Location2D entry = MazeManager::FindEntry<HEIGHT, WIDTH>(copiedMaze);
if (entry == Location2D(-1, -1))
{
cout << "오류 : 입구를 찾는데 실패 했습니다." << endl;
return;
}
stack.Push(entry);
while (!stack.IsEmpty())
{
Location2D currentLoc = stack.Peek();
stack.Pop();
MazeManager::PrintMap<HEIGHT, WIDTH>(copiedMaze, currentLoc);
cout << '(' << currentLoc.row << ", " << currentLoc.col << ") " << endl << endl;
if (copiedMaze[currentLoc.row][currentLoc.col] == 'x')
{
cout << endl << "출구 발견!" << endl;
return;
}
copiedMaze[currentLoc.row][currentLoc.col] = '.';
if (MazeManager::IsValidLoc<HEIGHT, WIDTH>(currentLoc.row + 1, currentLoc.col, copiedMaze))
{
stack.Push(Location2D(currentLoc.row + 1, currentLoc.col));
}
if (MazeManager::IsValidLoc<HEIGHT, WIDTH>(currentLoc.row - 1, currentLoc.col, copiedMaze))
{
stack.Push(Location2D(currentLoc.row - 1, currentLoc.col));
}
if (MazeManager::IsValidLoc<HEIGHT, WIDTH>(currentLoc.row, currentLoc.col + 1, copiedMaze))
{
stack.Push(Location2D(currentLoc.row, currentLoc.col + 1));
}
if (MazeManager::IsValidLoc<HEIGHT, WIDTH>(currentLoc.row, currentLoc.col - 1, copiedMaze))
{
stack.Push(Location2D(currentLoc.row, currentLoc.col - 1));
}
}
cout << "오류 : 출구를 발견하는데 실패했습니다." << endl;
}
}
| [
"dead4bees927@gmail.com"
] | dead4bees927@gmail.com |
114bf8d52bd515d580403613e9b69a836e347f7a | 92d69be79664e5f63a56317ad1353ebe6c3e2b2d | /PLFoundationCore/PLTimer.cpp | d3e849574700682b26a8335886c4b8676f39114f | [
"Apache-2.0"
] | permissive | YPLiang19/PLFoundation | c95b264752c0ebeb1e1e11aa99a39e86d61c5970 | 5701a005ad2fc75f08786ba8c61d6beb590b2574 | refs/heads/master | 2022-12-02T10:31:41.712963 | 2020-08-21T10:07:50 | 2020-08-21T10:07:50 | 285,720,354 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,530 | cpp | //
// PLTimer.cpp
// PLFoundation
//
// Created by yongpengliang on 2020/8/20.
// Copyright © 2020 yongpengliang. All rights reserved.
//
#include "PLTimer.h"
PLFOUNDATON_NAMESPACE_BEGIN
void PLTimer::init(PLTimeInterval interval, void *userInfo, bool repeats){
if (interval <= 0.0) {
interval = 0.0001;
}
_fireDate = PLDate(_interval);
_invalidated = false;
_userInfo = userInfo;
if (repeats) {
_repeats = true;
_interval = interval;
}else{
_repeats = false;
_interval = 0.0;
}
}
PLTimer::~PLTimer(){
if (_invalidated == false) {
invalidate();
}
}
void PLTimer::invalidate(){
_invalidated = true;
}
bool PLTimer::isValid(){
return !_invalidated;
}
PLDate PLTimer::fireDate(){
return _fireDate;
}
void PLTimer::setFireDate(PLDate &fireDate){
_fireDate = fireDate;
}
PLTimeInterval PLTimer::timeInterval(){
return _interval;
}
void * PLTimer::userInfo(){
return _userInfo;
}
PLComparisonResult PLTimer::compare(std::shared_ptr<PLTimer> anotherTimer){
if (this == anotherTimer.get()) {
return PLOrderedSame;
}
return _fireDate.compare(anotherTimer->_fireDate);
}
void PLTimer::fire(){
if (_block) {
try {
_block(shared_from_this());
} catch (...) {
fprintf(stderr, "PLTimer::fire err");
}
if (_repeats == false) {
invalidate();
}
}else{
invalidate();
}
}
PLFOUNDATON_NAMESPACE_END
| [
"ikeshi@tencent.com"
] | ikeshi@tencent.com |
c3e600b97fdb8c7357df69bc432788c7fcbae104 | 267bdf2bf6873ee1840784173de9bac70adef426 | /Advanced level/1038.Recover the Smallest Number.cpp | c2d22ce36be2cb97ec94cb26bcc6e9e51350a215 | [] | no_license | Im4lish/PAT | 48f14b728a5b34c026c22863a1c2a3585c3c2e81 | d8d681bb1ebc54900882ba873386b2033076b711 | refs/heads/master | 2021-08-31T11:34:50.558329 | 2017-12-21T07:12:19 | 2017-12-21T07:12:19 | 111,079,617 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 480 | cpp | #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
bool cmp(string a,string b) {
return a+b < b+a;
}
int main() {
int n;
cin>>n;
vector<string> vec(n);
for(int i=0;i<n;++i) {
cin>>vec[i];
}
sort(vec.begin(),vec.end(),cmp);
string ans;
for(int i=0;i<n;++i) {
ans += vec[i];
}
while(ans.size() != 0 && ans[0] == '0') {
ans.erase(ans.begin());
}
if(ans.size() == 0) {
cout<<0;
} else {
cout<<ans;
}
return 0;
}
| [
"zhaojiandong1995@gmail.com"
] | zhaojiandong1995@gmail.com |
06dd5bbcdbd171c1eaa79dc33495a46c310a5cc0 | 49e05bde450a459582e5be2734a90acfe2051a68 | /Animation_Kinematics/src/main.cpp | 06df4fc584a1832ab550a6668df7875cf9ff680a | [] | no_license | rt2520/Graphics | 47659076f32acaeb0a0a3d33dd33d599f36c8c78 | 804a7504b9b345ab74f589953098d8fcc21ec4b3 | refs/heads/master | 2020-05-17T23:15:29.350037 | 2014-10-06T14:30:11 | 2014-10-06T14:30:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 28,228 | cpp | /* Simple opengl demo program.
*/
//#elif defined(__linux)
#if defined(__APPLE__) || defined(MACOSX)
# include <GLUT/glut.h>
#else
# include <GL/glut.h>
#endif
#include <iostream>
#include <sstream>
#include <stdlib.h>
#include <stdio.h>
#include "GLScreenCapturer.h"
#include "trackball.h"
#include "Texture.h"
#include "Tree.h"
using namespace std;
#define BUFFER_LENGTH 64
#define drawOneLine(x1,y1,x2,y2) glBegin(GL_LINES); \
glVertex2f ((x1),(y1)); glVertex2f ((x2),(y2)); glEnd();
#define degree(x) (x * 180 / 3.1416)
#define radian(x) (x * 3.1416 / 180)
const float pinDia = 0.8;
//GLfloat camRotX, camRotY, camPosX, camPosY, camPosZ;
enum mode {FORWARD, INVERSE};
int currMode = FORWARD;
enum selectedModel {MODEL1 , MODEL2};
int currentModel = MODEL1;
enum selectedJoint1 {JOINT1, JOINT2, JOINT3, JOINT4};
int currentJoint1 = JOINT1;
enum selectedJoint2 {JOINT11 = 4, JOINT12, JOINT13, JOINT21, JOINT22, JOINT23, JOINT24,
JOINT31, JOINT32, JOINT33, JOINT41, JOINT42, JOINT43, JOINT44, JOINT45};
int currentJoint2 = JOINT12;
bool animating = false;
enum ikChain {CHAIN1, CHAIN2, CHAIN3, CHAIN4, CHAIN5};
int currIKChain = CHAIN1;
float near = 0.5f;
float far = 100.0f;
float camZ = 15.0;
Vector3f targetPos(6.0 * cos(0.5), 6.0* sin(0.5), 0.0);
Vector3f currentPos[5];
float smallIncrementIK = 0.0;
Joint joint1(0.0, 0.0, 1.0, 2.75, 0.0, 0.0, 0.0, JOINT1);
Joint joint2(0.0, 0.0, 1.0, 2.75, 0.0, 0.0, 10.0, JOINT2);
Joint joint3(0.0, 0.0, 1.0, 2.75, 0.0, 0.0, 0.0, JOINT3);
Joint joint4(0.0, 0.0, 1.0, 2.75, 0.0, 0.0, 0.0, JOINT4);
Node model1;
Joint joint11(0.0, 0.0, 1.0, 2.75, 0.0, 0.0, 0.0, JOINT11);
Joint joint12(0.0, 0.0, 1.0, 4.0, 0.0, 0.0, 10.0, JOINT12);
Joint joint13(0.0, 0.0, 1.0, 2.75, 0.0, 0.0, 0.0, JOINT13);
Node model2;
Joint joint21(0.0, 0.0, 1.0, 2.5, 0.0, 0.0, 60.0, JOINT21);
Joint joint22(0.0, 0.0, 1.0, 2.75, 0.0, 0.0, 10.0, JOINT22);
Joint joint23(0.0, 0.0, 1.0, 1.5, 0.0, 0.0, 0.0, JOINT23);
Joint joint24(0.0, 0.0, 1.0, 2.0, 0.0, 0.0, 0.0, JOINT24);
Node model3;
Joint joint31(0.0, 0.0, 1.0, 2.75, 0.0, 0.0, -60.0, JOINT31);
Joint joint32(0.0, 0.0, 1.0, 2.75, 0.0, 0.0, 10.0, JOINT32);
Joint joint33(0.0, 0.0, 1.0, 2.75, 0.0, 0.0, 0.0, JOINT33);
Node model4;
Joint joint41(0.0, 0.0, 1.0, 2.0, 0.0, 0.0, 180.0, JOINT41);
Joint joint42(0.0, 0.0, 1.0, 2.5, 0.0, 0.0, 10.0, JOINT42);
Joint joint43(0.0, 0.0, 1.0, 1.5, 0.0, 0.0, 0.0, JOINT43);
Joint joint44(0.0, 0.0, 1.0, 3.0, 0.0, 0.0, 0.0, JOINT44);
Joint joint45(0.0, 0.0, 1.0, 2.5, 0.0, 0.0, 0.0, JOINT45);
Node model5;
const int FPS = 60;
GLint viewport[4];
GLdouble modelview[16];
GLdouble projection[16];
GLuint pickedObj = -1;
char titleString[150];
int winWidth = 960;
int winHeight = 540;
// Lights & Materials
//GLfloat ambient[] = {0.2, 0.2, 0.2, 1.0};
GLfloat ambient[] = {1.0, 1.0, 1.0, 1.0};
GLfloat position[] = {0.0, 0.0, -10.0, 1.0};
GLfloat mat_diffuse[] = {1.0, 1.0, 1.0, 1.0};
GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0};
GLfloat mat_shininess[] = {50.0};
static GLScreenCapturer screenshot("screenshot-%d.ppm");
GLfloat norm(Vector3f v)
{
return (GLfloat)sqrt (v(0) * v(0) + v(1) * v(1) + v(2) * v(2));
}
MatrixXf getPseudoInverse(MatrixXf J)
{
MatrixXf JTr = J.transpose();
MatrixXf JJTr = (J * JTr);
MatrixXf JJTrPlusLambdaIInv = (JJTr + 0.000001 * MatrixXf::Identity(JJTr.rows(), JJTr.cols())).inverse();
return JTr * JJTrPlusLambdaIInv;
}
void incrementAnglesRecursively(Node model, MatrixXf dTheta, int level)
{
model.joint->rotation += degree(dTheta(level));
for (int i = 0; i < model.children.size(); i++)
incrementAnglesRecursively(model.children[i], dTheta, level + i + 1);
}
MatrixXf getJacobian(Node model, MatrixXf &J, int col, float prevAngle)
{
float length = norm(model.joint->endPoint);
float angle = model.joint->rotation + prevAngle;
Vector3f tmp(-length * sin(radian(angle)),length * cos(radian(angle)), model.joint->endPoint(2));
if (model.children.size() > 0)
{
Vector3f val = tmp + getJacobian(model.children[0], J, col + 1, angle);
J(0 , col) = val(0);
J(1 , col) = val(1);
J(2 , col) = val(2);
return (val);
}
else
{
J(0 , col) = tmp(0);
J(1 , col) = tmp(1);
J(2 , col) = tmp(2);
return tmp;
}
}
Vector3f getEffectorPos(Node model, float prevAngle)
{
float length = norm(model.joint->endPoint);
float angle = model.joint->rotation + prevAngle;
Vector3f tmp(length * cos(radian(angle)),length * sin(radian(angle)), model.joint->endPoint(2));
if (model.children.size() > 0)
{
Vector3f val = tmp + getEffectorPos(model.children[0], angle);
return (val);
}
else
{
return tmp;
}
}
int getDepth(Node model)
{
if (model.children.size() == 0)
return 1;
return 1 + getDepth(model.children[0]);
}
bool updateMovementAngles(Node model, int effector)
{
//Vector3f currentEffectorPos = currentPos[effector];
int joints = getDepth(model);
MatrixXf jacobian = MatrixXf::Zero(3, joints);
Vector3f currentEffectorPos = getEffectorPos(model, 0.0);
getJacobian(model, jacobian, 0, 0.0);
Vector3f dPos = (targetPos - currentEffectorPos);
//while (norm(dPos) > 0.1)
dPos *= 0.1;
MatrixXf dTheta = getPseudoInverse(jacobian) * dPos;
incrementAnglesRecursively(model, dTheta, 0);
if (norm(targetPos - getEffectorPos(model, 0.0)) < 0.001)
return true;
if (norm(targetPos - getEffectorPos(model, 0.0)) > norm(targetPos - currentEffectorPos))
{
incrementAnglesRecursively(model, -1 * dTheta, 0);
return true;
}
else
return false;
}
void initModels()
{
vector<Node> v;
Node node(&joint4, std::vector<Node>());//, NULL,
v.push_back(node);
node = Node(&joint3, v);// NULL,
v.clear();
v.push_back(node);
node = Node(&joint2, v);// NULL,
v.clear();
v.push_back(node);
model1 = Node(&joint1, v);//, NULL
//CHAIN 2
v.clear();
node = Node(&joint13, v);// NULL,
v.push_back(node);
node = Node(&joint12, v);// NULL,
v.clear();
v.push_back(node);
model2 = Node(&joint11, v);//, NULL*/
//CHAIN 3
v.clear();
node = Node(&joint24, v);// NULL,
v.push_back(node);
node = Node(&joint23, v);// NULL,
v.clear();
v.push_back(node);
node = Node(&joint22, v);// NULL,
v.clear();
v.push_back(node);
model3 = Node(&joint21, v);//, NULL*/
//CHAIN 4
v.clear();
node = Node(&joint33, v);// NULL,
v.push_back(node);
node = Node(&joint32, v);// NULL,
v.clear();
v.push_back(node);
model4 = Node(&joint31, v);//, NULL*/
//CHAIN 5
v.clear();
node = Node(&joint45, v);// NULL,
v.push_back(node);
node = Node(&joint44, v);// NULL,
v.clear();
v.push_back(node);
node = Node(&joint43, v);// NULL,
v.clear();
v.push_back(node);
node = Node(&joint42, v);// NULL,
v.clear();
v.push_back(node);
model5 = Node(&joint41, v);//, NULL*/
}
void initLights(void)
{
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
//glEnable(GL_BLEND);
glDisable(GL_BLEND);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, mat_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, mat_specular);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
}
void reshape( int w, int h )
{
winWidth = w;
winHeight = h;
tbReshape(w, h);
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// Set the clipping volume
gluPerspective(60.0f, (GLfloat)w / (GLfloat)h, near, far);
//glOrtho(0.0, (GLdouble) winWidth, 0.0, (GLdouble) winHeight, 1.0f, 100.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void timer(int v) {
if (currentModel == MODEL1)
{
if (!updateMovementAngles(model1, 0))
{
glutTimerFunc(1000/FPS, timer, v);
}
}
else if (currIKChain == CHAIN2)
{
if (!updateMovementAngles(model2, 0))
{
glutTimerFunc(1000/FPS, timer, v);
}
}
else if (currIKChain == CHAIN3)
{
if (!updateMovementAngles(model3, 0))
{
glutTimerFunc(1000/FPS, timer, v);
}
}
else if (currIKChain == CHAIN4)
{
if (!updateMovementAngles(model4, 0))
{
glutTimerFunc(1000/FPS, timer, v);
}
}
else if (currIKChain == CHAIN5)
{
if (!updateMovementAngles(model5, 0))
{
glutTimerFunc(1000/FPS, timer, v);
}
}
glutPostRedisplay();
}
int animatePosGen = 0;
int getClosestChain()
{
float min = norm(getEffectorPos(model2, 0.0) - targetPos);
int chain = CHAIN2;
float tmp = norm(getEffectorPos(model3, 0.0) - targetPos);
if (tmp < min)
{
min = tmp;
chain = CHAIN3;
}
tmp = norm(getEffectorPos(model4, 0.0) - targetPos);
if (tmp < min)
{
min = tmp;
chain = CHAIN4;
}
tmp = norm(getEffectorPos(model5, 0.0) - targetPos);
if (tmp < min)
{
min = tmp;
chain = CHAIN5;
}
return chain;
}
void animatedTimer(int v) {
if (animating && currMode == INVERSE)
{
if (currentModel == MODEL1)
{
if (!updateMovementAngles(model1, 0))
{
glutTimerFunc(1000/FPS, animatedTimer, v);
}
else if (animatePosGen++ <= 10)
{
srand (time(NULL));
targetPos(0) = ((rand() % 2 == 0) ? -1 : 1) * (rand() % 8);
targetPos(1) = ((rand() % 2 == 0) ? -1 : 1) * (rand() % 8);
glutTimerFunc(1000/FPS, animatedTimer, v);
}
else
animating = false;
}
else
{
bool rerun = false;
if (currIKChain == CHAIN2)
rerun = !updateMovementAngles(model2, 0);
if (currIKChain == CHAIN3)
rerun = !updateMovementAngles(model3, 0);
if (currIKChain == CHAIN4)
rerun = !updateMovementAngles(model4, 0);
if (currIKChain == CHAIN5)
rerun = !updateMovementAngles(model5, 0);
if (rerun)
{
glutTimerFunc(1000/FPS, animatedTimer, v);
}
else if (animatePosGen++ <= 10)
{
srand (time(NULL));
targetPos(0) = ((rand() % 2 == 0) ? -1 : 1) * (rand() % 8);
targetPos(1) = ((rand() % 2 == 0) ? -1 : 1) * (rand() % 8);
currIKChain = getClosestChain();
glutTimerFunc(1000/FPS, animatedTimer, v);
}
else
animating = false;
}
}
glutPostRedisplay();
}
void setupRC()
{
tbInit(GLUT_RIGHT_BUTTON);
tbAnimate(GL_TRUE);
// Place Camera
// camRotX = 350.0f;
// camRotY = 680.0f;
// camPosX = 0.0f;
// camPosY = 0.0f;
// camPosZ = -10.5f;
//glEnable( GL_DEPTH_TEST );
//glShadeModel(GL_SMOOTH);
//glClearColor(0.0, 0.0, 0.0, 0.0);
//glShadeModel (GL_FLAT);
initLights();
//initDisplayLists();
}
void setCamera( void )
{
/*glTranslatef(0, 0, camPosZ);
glRotatef(camRotX, 1, 0, 0);
glRotatef(camRotY, 0, 1, 0);*/
glTranslatef(0.0, 0.0, -1 * camZ);
//glScalef(0.1, 0.1, 0.1);
//gluLookAt(0.0, 2.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
GLfloat selColor[] = {0, 1, 0, 1};
void drawNodeRecursively(Node node, bool pickable, GLfloat jointColor[], GLfloat linkColor[])
{
glPushMatrix();
{
Joint* currJoint = node.joint;
glPushMatrix();
{
if (currentJoint1 == currJoint->selName || currentJoint2 == currJoint->selName)
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, selColor);
else
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, jointColor);
if (currentModel == MODEL2 && (currentJoint2 == JOINT11 || currentJoint2 == JOINT21
|| currentJoint2 == JOINT31 || currentJoint2 == JOINT41))
{
if (currJoint->selName == JOINT11 || currJoint->selName == JOINT21 ||
currJoint->selName == JOINT31 || currJoint->selName == JOINT41)
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, selColor);
}
//glLoadName(currJoint->selName);
// if (pickable)
// glColor3ub(currJoint->selName + 1,0,0);
glutSolidSphere(0.4, 20, 20);
}
glPopMatrix();
//glTranslatef(0.25, 0.0, 0.0);
glRotatef(currJoint->rotation, currJoint->axis(0), currJoint->axis(1), currJoint->axis(2));
glPushMatrix();
{
glRotatef(90.0, 0.0, 1.0, 0.0);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, linkColor);
GLUquadric* cylQuad = gluNewQuadric();
// glLoadName(currJoint->selName);
// if (pickable)
// glColor3ub(currJoint->selName + 1,0,0);
if (cylQuad != 0)
gluCylinder(cylQuad, 0.25, 0.25, norm(currJoint->endPoint), 10, 50);
}
glPopMatrix();
glTranslatef(currJoint->endPoint(0), currJoint->endPoint(1), currJoint->endPoint(2));//joint1.axleLength + joint2.radius, 0.0, 0.0);
for (int i = 0; i < node.children.size(); i++)
drawNodeRecursively(node.children[i], pickable, jointColor, linkColor);
}
glPopMatrix();
}
void drawModel1 (bool pickable)
{
GLfloat c1[] = {0, 0, 0, 1};
GLfloat c2[] = {0, 0, 0, 1};
if (currentModel == MODEL1)
{
c1[0] = 1; c1[1] = 0; c1[2] = 0;
c2[0] = 1; c2[1] = 0; c2[2] = 1;
drawNodeRecursively(model1, pickable, c1, c2);
}
if (currentModel == MODEL2)
{
c1[0] = 1; c1[1] = 0; c1[2] = 0;
c2[0] = 1; c2[1] = 0; c2[2] = 1;
drawNodeRecursively(model2, pickable, c1, c2);
c1[0] = 0; c1[1] = 0; c1[2] = 1;
c2[0] = 0.6; c2[1] = 0.4; c2[2] = 0.2;
drawNodeRecursively(model3, pickable, c1, c2);
c1[0] = 1; c1[1] = 1; c1[2] = 0;
c2[0] = 0.2; c2[1] = 0.4; c2[2] = 0.6;
drawNodeRecursively(model4, pickable, c1, c2);
c1[0] = 0; c1[1] = 1; c1[2] = 1;
c2[0] = 0.7; c2[1] = 0.8; c2[2] = 0.4;
drawNodeRecursively(model5, pickable, c1, c2);
}
// Retrieve current matrice before they popped.
glGetDoublev( GL_MODELVIEW_MATRIX, modelview ); // Retrieve The Modelview Matrix
glGetDoublev( GL_PROJECTION_MATRIX, projection ); // Retrieve The Projection Matrix
glGetIntegerv( GL_VIEWPORT, viewport ); // Retrieves The Viewport Values (X, Y, Width, Height)
}
void display(void)
{
glLoadIdentity (); /* clear the matrix */
setCamera();
tbMatrix();
GLfloat currentColor[] = {1,1,0,1};
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, currentColor);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
drawModel1(false);
if (currMode == INVERSE)
{
glPushMatrix();
GLfloat pointColor[] = {1,1,1,1};
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, pointColor);
glTranslatef(targetPos(0), targetPos(1), targetPos(2));
glutSolidSphere(0.1, 20, 20);
glPopMatrix();
}
glFlush ();
glutSwapBuffers();
}
void specialKeys( int key, int x, int y )
{
switch(key)
{
case GLUT_KEY_UP:
if (currMode == FORWARD)
{
if (currentModel == MODEL1)
{
if (currentJoint1 == JOINT1) //&& joint1.rotation < 80)
joint1.rotation += 1;
else if (currentJoint1 == JOINT2) //&& joint2.rotation < 80)
joint2.rotation += 1;
else if (currentJoint1 == JOINT3) //&& joint3.rotation < 80)
joint3.rotation += 1;
else if (currentJoint1 == JOINT4) //&& joint4.rotation < 80)
joint4.rotation += 1;
}
else if (currentModel == MODEL2)
{
if (currentJoint2 == JOINT11) //&& joint11.rotation < 80)
joint11.rotation += 1;
else if (currentJoint2 == JOINT12) //&& joint12.rotation < 80)
{
joint12.rotation += 1;
}
else if (currentJoint2 == JOINT13) //&& joint13.rotation < 80)
joint13.rotation += 1;
else if (currentJoint2 == JOINT21) //&& joint21.rotation < 80)
joint21.rotation += 1;
else if (currentJoint2 == JOINT22) //&& joint22.rotation < 80)
joint22.rotation += 1;
else if (currentJoint2 == JOINT23) //&& joint23.rotation < 80)
joint23.rotation += 1;
else if (currentJoint2 == JOINT24) //&& joint24.rotation < 80)
joint24.rotation += 1;
else if (currentJoint2 == JOINT31) //&& joint31.rotation < 80)
joint31.rotation += 1;
else if (currentJoint2 == JOINT32) //&& joint32.rotation < 80)
joint32.rotation += 1;
else if (currentJoint2 == JOINT33) //&& joint33.rotation < 80)
joint33.rotation += 1;
else if (currentJoint2 == JOINT41) //&& joint41.rotation < 80)
joint41.rotation += 1;
else if (currentJoint2 == JOINT42) //&& joint42.rotation < 80)
joint42.rotation += 1;
else if (currentJoint2 == JOINT43) //&& joint43.rotation < 80)
joint43.rotation += 1;
else if (currentJoint2 == JOINT44) //&& joint44.rotation < 80)
joint44.rotation += 1;
else if (currentJoint2 == JOINT45) //&& joint45.rotation < 80)
joint45.rotation += 1;
}
glutPostRedisplay();
}
break;
case GLUT_KEY_DOWN:
if (currMode == FORWARD)
{
if (currentModel == MODEL1)
{
if (currentJoint1 == JOINT1) //&& joint1.rotation > -80)
joint1.rotation -= 1;
else if (currentJoint1 == JOINT2) //&& joint2.rotation > -80)
joint2.rotation -= 1;
else if (currentJoint1 == JOINT3) //&& joint3.rotation > -80)
joint3.rotation -= 1;
else if (currentJoint1 == JOINT4) //&& joint4.rotation > -80)
joint4.rotation -= 1;
}
else if (currentModel == MODEL2)
{
if (currentJoint2 == JOINT11) //&& joint11.rotation > -80)
joint11.rotation -= 1;
else if (currentJoint2 == JOINT12) //&& joint12.rotation > -80)
joint12.rotation -= 1;
else if (currentJoint2 == JOINT13) //&& joint13.rotation > -80)
joint13.rotation -= 1;
else if (currentJoint2 == JOINT21) //&& joint21.rotation > -80)
joint21.rotation -= 1;
else if (currentJoint2 == JOINT22) //&& joint22.rotation > -80)
joint22.rotation -= 1;
else if (currentJoint2 == JOINT23) //&& joint23.rotation > -80)
joint23.rotation -= 1;
else if (currentJoint2 == JOINT24) //&& joint24.rotation > -80)
joint24.rotation -= 1;
else if (currentJoint2 == JOINT31) //&& joint31.rotation > -80)
joint31.rotation -= 1;
else if (currentJoint2 == JOINT32) //&& joint32.rotation > -80)
joint32.rotation -= 1;
else if (currentJoint2 == JOINT33) //&& joint33.rotation > -80)
joint33.rotation -= 1;
else if (currentJoint2 == JOINT41) //&& joint41.rotation > -80)
joint41.rotation -= 1;
else if (currentJoint2 == JOINT42) //&& joint42.rotation > -80)
joint42.rotation -= 1;
else if (currentJoint2 == JOINT43) //&& joint43.rotation > -80)
joint43.rotation -= 1;
else if (currentJoint2 == JOINT44) //&& joint44.rotation > -80)
joint44.rotation -= 1;
else if (currentJoint2 == JOINT45) //&& joint45.rotation > -80)
joint45.rotation -= 1;
}
glutPostRedisplay();
}
break;
//case GLUT_KEY_LEFT:
//case GLUT_KEY_RIGHT:
}
}
void keyboard( unsigned char key, int x, int y )
{
switch(key)
{
case 27: // Escape key
exit(0);
break;
case 'r':
printf("save current screen\n");
screenshot.capture();
break;
case ' ': //Space bar
if (currMode == FORWARD)
{
currMode = INVERSE;
glutPostRedisplay();
//Update Current positions currentPos[5]
// glutTimerFunc(1000/FPS, timer, v);
}
else
currMode = FORWARD;
break;
case '1':
currentModel = MODEL1;
currentJoint1 = JOINT1;
glutPostRedisplay();
break;
case '2':
currentModel = MODEL2;
currentJoint2 = JOINT12;
glutPostRedisplay();
break;
case 'a':
if (currMode == INVERSE)
{
if (animating)
animating = false;
else
{
animating = true;
srand (time(NULL));
targetPos(0) = ((rand() % 2 == 0) ? -1 : 1) * (rand() % 8);
targetPos(1) = ((rand() % 2 == 0) ? -1 : 1) * (rand() % 8);
if (currentModel == MODEL2)
currIKChain = getClosestChain();
else
currIKChain = CHAIN1;
glutTimerFunc(1000/FPS, animatedTimer, 0);
}
animatePosGen = 0;
}
break;
}
}
// Got this from Nehe Gamedev Tutorials
Vector3f GetOGLPos(int x, int y)
{
GLint viewport[4];
GLdouble modelview[16];
GLdouble projection[16];
GLfloat winX, winY, winZ;
GLdouble posX, posY, posZ;
glGetDoublev( GL_MODELVIEW_MATRIX, modelview );
glGetDoublev( GL_PROJECTION_MATRIX, projection );
glGetIntegerv( GL_VIEWPORT, viewport );
winX = (float)x;
winY = (float)viewport[3] - (float)y;
glReadPixels( x, int(winY), 1.0, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ );
gluUnProject( winX, winY, winZ, modelview, projection, viewport, &posX, &posY, &posZ);
return Vector3f(posX, posY, posZ);
}
int selectedJoint(Node model, float prevAngle, Vector3f prevPos, Vector3f click)
{
float length = norm(model.joint->endPoint);
float angle = model.joint->rotation + prevAngle;
Vector3f tmp(length * cos(radian(angle)),length * sin(radian(angle)), model.joint->endPoint(2));
tmp += prevPos;
// if (model.children.size() > 0 && norm (click - tmp) < 0.1)
// return model.children[0].joint->selName;
if (norm (click - tmp) < 1.0)
return model.joint->selName;
else if (model.children.size() > 0)
{
return selectedJoint(model.children[0], angle, tmp, click);
}
else
{
return -1;
}
}
void resolveSelection (float x, float y)
{
Vector3f click(x, y, 0.0);
int selection = -1;
if (currentModel == MODEL1)
{
//if (norm (click) < 0.1)
//{
// currentJoint1 = JOINT1;
//}
//else
//{
selection = selectedJoint(model1, 0.0, Vector3f(0.0,0.0,0.0), click);
if (selection != -1)
currentJoint1 = selection;
//}
return;
}
else if (currentModel == MODEL2)
{
selection = selectedJoint(model2, 0.0, Vector3f(0.0,0.0,0.0), click);
if (selection != -1)
{
currentJoint2 = selection;
return;
}
selection = selectedJoint(model3, 0.0, Vector3f(0.0,0.0,0.0), click);
if (selection != -1)
{
currentJoint2 = selection;
return;
}
selection = selectedJoint(model4, 0.0, Vector3f(0.0,0.0,0.0), click);
if (selection != -1)
{
currentJoint2 = selection;
return;
}
selection = selectedJoint(model5, 0.0, Vector3f(0.0,0.0,0.0), click);
if (selection != -1)
{
currentJoint2 = selection;
return;
}
}
}
void mouse( int button, int state, int x, int y)
{
tbMouse(button, state, x, y);
if(button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
{
//processSelection(x, y);
Vector3f openGLCoord = GetOGLPos(x,y);
if (currMode == INVERSE && !animating)
{
targetPos(0) = (camZ / far) * openGLCoord(0);
targetPos(1) = (camZ / far) * openGLCoord(1);
if (currentModel == MODEL2)
currIKChain = getClosestChain();
else
currIKChain = CHAIN1;
glutTimerFunc(1000/FPS, timer, 0);
}
else if (currMode == FORWARD)
{
resolveSelection((camZ / far) * openGLCoord(0), (camZ / far) * openGLCoord(1));
}
}
if(button == GLUT_LEFT_BUTTON && state == GLUT_UP)
{
pickedObj = -1;
glutPostRedisplay();
}
}
void motion(int x, int y)
{
tbMotion(x, y);
GLfloat winX, winY, winZ;
GLdouble posX, posY, posZ;
winX = (float)x;
winY = (float)viewport[3] - (float)y;
glReadPixels( x, (int)winY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ );
gluUnProject( winX, winY, winZ, modelview, projection, viewport, &posX, &posY, &posZ);
glutPostRedisplay();
}
int main (int argc, char *argv[])
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize( winWidth, winHeight );
glutCreateWindow( "KINEMATICS" );
initModels();
setupRC();
glutDisplayFunc( display );
glutReshapeFunc( reshape );
glutKeyboardFunc( keyboard );
glutSpecialFunc( specialKeys );
glutMouseFunc( mouse );
glutMotionFunc( motion );
glutMainLoop();
}
| [
"rt2520@columbia.edu"
] | rt2520@columbia.edu |
152bf52eaf6597c561f6e9dbcd29fbc155c9fa3b | af9e3a456879e0d202a9a7901f0df94e4e865ad3 | /src/Definitions/ContinueStatement.cc | 6aaeefcfcf36ccd7c6e10d0f6e6a3290d12a24ad | [] | no_license | adisarip/DecafCompiler | 532661ddb5c2be304e056ef346f7886c3234d8fc | 93c323f8ab5e4b346c76a90c205908f1391c06ea | refs/heads/master | 2020-04-08T14:52:37.117298 | 2018-11-28T06:39:31 | 2018-11-28T06:39:31 | 159,455,353 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 217 | cc |
#include "ContinueStatement.hh"
using namespace std;
ContinueStatement::ContinueStatement()
{
mStmtType = Statement::NON_RETURNING;
}
void ContinueStatement::accept(Visitor& vParm)
{
vParm.visit(*this);
}
| [
"aditya.saripalli@students.iiit.ac.in"
] | aditya.saripalli@students.iiit.ac.in |
f78564f7b26a4e5dd87b5e51d3242175f05f43cf | c6b44ea783689299d27b9b4339c490dab75ebee0 | /include/fr/cards/poker_deck_factory.hpp | 1fb2e2fbb8c4462283c3b1c568aa640fcdf9f107 | [
"Apache-2.0"
] | permissive | FlyingRhenquest/cards | 8dd55f0c6ac32344c0a7a5a1118731692b31aea9 | 43fd4126171baaa71d04f0bdbc26ff998d46aee8 | refs/heads/master | 2020-09-03T03:41:15.071659 | 2019-11-03T23:00:26 | 2019-11-03T23:00:26 | 219,377,377 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,247 | hpp | /**
* Copyright 2019 Bruce Ide
*
* 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.
*
* Creates a poker deck.
*/
#include "deck.hpp"
#include <climits>
#include <tuple>
#include <vector>
#ifndef _HPP_FR_POKER_DECK_FACTORY
#define _HPP_FR_POKER_DECK_FACTORY
namespace fr {
namespace cards {
class poker_deck_factory {
public:
// Shifts for suites
const int hearts_shift = 0;
const int spades_shift = 16;
const int diamonds_shift = 32;
const int clubs_shift = 48;
// Masks for suites
const uint64_t hearts_mask = USHRT_MAX << hearts_shift;
const uint64_t spades_mask = USHRT_MAX << spades_shift;
const uint64_t diamonds_mask = USHRT_MAX << diamonds_shift;
const uint64_t clubs_mask = USHRT_MAX << clubs_shift;
static deck get()
{
deck retval;
std::vector<std::string> suites{"Hearts", "Spades", "Diamonds", "Clubs"};
std::vector<std::tuple<std::string, std::uint16_t>> values = {
{"Two", 2},
{"Three", 2 << 1},
{"Four", 2 << 2},
{"Five", 2 << 3},
{"Six", 2 << 4},
{"Seven", 2 << 5},
{"Eight", 2 << 6},
{"Nine", 2 << 7},
{"Ten", 2 << 8},
{"Jack", 2 << 9},
{"Queen", 2 << 10},
{"King", 2 << 11},
// Ace can be high or low for straights, so we'll set the low bit too.
{"Ace", (2 << 12) + 1}
};
int shift_val = 0;
for (auto suite : suites) {
for (auto [short_name, short_id] : values) {
std::string long_name(short_name);
long_name.append(" of ");
long_name.append(suite);
std::uint64_t long_id = short_id << shift_val;
retval.add(card(long_id, short_id, long_name));
}
shift_val += 16;
}
return retval;
}
};
}
}
#endif
| [
"FlyingRhenquest@gmail.com"
] | FlyingRhenquest@gmail.com |
32dc0f7ab88baab09bbedd89324135cca9745268 | 700dc494ce3461890dbc21451dbddca7f5ceded8 | /First and Follow - Q5/q5.cpp | 1417c0a5056bdab19a01151d58f6ab28b0563ec9 | [] | no_license | mauwazahmed/compilerDesignLab | fb618bbb21e562270c9564df3503a2952d617cde | 55d3e0ca3291b79af678c642bbd26cb48eabad73 | refs/heads/main | 2023-05-08T01:00:46.921304 | 2021-04-07T10:44:28 | 2021-04-07T10:44:28 | 369,991,700 | 1 | 0 | null | 2021-05-23T07:47:06 | 2021-05-23T07:47:05 | null | UTF-8 | C++ | false | false | 4,144 | cpp | #include <bits/stdc++.h>
using namespace std;
set<char> ss;
bool dfs(char i, char org, char last, map<char, vector<vector<char>>> &mp) {
bool rtake = false;
for (auto r : mp[i]) {
bool take = true;
for (auto s : r) {
if (s == i) break;
if (!take) break;
if (!(s >= 'A' && s <= 'Z') && s != '#') {
ss.insert(s);
break;
} else if (s == '#') {
if (org == i || i == last)
ss.insert(s);
rtake = true;
break;
} else {
take = dfs(s, org, r[r.size() - 1], mp);
rtake |= take;
}
}
}
return rtake;
}
int main() {
int i, j;
ifstream fin("input.txt");
string num;
vector<int> fs;
vector<vector<int>> a;
map<char, vector<vector<char>>> mp;
char start;
bool flag = 0;
while (getline(fin, num)) {
if (flag == 0) start = num[0], flag = 1;
vector<char> temp;
char s = num[0];
for (i = 3; i < num.size(); i++) {
if (num[i] == '|') {
mp[s].push_back(temp);
temp.clear();
} else
temp.push_back(num[i]);
}
mp[s].push_back(temp);
}
map<char, set<char>> fmp;
for (auto q : mp) {
ss.clear();
dfs(q.first, q.first, q.first, mp);
for (auto g : ss) fmp[q.first].insert(g);
}
cout << '\n';
cout << "Firsts: " << '\n';
for (auto q : fmp) {
string ans = "";
ans += q.first;
ans += " = ";
for (char r : q.second) {
ans += r;
ans += ", ";
}
ans.pop_back();
cout << ans << '\n';
}
map<char, set<char>> gmp;
gmp[start].insert('$');
int count = 10;
while (count--) {
for (auto q : mp) {
for (auto r : q.second) {
for (i = 0; i < r.size() - 1; i++) {
if (r[i] >= 'A' && r[i] <= 'Z') {
if (!(r[i + 1] >= 'A' && r[i + 1] <= 'Z'))
gmp[r[i]].insert(r[i + 1]);
else {
char temp = r[i + 1];
int j = i + 1;
while (temp >= 'A' && temp <= 'Z') {
if (*fmp[temp].begin() == '#') {
for (auto g : fmp[temp]) {
if (g == '#') continue;
gmp[r[i]].insert(g);
}
j++;
if (j < r.size()) {
temp = r[j];
if (!(temp >= 'A' && temp <= 'Z')) {
gmp[r[i]].insert(temp);
break;
}
} else {
for (auto g : gmp[q.first]) gmp[r[i]].insert(g);
break;
}
} else {
for (auto g : fmp[temp]) {
gmp[r[i]].insert(g);
}
break;
}
}
}
}
}
if (r[r.size() - 1] >= 'A' && r[r.size() - 1] <= 'Z') {
for (auto g : gmp[q.first]) gmp[r[i]].insert(g);
}
}
}
}
cout << '\n';
cout << "Follows: " << '\n';
for (auto q : gmp) {
string ans = "";
ans += q.first;
ans += " = ";
for (char r : q.second) {
ans += r;
ans += ", ";
}
ans.pop_back();
cout << ans << '\n';
}
return 0;
} | [
"thatazimjaved@gmail.com"
] | thatazimjaved@gmail.com |
bd72843887c3b62108300bbae589207949ab7cd6 | 3cf73d4ec1e9bd0cfeebb0de3775e5553530efe2 | /USER-OMP/angle_cosine_squared_omp.cpp | e8eaff6b2a70dcb07d5aea400a2649722a9538f9 | [] | no_license | TJFord/sard | 49766cb2f72610ae60319e9ed73b712f0c05e66a | 6697819f47d5e28b60d36183a65b5b95a725b6b1 | refs/heads/master | 2016-09-06T09:58:00.641931 | 2014-06-28T02:57:51 | 2014-06-28T02:57:51 | 10,278,164 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,558 | cpp | /* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
/* ----------------------------------------------------------------------
Contributing author: Axel Kohlmeyer (Temple U)
------------------------------------------------------------------------- */
#include "angle_cosine_squared_omp.h"
#include "atom.h"
#include "comm.h"
#include "force.h"
#include "neighbor.h"
#include "domain.h"
#include "math_const.h"
#include <math.h>
#include "suffix.h"
using namespace LAMMPS_NS;
using namespace MathConst;
#define SMALL 0.001
/* ---------------------------------------------------------------------- */
AngleCosineSquaredOMP::AngleCosineSquaredOMP(class LAMMPS *lmp)
: AngleCosineSquared(lmp), ThrOMP(lmp,THR_ANGLE)
{
suffix_flag |= Suffix::OMP;
}
/* ---------------------------------------------------------------------- */
void AngleCosineSquaredOMP::compute(int eflag, int vflag)
{
if (eflag || vflag) {
ev_setup(eflag,vflag);
} else evflag = 0;
const int nall = atom->nlocal + atom->nghost;
const int nthreads = comm->nthreads;
const int inum = neighbor->nanglelist;
#if defined(_OPENMP)
#pragma omp parallel default(none) shared(eflag,vflag)
#endif
{
int ifrom, ito, tid;
loop_setup_thr(ifrom, ito, tid, inum, nthreads);
ThrData *thr = fix->get_thr(tid);
ev_setup_thr(eflag, vflag, nall, eatom, vatom, thr);
if (evflag) {
if (eflag) {
if (force->newton_bond) eval<1,1,1>(ifrom, ito, thr);
else eval<1,1,0>(ifrom, ito, thr);
} else {
if (force->newton_bond) eval<1,0,1>(ifrom, ito, thr);
else eval<1,0,0>(ifrom, ito, thr);
}
} else {
if (force->newton_bond) eval<0,0,1>(ifrom, ito, thr);
else eval<0,0,0>(ifrom, ito, thr);
}
reduce_thr(this, eflag, vflag, thr);
} // end of omp parallel region
}
template <int EVFLAG, int EFLAG, int NEWTON_BOND>
void AngleCosineSquaredOMP::eval(int nfrom, int nto, ThrData * const thr)
{
int i1,i2,i3,n,type;
double delx1,dely1,delz1,delx2,dely2,delz2;
double eangle,f1[3],f3[3];
double dcostheta,tk;
double rsq1,rsq2,r1,r2,c,a,a11,a12,a22;
const double * const * const x = atom->x;
double * const * const f = thr->get_f();
const int * const * const anglelist = neighbor->anglelist;
const int nlocal = atom->nlocal;
for (n = nfrom; n < nto; n++) {
i1 = anglelist[n][0];
i2 = anglelist[n][1];
i3 = anglelist[n][2];
type = anglelist[n][3];
// 1st bond
delx1 = x[i1][0] - x[i2][0];
dely1 = x[i1][1] - x[i2][1];
delz1 = x[i1][2] - x[i2][2];
rsq1 = delx1*delx1 + dely1*dely1 + delz1*delz1;
r1 = sqrt(rsq1);
// 2nd bond
delx2 = x[i3][0] - x[i2][0];
dely2 = x[i3][1] - x[i2][1];
delz2 = x[i3][2] - x[i2][2];
rsq2 = delx2*delx2 + dely2*dely2 + delz2*delz2;
r2 = sqrt(rsq2);
// angle (cos and sin)
c = delx1*delx2 + dely1*dely2 + delz1*delz2;
c /= r1*r2;
if (c > 1.0) c = 1.0;
if (c < -1.0) c = -1.0;
// force & energy
dcostheta = c - cos(theta0[type]);
tk = k[type] * dcostheta;
if (EFLAG) eangle = tk*dcostheta;
a = 2.0 * tk;
a11 = a*c / rsq1;
a12 = -a / (r1*r2);
a22 = a*c / rsq2;
f1[0] = a11*delx1 + a12*delx2;
f1[1] = a11*dely1 + a12*dely2;
f1[2] = a11*delz1 + a12*delz2;
f3[0] = a22*delx2 + a12*delx1;
f3[1] = a22*dely2 + a12*dely1;
f3[2] = a22*delz2 + a12*delz1;
// apply force to each of 3 atoms
if (NEWTON_BOND || i1 < nlocal) {
f[i1][0] += f1[0];
f[i1][1] += f1[1];
f[i1][2] += f1[2];
}
if (NEWTON_BOND || i2 < nlocal) {
f[i2][0] -= f1[0] + f3[0];
f[i2][1] -= f1[1] + f3[1];
f[i2][2] -= f1[2] + f3[2];
}
if (NEWTON_BOND || i3 < nlocal) {
f[i3][0] += f3[0];
f[i3][1] += f3[1];
f[i3][2] += f3[2];
}
if (EVFLAG) ev_tally_thr(this,i1,i2,i3,nlocal,NEWTON_BOND,eangle,f1,f3,
delx1,dely1,delz1,delx2,dely2,delz2,thr);
}
}
| [
"tan.jifu@gmail.com"
] | tan.jifu@gmail.com |
40eda8466c0f9ceb0f3d1cca8c843248a701bf9d | 449ae14862d9803277babe446f7f030fe9b0f15e | /p2/tags/RELEASE_0_6/python/p2/p2core/val_time.cpp | 6314c7c794b6ba47494f7ae35598668bf5288b35 | [] | no_license | declarativitydotnet/declarativity | 863ea58bed1c0efc57573d75b73e0006eca3f280 | 75096fb78264c517cd00e8486467c010038434cb | refs/heads/master | 2021-01-10T11:58:00.700630 | 2015-12-08T17:44:39 | 2015-12-08T17:44:39 | 47,607,520 | 9 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 415 | cpp | #include <val_time.h>
#include <boost/python.hpp>
using namespace boost::python;
ValuePtr (*mk_ptime)(boost::posix_time::ptime) = &Val_Time::mk;
ValuePtr (*mk_timespec)(struct timespec) = &Val_Time::mk;
void export_val_time()
{
class_<Val_Time, bases<Value>, boost::shared_ptr<Val_Time> >
("Val_Time", no_init)
.def("mk", mk_ptime)
.def("mk", mk_timespec)
.staticmethod("mk")
;
}
| [
"(no author)"
] | (no author) |
83ccefde0779bb1f0755bd50380bb21428a54f9a | 771cc29cd1263dc999f57cad23cc49cc35d43d99 | /abstractbeatinterval.cpp | bbcafa0f1019f0588da120c0f4427ddcc54bdce2 | [
"Artistic-2.0"
] | permissive | BadassBaal/cock-heroine | 6e1eecd92b3726187e6665bcaaeafb1510ffcdad | e5da101c97e5a35447c32a9c46da5a4e657ea4b9 | refs/heads/master | 2023-06-20T10:18:01.104375 | 2021-07-20T09:33:09 | 2021-07-20T09:33:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,995 | cpp | #include "abstractbeatinterval.h"
#include "helperfunctions.h"
#include <QDebug>
#include <float.h>
#include "config.h"
#include "globals.h"
AbstractBeatInterval::AbstractBeatInterval()
{
}
AbstractBeatInterval::~AbstractBeatInterval()
{
}
bool AbstractBeatInterval::matchesThisInterval(int otherInterval) const
{
return isWithinXPercentOf(getLength(),otherInterval,BeatAnalysis::Configuration::maxPercentAcceptableBeatError);
}
bool AbstractBeatInterval::matchesThisInterval(AbstractBeatInterval &otherInterval) const
{
return matchesThisInterval(otherInterval.getLength());
}
bool AbstractBeatInterval::matchesThisInterval(BeatValue & otherValue) const
{
return matchesThisInterval(roundToInt(otherValue.getLength()));
}
void AbstractBeatInterval::calculateValue() const
{
if (beatValues.size() == 0)
{
qDebug() << "Error: Trying to calculate value of interval before beat values are initialised!";
value = 0;
return;
}
if (BeatAnalysis::Configuration::tempoEstablished == false)
{
qDebug() << "Error: Trying to calculate value of interval before tempo is calculated!";
value = 0;
return;
}
int i = 0;
float valueDifference = 100.0;
for (i = 0; i < beatValues.size(); ++i)
{
if (beatValues.at(i).active &&
percentageDifferenceBetween(beatValues.at(i).value() * BeatAnalysis::Configuration::tempoInterval(),getLength()) < valueDifference)
{
valueDifference = percentageDifferenceBetween(beatValues.at(i).value() * BeatAnalysis::Configuration::tempoInterval(),getLength());
value = &beatValues.at(i);
}
}
}
float AbstractBeatInterval::deviationFromNearestKnownBeatValue() const
{
if ( ! value )
calculateValue();
if ( ! value )
return FLT_MAX;
return percentageDifferenceBetween(value->getLength(),getLength());
}
float AbstractBeatInterval::absoluteDifferenceFromNearestKnownBeatValue() const
{
if ( ! value )
calculateValue();
if ( ! value )
return FLT_MAX;
return absoluteDifferenceBetween(value->getLength(), getLength());
}
bool AbstractBeatInterval::isKnownBeatValue() const
{
bool acceptableProportion = (deviationFromNearestKnownBeatValue() <= BeatAnalysis::Configuration::maxPercentAcceptableBeatError);
if (!acceptableProportion)
return false; //return early as access to 'value->' below may NPE in this case
float absoluteDifference = absoluteDifferenceFromNearestKnownBeatValue();
float partialBeatLength = BeatAnalysis::Configuration::tempoInterval() / (BeatAnalysis::Configuration::allowHalfBeatsInBreaks ? 4.0 : 2.0);
bool acceptableError = absoluteDifference <= partialBeatLength;
return acceptableError; // && acceptableProportion (we wouldn't be here otherwise)
}
BeatValue const * AbstractBeatInterval::getValue() const
{
if (isKnownBeatValue())
return value;
else
return NULL;
}
| [
"megamasha@gmail.com"
] | megamasha@gmail.com |
50b50a52ccc0697c6f92c154e83915d4a125c56a | 45ca4ef13e50719548db781333a8cf1794cdac6d | /NCSG/NCSG.cpp | 60cb35e5fa4f4c81c95938292e6476969702e9c6 | [] | no_license | JackJinWang/NCSG | d9f6b32d82f69bed94c6ac1ef1c9c6a0e64e8bb1 | 99a27edb3d8fb39ac5a523cd704543128f5d75c6 | refs/heads/master | 2021-07-21T06:21:16.941884 | 2017-10-31T03:11:54 | 2017-10-31T03:11:54 | 108,935,306 | 2 | 0 | null | null | null | null | GB18030 | C++ | false | false | 21,972 | cpp | #include"NCSG.h"
#include<iostream>
#include<limits.h>
using namespace std;
const int NOSUCCESSOR = INT_MAX;
NCSG::NCSG(int dimension, int number_character, vector<int **>st)
{
this->dimension = dimension;
this->number_character = number_character;
this->st = st;
}
void NCSG::getDominant()
{
// vector<int *> k_th_dominant;
// int index = 0; //DM表序号
int *source_point = new int[dimension];
for (int i = 0; i < dimension; i++)
{
source_point[i] = 0;
}
DM dm(index,source_point,dimension);
this->V.push_back(dm); //加入到边集合
// k_th_dominant.push_back(source_point); //加入（0，。。。0）点
// dominants.push_back(k_th_dominant);
// st_temp[i][j][k] i表示第几个序列 j表示序列第几个字符 k表示序列的第几列
// vector<int *> first_th_dominant;
for (int i = 0; i < number_character; i++)
{
int *point = new int[dimension];
for (int j = 0; j < dimension; j++)
point[j] = st[j][i][0];
index++;
DM dm(index, point, dimension);
this->V.push_back(dm); //加入到边集合
getAllDominant(point);
// first_th_dominant.push_back(point);
}
// dominants.push_back(first_th_dominant);
}
void NCSG::getAllDominant(int *inpoint)
{
if (!haveSuccessor(inpoint)) //无后继终止递归
return;
for (int i = 0; i < number_character; i++)
{
int *point = new int[dimension];
for (int j = 0; j < dimension; j++)
{
int number = inpoint[j];
point[j] = st[j][i][number];
}
if (!isInDM(point)&&isSuccessor(point))
{
index++;
DM dm(index, point, dimension);
this->V.push_back(dm); //加入到边集合
// cout <<"输出位置"<< index<<endl;
getAllDominant(point); //递归求解
}
}
}
void NCSG::buildNCSG()
{
ncsgindex = 0;
int size = V.size()+1; //加入汇点（无穷点）
number_dominant = size;
E = new int*[size];
for (int i = 0; i < size; i++)
E[i] = new int[size];
//初始化E矩阵
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
E[i][j] = 0;
}
}
//构造d0与d1；
int *source_point = new int[dimension];
for (int i = 0; i < dimension; i++)
{
source_point[i] = 0;
}
V.clear();
DM dm(ncsgindex, source_point, dimension);
this->V.push_back(dm); //加入到边集合
for (int i = 0; i < number_character; i++)
{
int *point = new int[dimension];
for (int j = 0; j < dimension; j++)
point[j] = st[j][i][0];
ncsgindex++;
E[0][ncsgindex] = 1;
DM dm(ncsgindex, point, dimension);
this->V.push_back(dm);
buildAllNCSG(point, ncsgindex);
// first_th_dominant.push_back(point);
}
}
void NCSG::buildAllNCSG(int *inpoint,int inindex)
{
if (!haveSuccessor(inpoint) && isSuccessor(inpoint)) //无后继终止递归,//如果不存在后嵇点与汇点相连
{
E[inindex][number_dominant - 1] = 1;
return;
}
for (int i = 0; i < number_character; i++)
{
int *point = new int[dimension];
for (int j = 0; j < dimension; j++)
{
int number = inpoint[j];
point[j] = st[j][i][number];
}
//如果不存在加入点
if (!isInDM(point) && isSuccessor(point))
{
ncsgindex++;
E[inindex][ncsgindex] = 1;
DM dm(ncsgindex, point, dimension);
this->V.push_back(dm); //加入到边集合
buildAllNCSG(point, ncsgindex); //递归求解
}else if (isInDM(point) && isSuccessor(point))
{
//如果存在边相连
/*
cout << "******************" << endl;
cout << "已存在" << endl;
cout << "前驱点" << endl;
for (int j = 0; j < dimension; j++)
{
cout<<inpoint[j]<<" ";
}
cout << endl;
cout << "后继点" << endl;
for (int j = 0; j < dimension; j++)
{
cout << point[j] << " ";
}
this->show();
cout <<"******************"<<endl;
*/
//找到存在点的序号
int exitnumber = getPointIndex(point);
E[inindex][exitnumber] = 1;
// buildAllNCSG(point, ncsgindex); //递归求解
}
}
}
void NCSG::forwardTopSort()
{
int levelnum = -1;
//初始化矩阵
vector<int> dominatindex; //将dominant序列放入
k_level_forward = new int[number_dominant];
for (int i = 0; i < number_dominant; i++)
{
dominatindex.push_back(i);
}
int **tempE;
tempE = new int*[number_dominant];
topsort = new int*[number_dominant];
for (int i = 0; i < number_dominant; i++)
{
topsort[i] = new int[number_dominant];
tempE[i] = new int[number_dominant];
}
for (int i = 0; i < number_dominant; i++)
{
for (int j = 0; j < number_dominant; j++)
{
tempE[i][j] = E[i][j];
topsort[i][j] = E[i][j];
}
}
//不断删除入度为0的点
//计算入度放入indegeree
while (dominatindex.size() > 0)
{
vector<int> k_level; //存放index;
//计算入度
int flag = 0; //退出时删除点
for (int i = 0; i < dominatindex.size(); i++)
{
int count = dominatindex[i];
int sum = 0;
//计算入度
for (int j = 0; j < number_dominant; j++)
{
sum = sum + tempE[j][count];
}
//入度为0则存入级别
if (sum == 0)
{
k_level_forward[count] = levelnum + 1;
k_level.push_back(count);
}
}
k_dominants.push_back(k_level);
levelnum++;
//删除入度为0点
for (int i = 0; i < k_level.size(); i++)
{
int count = k_level[i];
vector <int>::iterator Iter;
Iter = dominatindex.begin();
while (Iter != dominatindex.end())
{
if (count == *Iter)
{
dominatindex.erase(Iter);
Iter = dominatindex.begin();
//如果删除点与前向点有关系则需构建图
vector<int> record;
for (int i = 0; i < number_dominant; i++)
{
if (E[i][count] == 1)
record.push_back(i);
}
for (int i = 0; i < record.size(); i++)
{
for (int j = i + 1; j < record.size(); j++)
{
int number1 = record[i];
int number2 = record[j];
if (E[number1][number2] == 1)
{
topsort[number1][count] = 0;
}
if (E[number2][number1] == 1)
{
topsort[number2][count] = 0;
}
}
}
break;
}
else
++Iter;
}
//更改矩阵删除边
for (int j = 0; j < number_dominant; j++)
{
tempE[count][j] = 0;
}
}
}
MAX_LEVEL = levelnum;
//跨级别边删除
for (int i = 0; i < number_dominant; i++)
{
for (int j = 0; j < number_dominant; j++)
{
if ((topsort[i][j] == 1) && (j != number_dominant - 1) && ((k_level_forward[j] - k_level_forward[i])>1))
topsort[i][j] = 0;
}
}
int number = 0;
for (int i = 0; i < number_dominant; i++)
{
number = 0;
for (int j = 0; j < number_dominant; j++)
{
if (topsort[i][j] == 1)
break;
else
number++;
}
if (number == number_dominant)
for (int j = 0; j < number_dominant; j++)
{
topsort[i][j] = E[i][j];
}
}
for (int i = 0; i < number_dominant; i++)
{
delete[] tempE[i];
}
delete[] tempE;
}
void NCSG::backTopSort()
{
backsort = new int*[number_dominant];
for (int i = 0; i < number_dominant; i++)
{
backsort[i] = new int[number_dominant];
}
//拓扑矩阵赋值
for (int i = 0; i < number_dominant; i++)
{
for (int j = 0; j < number_dominant; j++)
{
backsort[i][j] = topsort[i][j];
}
}
//拓扑矩阵反向求路径
for (int i = 0; i < number_dominant; i++)
{
for (int j = 0; j < i; j++)
{
int temp = backsort[i][j];
backsort[i][j] = backsort[j][i];
backsort[j][i] = temp;
}
}
//后向拓扑排序
int levelnum = -1;
k_level_backward = new int[number_dominant];
//初始化矩阵
vector<int> dominatindex; //将dominant序列放入
for (int i = 0; i < number_dominant; i++)
{
dominatindex.push_back(i);
}
int **tempE;
tempE = new int*[number_dominant];
for (int i = 0; i < number_dominant; i++)
{
tempE[i] = new int[number_dominant];
}
for (int i = 0; i < number_dominant; i++)
{
for (int j = 0; j < number_dominant; j++)
{
tempE[i][j] = backsort[i][j];
}
}
//不断删除入度为0的点
//计算入度放入indegeree
while (dominatindex.size() > 0)
{
vector<int> k_level; //存放index;
//计算入度
int flag = 0; //退出时删除点
for (int i = 0; i < dominatindex.size(); i++)
{
int count = dominatindex[i];
int sum = 0;
//计算入度
for (int j = 0; j < number_dominant; j++)
{
sum = sum + tempE[j][count];
}
//入度为0则存入级别
if (sum == 0)
{
k_level.push_back(count);
k_level_backward[count] = levelnum + 1;
}
}
k_dominants_back.push_back(k_level);
levelnum++;
//删除入度为0点
for (int i = 0; i < k_level.size(); i++)
{
int count = k_level[i];
vector <int>::iterator Iter;
Iter = dominatindex.begin();
while (Iter != dominatindex.end())
{
if (count == *Iter)
{
dominatindex.erase(Iter);
Iter = dominatindex.begin();
//如果删除点与前向点有关系则需构建图
vector<int> record;
for (int i = 0; i < number_dominant; i++)
{
if (E[i][count] == 1)
record.push_back(i);
}
for (int i = 0; i < record.size(); i++)
{
for (int j = i + 1; j < record.size(); j++)
{
int number1 = record[i];
int number2 = record[j];
if (E[number1][number2] == 1)
{
topsort[number1][count] = 0;
}
if (E[number2][number1] == 1)
{
topsort[number2][count] = 0;
}
}
}
break;
}
else
++Iter;
}
//更改矩阵删除边
for (int j = 0; j < number_dominant; j++)
{
tempE[count][j] = 0;
}
}
}
//判断前向后巷相加不为最大层级删除
for (int i = 0; i < number_dominant; i++)
{
if ((k_level_backward[i] + k_level_forward[i]) != MAX_LEVEL)
{
delete_point_back.push_back(i);
}
}
//构造后巷图
for (int i = 0; i < delete_point_back.size(); i++)
{
for (int j = 0; j < number_dominant; j++)
{
backsort[j][delete_point_back[i]] = 0;
backsort[delete_point_back[i]][j] = 0;
}
}
for (int i = 0; i < number_dominant; i++)
{
delete[] tempE[i];
}
delete[] tempE;
}
void NCSG::getPath()
{
//拓扑矩阵反向求路径
for (int i = 0; i < number_dominant; i++)
{
for (int j = 0; j < i; j++)
{
int temp = backsort[i][j];
backsort[i][j] = backsort[j][i];
backsort[j][i] = temp;
}
}
state_isstack = new int[number_dominant];
for (int i = 0; i < number_dominant; i++)
{
state_isstack[i] = 0;
}
// state_isstack[0] = 1;
// stack.push_back(0);
// searchPath(0);
search();
}
void NCSG::setString(string *T,int number)
{
this->T = new string[number];
for (int i = 0; i < number; i++)
{
this->T[i] = T[i];
}
}
void NCSG::search()
{
int **tempE;
tempE = new int*[number_dominant];
for (int i = 0; i < number_dominant; i++)
{
tempE[i] = new int[number_dominant];
}
for (int i = 0; i < number_dominant; i++)
{
for (int j = 0; j < number_dominant; j++)
{
tempE[i][j] = 0;
}
}
stack.push_back(0);
state_isstack[0] = 1;
while(!stack.empty())
{
int elem = stack[stack.size()-1];//获得栈顶元素
if (elem == number_dominant - 1)//找到了一条路径
{
// path = Traverse(mystack);
// if (stack.size() == MAX_LEVEL + 1)
// {
for (int i = 0; i < stack.size(); i++)
{
singlePath.push_back(stack[i]);
if (stack[i] == 0)
cout << 0 << "->";
else if (stack[i] == number_dominant - 1)
cout << "终点" << "->";
else
{
int show_number = (V[stack[i]].getPoint())[0];
char show = T[0][show_number - 1];
cout << show << "(" << stack[i] << ")" << "->";
}
}
cout << endl;
allPath.push_back(singlePath);
// }
state_isstack[elem] = 0;
for (int i = 0; i < number_dominant; i++)
{
if ((backsort[elem][i] == 1) && (state_isstack[i] == 0))
{
tempE[elem][i] = 0;
}
if ((backsort[i][elem] == 1) && (state_isstack[i] == 0))
{
tempE[i][elem] = 0;
}
}
// UpdateArcStatus();//更新ArcStatus[][]，使得所有两个端点都不在栈内的边的状态为0
stack.pop_back();//移除栈顶元素
}
else
{
int i = 0;
for (; i < number_dominant; i++)
{
if( (state_isstack[i] == 0) && (tempE[elem][i] == 0 )&& (backsort[elem][i]==1))
{
state_isstack[i] = 1;
tempE[elem][i] = 1;
stack.push_back(i);//入栈
break;
}
}
if (i == number_dominant)//该节点没有符合要求的后续节点
{
state_isstack[elem] = 0;
for (int i = 0; i < number_dominant; i++)
{
if ((backsort[elem][i] == 1) && (state_isstack[i] == 0))
{
tempE[elem][i] = 0;
}
if ((backsort[i][elem] == 1) && (state_isstack[i] == 0))
{
tempE[i][elem] = 0;
}
}
// UpdateArcStaus();////更新ArcStatus[][]，使得所有两个端点都不在栈内的边的状为0
stack.pop_back();//出栈
}
}
}
for (int i = 0; i < number_dominant; i++)
{
delete[] tempE[i];
}
delete[] tempE;
}
void NCSG::searchPath(int precursor)
{
if (stack.size() == 0)
return;
if (precursor == number_dominant - 1)
{
if (stack[0] == 0)
{
for (int i = 0; i < stack.size(); i++)
{
if (stack[i] ==0)
cout << 0 << "->";
else if (stack[i]==number_dominant -1 )
cout << "终点" << "->";
else
{
int show_number = (V[stack[i]].getPoint())[0];
char show = T[0][show_number - 1];
cout << show << "->";
}
}
cout << endl;
}
state_isstack[stack[stack.size()-1]] = 0;
int top_first = stack[stack.size() - 1];
stack.pop_back();
while (stack.size()>0)
{
int top = stack[stack.size()-1];
int flag = 0;
for (int i = 0; i < number_dominant; i++)
{
if ((backsort[top][i] == 1) && (i != top_first) && (state_isstack[i] == 0))
{
stack.push_back(i);
state_isstack[i] = 1;
searchPath(i);
break;
}
flag++;
}
if (flag == number_dominant)
{
top_first = stack[stack.size() - 1];
if (stack.size() > 1)
{
int top_second = stack[stack.size() - 2];
int i;
for (i = 0; i < number_dominant; i++)
{
if ((backsort[top_second][i] == 1) && (state_isstack[i] == 0) && (i != top_first))
{
state_isstack[top_first] = 1;
break;
}
}
if (i == number_dominant)
state_isstack[top] = 0;
}
stack.pop_back();
}
}
return;
}
for (int i = 0; i < number_dominant; i++)
{
if ((backsort[precursor][i] == 1) && (state_isstack[i])==0)
{
state_isstack[i] = 1;
stack.push_back(i);
searchPath(i);
}
}
}
void NCSG::getAllPath(int precursor)
{
vector<int> path;
int **tempBcak;//用以标记走过的路径
tempBcak = new int*[number_dominant];
for (int i = 0; i < number_dominant; i++)
{
tempBcak[i] = new int[number_dominant];
}
for (int i = 0; i < number_dominant; i++)
{
for (int j = 0; j < number_dominant; j++)
{
tempBcak[i][j] = 0;
}
}
//拓扑矩阵反向求路径
for (int i = 0; i < number_dominant; i++)
{
for (int j = 0; j < i; j++)
{
int temp = backsort[i][j];
backsort[i][j] = backsort[j][i];
backsort[j][i] = temp;
}
}
int *outdegree; //计算出度表
outdegree = new int[number_dominant];
for (int i = 0; i < number_dominant; i++)
{
int sum = 0;
for (int j = 0; j < number_dominant; j++)
{
sum = sum + backsort[i][j];
outdegree[i] = sum;
}
}
int flag = 0;
for (int j = 0; j < number_dominant; j++)
{
if ((backsort[precursor][j] == 1) && (tempBcak[precursor][j])==0)
{
path.push_back(j);
if (outdegree[precursor]>1)
{
tempBcak[precursor][j] == 1;
}
outdegree[precursor] = outdegree[precursor] - 1;
getAllPath(j);
}
else
flag++;
}
if (flag == number_dominant)
{
for (int i = 0; i < path.size(); i++)
{
cout << path[i] << "->";
}
cout << endl;
while (path.size()>0)
{
}
return;
}
}
int NCSG::getPointIndex(int *point)
{
int size = V.size();
int flag = 0;
for (int i = 0; i < size; i++)
{
flag = 0;
for (int j = 0; j < dimension; j++)
{
if ((V[i].getPoint())[j] == point[j])
flag++;
}
if (flag == dimension)
{
/*
cout << V[i].getIndex()<<":"<<endl;
for (int f = 0; f < dimension; f++)
{
cout << (V[i].getPoint())[f] << " ";
}
cout << endl;
cout << "传入点:" << endl;
for (int f = 0; f < dimension; f++)
{
cout << point[f] << " ";
}
cout << endl;
*/
return V[i].getIndex();
}
}
return INT_MAX;
}
bool NCSG::isSuccessor(int *point)
{
int flag = 0;
for (int i = 0; i < dimension; i++)
{
if (point[i] == NOSUCCESSOR)
return false;
}
return true;
}
//判断是否有后继点
bool NCSG::haveSuccessor(int *point)
{
// vector<int*> successor;
int flag = 0;
bool remember;//是否是后继点 是存储 不是
for (int i = 0; i < number_character; i++)
{
remember = true;
int *temp_point;
// cout << "i:" << i << endl;
for (int j = 0; j < dimension; j++)
{
temp_point = new int[dimension];
int number = point[j];
temp_point[j] = st[j][i][number];
if (temp_point[j] == NOSUCCESSOR)
{
remember = false;
flag++;
break;
}
// cout << temp_point[j] << " ";
}
cout << endl;
// if (remember)
// successor.push_back(temp_point);
}
if (flag == number_character)
return false;
else
return true;
}
bool NCSG::isInDM(int *point)
{
DM temp_dm;
int flag = 0;
for (int i = 0; i < V.size(); i++)
{
flag = 0;
temp_dm = V[i];
for (int j = 0; j < dimension; j++)
{
if (point[j] == (temp_dm.getPoint())[j])
flag++;
}
if (flag == dimension)
return true;
}
return false;
}
void NCSG::show()
{
cout << "********************分层结果****************" << endl;
int number = k_dominants.size();
for (int i = 0; i < number; i++)
{
cout << i << "-th" << endl;
int queuenumber = k_dominants[i].size();
for (int j = 0; j < queuenumber; j++)
{
cout << k_dominants[i][j]<< " ";
cout << endl;
}
}
cout << "********************DM索引表结果****************" << endl;
cout << "DM" << endl;
for (int i = 0; i < V.size(); i++)
{
cout << V[i].getIndex()<<",";
for (int j = 0; j < dimension; j++)
{
cout << (V[i].getPoint())[j] << " ";
}
cout << endl;
}
cout << "********************NCSG图****************" << endl;
cout << "NCSG" << endl;
int size = V.size() + 1; //加入汇点（无穷点）
//初始化E矩阵
cout << 0 << ":";
for (int j = 0; j < size; j++)
{
if (j>10)
cout << j<<" ";
else
cout << j << " ";
}
cout << endl;
int sum = 0;
for (int i = 0; i < size; i++)
{
cout << i << ":";
for (int j = 0; j < size; j++)
{
sum = sum + E[i][j];
cout <<E[i][j] <<" ";
}
cout << endl;
}
cout << "边的总数为" << sum<<endl;
sum = 0;
cout << "********************前向拓扑排序结果及图****************" << endl;
cout << "forwordsortNCSG" << endl;
//初始化E矩阵
cout << 0 << ":";
for (int j = 0; j < size; j++)
{
if (j>10)
cout << j << " ";
else
cout << j << " ";
}
cout << endl;
for (int i = 0; i < size; i++)
{
cout << i << ":";
for (int j = 0; j < size; j++)
{
sum = sum + topsort[i][j];
cout << topsort[i][j] << " ";
}
cout << endl;
}
cout << "边的总数为" << sum << endl;
sum = 0;
cout << "********************后向拓扑排序结果及图****************" << endl;
cout << "backsortNCSG" << endl;
//初始化E矩阵
cout << 0 << ":";
int flag = 0;
for (int j = 0; j < size; j++)
{
flag = 0;
for (int i = 0; i < delete_point_back.size(); i++)
{
if (delete_point_back[i] == j)
flag = 1;
}
if (flag == 1)
continue;
if (j>10)
cout << j << " ";
else
cout << j << " ";
}
cout << endl;
for (int i = 0; i < size; i++)
{
flag = 0;
for (int k = 0; k < delete_point_back.size(); k++)
{
if (delete_point_back[k] == i)
flag = 1;
}
if (flag == 1)
continue;
cout << i << ":";
for (int j = 0; j < size; j++)
{
flag = 0;
for (int k = 0; k < delete_point_back.size(); k++)
{
if (delete_point_back[k] == j)
flag = 1;
}
if (flag == 1)
continue;
sum = sum + backsort[i][j];
cout << backsort[i][j] << " ";
}
cout << endl;
}
cout << "边的总数为" << sum << endl;
cout << "********************前向拓扑排序每点的级别****************" << endl;
cout << "前向级别" << endl;
for (int i = 0; i < number_dominant; i++)
{
cout << k_level_forward[i]<<" ";
}
cout << endl;
cout << "********************后向拓扑排序每点级别****************" << endl;
cout << "后向级别" << endl;
for (int i = 0; i < number_dominant; i++)
{
cout << k_level_backward[i] << " ";
}
cout << endl;
cout << "********************后向拓扑排序删除的点****************" << endl;
cout << "后序删除的点" << endl;
for (int i = 0; i < delete_point_back.size(); i++)
{
cout << delete_point_back[i] << " ";
}
}
NCSG::~NCSG()
{
if (T!=nullptr)
{
delete[]T;
}
if (k_level_forward != nullptr)
{
delete[]T;
}
if (k_level_backward != nullptr)
{
delete[]T;
}
if (state_isstack != nullptr)
{
delete[]state_isstack;
}
if (topsort != nullptr)
{
for (int i = 0; i < number_dominant; i++)
{
delete[] topsort[i];
}
delete[] topsort;
}
if (E != nullptr)
{
for (int i = 0; i < number_dominant; i++)
{
delete[] E[i];
}
delete[] E;
}
if (backsort != nullptr)
{
for (int i = 0; i < number_dominant; i++)
{
delete[] backsort[i];
}
delete[] backsort;
}
//消除内存vector中new的空间
for (int i = 0; i < st.size(); i++)
{
int **temp = st[i];
int number = T[i].size();
for (int j = 0; j<number_character; j++)
{
delete[number]temp[j];
temp[j] = NULL;
}
delete[number_character]temp;
temp = NULL;
}
st.clear();
}
| [
"wang2695685@163.com"
] | wang2695685@163.com |
3b65241b1468ae0ebb7b51b92ebdf1db9cef00aa | 6c400d91d92a8e70a3711f81262fae5a00b9a6c4 | /evpp/inner_pre.cc | 7cb0ee8a1970e45553f33755d541ac0da73ecb5e | [
"BSD-3-Clause"
] | permissive | sighttviewliu/evpp | 86e90d80b1ff700de74711c073b2c5776b99716a | 7d76122ccbcfcb1d36140d6a8e4bd13a45a4c59a | refs/heads/master | 2021-01-20T01:56:36.450143 | 2017-04-24T02:43:59 | 2017-04-24T02:43:59 | 89,346,415 | 1 | 0 | null | 2017-04-25T10:08:57 | 2017-04-25T10:08:57 | null | UTF-8 | C++ | false | false | 2,374 | cc | #include "evpp/inner_pre.h"
#include "evpp/libevent_headers.h"
#ifdef H_OS_WINDOWS
#pragma comment(lib, "event.lib")
#if EVENT__NUMERIC_VERSION >= 0x02010500
#pragma comment(lib, "event_core.lib")
#pragma comment(lib, "event_extra.lib")
#endif
#pragma comment(lib,"Ws2_32.lib")
#pragma comment(lib,"libglog_static.lib")
#endif
#ifndef H_OS_WINDOWS
#include <signal.h>
#endif
#include <map>
#include <thread>
#include <mutex>
namespace evpp {
namespace {
struct OnStartup {
OnStartup() {
#ifndef H_OS_WINDOWS
if (signal(SIGPIPE, SIG_IGN) == SIG_ERR) {
LOG_ERROR << "SIGPIPE set failed.";
exit(-1);
}
LOG_INFO << "ignore SIGPIPE";
#endif
}
~OnStartup() {
}
} __s_onstartup;
}
#ifdef H_DEBUG_MODE
static std::map<struct event*, std::thread::id> evmap;
static std::mutex mutex;
#endif
int EventAdd(struct event* ev, const struct timeval* timeout) {
#ifdef H_DEBUG_MODE
{
std::lock_guard<std::mutex> guard(mutex);
if (evmap.find(ev) == evmap.end()) {
auto id = std::this_thread::get_id();
evmap[ev] = id;
} else {
LOG_ERROR << "Event " << ev << " fd=" << ev->ev_fd << " event_add twice!";
assert("event_add twice");
}
}
LOG_DEBUG << "event_add ev=" << ev << " fd=" << ev->ev_fd << " user_ptr=" << ev->ev_arg << " tid=" << std::this_thread::get_id();
#endif
return event_add(ev, timeout);
}
int EventDel(struct event* ev) {
#ifdef H_DEBUG_MODE
{
std::lock_guard<std::mutex> guard(mutex);
auto it = evmap.find(ev);
if (it == evmap.end()) {
LOG_ERROR << "Event " << ev << " fd=" << ev->ev_fd << " not exist in event loop, maybe event_del twice.";
assert("event_del twice");
} else {
auto id = std::this_thread::get_id();
if (id != it->second) {
LOG_ERROR << "Event " << ev << " fd=" << ev->ev_fd << " deleted in different thread.";
assert(it->second == id);
}
evmap.erase(it);
}
}
LOG_DEBUG << "event_del ev=" << ev << " fd=" << ev->ev_fd << " user_ptr=" << ev->ev_arg << " tid=" << std::this_thread::get_id();
#endif
return event_del(ev);
}
int GetActiveEventCount() {
#ifdef H_DEBUG_MODE
return evmap.size();
#else
return 0;
#endif
}
}
| [
"zieckey@gmail.com"
] | zieckey@gmail.com |
af3af35f7b15bcdc231d8db595e45d2bb1ae7eb1 | 124f415dea0a7d4ec2e8ae1ce11194b89ddd9e77 | /Projects/Project5/main.cpp | e5a03f54b64389bdab713740bcdd6081d7a678e4 | [] | no_license | GauteHolen/Fys3150_MyCode | 9fc076b27e2e13741d6e3e46d224ce96aee969a2 | a83c16d5739ea2e32f21afd20a3cd4a50661438d | refs/heads/master | 2023-02-01T14:26:26.434510 | 2020-12-17T22:54:09 | 2020-12-17T22:54:09 | 289,979,434 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,825 | cpp | #include "./cpp_codes/RK_solver.hpp"
#include "./cpp_codes/MC_solver.hpp"
#include <omp.h>
int main(int argc, char const *argv[]){
/*====================
Input parameters
======================*/
string mode = argv[1];
string filename = argv[2];
double a = atof(argv[3]);
double b = atof(argv[4]);
double c = atof(argv[5]);
int S_0 = atoi(argv[6]);
int I_0 = atoi(argv[7]);
int R_0 = atoi(argv[8]);
double t_0 = atof(argv[9]);
double t_n = atof(argv[10]);
double n_steps = atof(argv[11]);
double N = S_0 + R_0 + I_0;
double d = atof(argv[12]);
double dI = atof(argv[13]);
double e = atof(argv[14]);
double f = atof(argv[15]);
double w = atof(argv[16]);
double A = atof(argv[17]);
double f_BULK = atof(argv[18]);
double bulk_stock = atoi(argv[19]);
/*------------------------------------------------------------
/*====================
Runge-Kutta solver
======================*/
cout<<"Starting Runge-Kutta solver..."<<endl;
RK_solver solver;
solver.init_constants(a,b,c,d,dI,e,f,w,A);
solver.init_population(N,S_0,I_0,R_0);
if(d+dI+e+f+A==0){
//Simple case with only a,b and c
cout<<"Runge-Kutta solver with no optional parameters"<<endl;
solver.expected_values();
solver.solve(t_0,t_n,n_steps, &RK_solver::susceptible, &RK_solver::infected, &RK_solver::recovering);
}
else if(d+dI+e>0 && f+A == 0){
//Only vital parameters
cout<<"Runge-Kutta solver with only option: vital"<<endl;
solver.solve(t_0,t_n,n_steps, &RK_solver::vitalS, &RK_solver::vitalI, &RK_solver::vitalR);
}
else if(f>0 && d+dI+e+A == 0){
cout<<"Runge-Kutta solver with only opetion: vaccination"<<endl;
solver.solve(t_0,t_n,n_steps, &RK_solver::vaccineS, &RK_solver::vaccineI, &RK_solver::vaccineR);
}
else if(A>0 && d+dI+e+f == 0){
cout<<"Runge-Kutta solver with only seasonal variations"<<endl;
solver.solve(t_0,t_n,n_steps, &RK_solver::seasonalS, &RK_solver::seasonalI, &RK_solver::seasonalR);
}
else{
//Cover all parameters
cout<<"Runge-Kutta solver more than one optional parameter group"<<endl;
solver.solve(t_0,t_n,n_steps, &RK_solver::allS, &RK_solver::allI, &RK_solver::allR);
}
solver.print_runtime();
solver.write_to_file(filename);
cout<<"Runge-Kutta solver DONE"<<endl;
/*------------------------------------------------------------
/*====================
Monte Carlo solver
======================*/
cout<<"Starting Monte-Carlo solver..."<<endl;
if(mode=="multiple"){
int n_runs = atoi(argv[20]);
MC_solver mc_multiple;
cout<<"Multiple run mode"<<endl;
double start_time = mc_multiple.init_multiple_runs(filename);
{
#pragma omp parallel for
for (int i = 0; i < n_runs; i++)
{
MC_solver *mc_solver = new MC_solver;
mc_solver->init_constants(a,b,c,d,dI,e,f,w,A);
mc_solver->init_population(N,S_0,I_0,R_0);
mc_solver->run(t_0,t_n,mode,i+1);
mc_solver->write_multiple_runs(filename);
delete mc_solver;
}
}
mc_multiple.multiple_run_time(filename,start_time);
}
else
{
MC_solver mc_solver;
mc_solver.init_constants(a,b,c,d,dI,e,f,w,A);
mc_solver.init_population(N,S_0,I_0,R_0);
if(mode=="BULK"){
mc_solver.init_bulkvacc(f_BULK, bulk_stock);
}
mc_solver.run(t_0,t_n,mode,1);
mc_solver.write_to_file(filename);
mc_solver.print_runtime();
}
cout<<"Monte-Carlo solver DONE"<<endl;
} | [
"gaute.ah@gmail.com"
] | gaute.ah@gmail.com |
53344d2f14e0db041a2f96d5b90f6594b13f0896 | ee797c5b1e2b0fb739b43fe5a8c64bbb6e9a8ee7 | /src/rpi_video.cpp | 178a45575b29e60689e89a3af72fd8b58f0b91bf | [
"MIT"
] | permissive | GuiPinto/aminogfx-gl | ebb5abe92e2c5cad460276038b4ec8736855e149 | 6cb0f76ed0f9b7c94f591b0ca5272c18c07b649e | refs/heads/master | 2020-04-30T18:38:19.178544 | 2018-10-04T18:04:05 | 2018-10-04T18:04:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 52,243 | cpp | #include "rpi_video.h"
#include "rpi.h"
#include "bcm_host.h"
#include "interface/vchiq_arm/vchiq_if.h"
#include <linux/input.h>
#include <dirent.h>
#include <stdio.h>
#include <semaphore.h>
#include <sstream>
#define DEBUG_OMX false
#define DEBUG_OMX_READ false
#define DEBUG_OMX_BUFFER false
#define DEBUG_OMX_ERRORS true
#define DEBUG_VIDEO_TIMING false
/*
* Buffers.
*
* 1) video 1080p@30, display 1080p@60, high bitrate
*
* - 3 buffers: 27 fps
* - 4 buffers: 27 fps
* - 8 buffers: 27 fps (no improvement)
*
* Summary: buffers do not influence playback performance
*/
#define OMX_EGL_BUFFERS 4
//
// AminoOmxVideoPlayer
//
AminoOmxVideoPlayer::AminoOmxVideoPlayer(AminoTexture *texture, AminoVideo *video): AminoVideoPlayer(texture, video) {
//init memory buffers
memset(list, 0, sizeof list);
memset(tunnel, 0, sizeof tunnel);
//semaphore
int res = uv_sem_init(&pauseSem, 0);
int res2 = uv_sem_init(&textureSem, 0);
assert(res == 0);
assert(res2 == 0);
//egl
eglImages = new EGLImageKHR[OMX_EGL_BUFFERS];
eglBuffers = new OMX_BUFFERHEADERTYPE*[OMX_EGL_BUFFERS];
for (int i = 0; i < OMX_EGL_BUFFERS; i++) {
eglImages[i] = EGL_NO_IMAGE_KHR;
eglBuffers[i] = NULL;
if (i > 1) {
textureNew.push(i);
}
}
//locks
uv_mutex_init(&bufferLock);
uv_mutex_init(&destroyLock);
}
AminoOmxVideoPlayer::~AminoOmxVideoPlayer() {
destroyAminoOmxVideoPlayer();
//semaphore
uv_sem_destroy(&pauseSem);
uv_sem_destroy(&textureSem);
//eglImages
delete[] eglImages;
delete[] eglBuffers;
//locks
uv_mutex_destroy(&bufferLock);
uv_mutex_destroy(&destroyLock);
}
/**
* Initialize the video player.
*/
void AminoOmxVideoPlayer::init() {
//we are on the OpenGL thread
if (DEBUG_OMX) {
printf("-> init OMX video player\n");
}
//stream
assert(stream);
if (!stream->init()) {
lastError = stream->getLastError();
delete stream;
stream = NULL;
handleInitDone(false);
return;
}
//check format
if (!stream->isH264()) {
if (!stream->getDemuxer()) {
lastError = "unsupported format";
delete stream;
stream = NULL;
handleInitDone(false);
}
softwareDecoding = true;
threadRunning = true;
#ifdef USE_OMX_VCOS_THREAD
VCOS_STATUS_T res = vcos_thread_create(&thread, "decoder thread", NULL, &decoderThread, this);
assert(res == VCOS_SUCCESS);
#else
int res = uv_thread_create(&thread, decoderThread, this);
assert(res == 0);
#endif
return;
}
//create OMX thread
threadRunning = true;
#ifdef USE_OMX_VCOS_THREAD
VCOS_STATUS_T res = vcos_thread_create(&thread, "OMX thread", NULL, &omxThread, this);
assert(res == VCOS_SUCCESS);
#else
int res = uv_thread_create(&thread, omxThread, this);
assert(res == 0);
#endif
}
/**
* Init video stream (on main stream).
*/
bool AminoOmxVideoPlayer::initStream() {
if (DEBUG_OMX) {
printf("-> init stream\n");
}
assert(video);
assert(!stream);
stream = new VideoFileStream(video->getPlaybackSource(), video->getPlaybackOptions());
return stream != NULL;
}
/**
* Destroy placer.
*/
void AminoOmxVideoPlayer::destroy() {
if (destroyed) {
return;
}
//instance
destroyAminoOmxVideoPlayer();
//base class
AminoVideoPlayer::destroy();
}
/**
* Destroy OMX player instance.
*/
void AminoOmxVideoPlayer::destroyAminoOmxVideoPlayer() {
//stop playback
stopOmx();
//free EGL texture
AminoGfxRPi *gfx = static_cast<AminoGfxRPi *>(texture->getEventHandler());
assert(gfx);
for (int i = 0; i < OMX_EGL_BUFFERS; i++) {
EGLImageKHR eglImage = eglImages[i];
if (eglImage != EGL_NO_IMAGE_KHR) {
gfx->destroyEGLImage(eglImage);
eglImages[i] = EGL_NO_IMAGE_KHR;
}
}
}
/**
* Close the stream.
*/
void AminoOmxVideoPlayer::closeStream() {
if (stream) {
delete stream;
stream = NULL;
}
}
/**
* OMX thread.
*/
void* AminoOmxVideoPlayer::omxThread(void *arg) {
AminoOmxVideoPlayer *player = static_cast<AminoOmxVideoPlayer *>(arg);
assert(player);
//init OMX
player->initOmx();
//close stream
player->closeStream();
//done
player->threadRunning = false;
return NULL;
}
/**
* OMX buffer callback.
*
* Note: egl_render buffer output buffer was filled.
*/
void AminoOmxVideoPlayer::handleFillBufferDone(void *data, COMPONENT_T *comp) {
AminoOmxVideoPlayer *player = static_cast<AminoOmxVideoPlayer *>(data);
assert(player);
if (DEBUG_OMX_BUFFER) {
printf("OMX: handleFillBufferDone() %p\n", comp);
}
//check state
if (player->omxDestroyed) {
//Note: last call happens while destroying OMX instance!
return;
}
//fill the next buffer (and write to texture)
uv_mutex_lock(&player->bufferLock);
//debug
//printf("-> filled: %i\n", player->textureFilling);
player->textureReady.push(player->textureFilling);
if (!player->textureNew.empty()) {
//use new
player->textureFilling = player->textureNew.front();
player->textureNew.pop();
} else {
//stop filling
player->textureFilling = -1;
//debug
//printf("-> buffering paused\n");
}
uv_mutex_unlock(&player->bufferLock);
player->omxFillNextEglBuffer();
}
/**
* Get an OMX error as string.
*/
std::string AminoOmxVideoPlayer::getOmxError(OMX_S32 err) {
switch (err) {
case OMX_ErrorNone:
//No error.
return "OMX_ErrorNone";
case OMX_ErrorInsufficientResources:
//There were insufficient resources to perform the requested operation.
return "OMX_ErrorInsufficientResources";
case OMX_ErrorUndefined:
//There was an error, but the cause of the error could not be determined.
return "OMX_ErrorUndefined";
case OMX_ErrorInvalidComponentName:
//The component name string was not valid.
return "OMX_ErrorInvalidComponentName";
case OMX_ErrorComponentNotFound:
//No component with the specified name string was found.
return "OMX_ErrorComponentNotFound";
case OMX_ErrorInvalidComponent:
//The component specified did not have a "OMX_ComponentInit" or "OMX_ComponentDeInit entry point.
return "OMX_ErrorInvalidComponent";
case OMX_ErrorBadParameter:
//One or more parameters were not valid.
return "OMX_ErrorBadParameter";
case OMX_ErrorNotImplemented:
//The requested function is not implemented.
return "OMX_ErrorNotImplemented";
case OMX_ErrorUnderflow:
//The buffer was emptied before the next buffer was ready.
return "OMX_ErrorUnderflow";
case OMX_ErrorOverflow:
//The buffer was not available when it was needed.
return "OMX_ErrorOverflow";
case OMX_ErrorHardware:
//The hardware failed to respond as expected.
return "OMX_ErrorHardware";
case OMX_ErrorInvalidState:
//The component is in the state OMX_StateInvalid.
return "OMX_ErrorInvalidState";
case OMX_ErrorStreamCorrupt:
//Stream is found to be corrupt.
return "OMX_ErrorStreamCorrupt";
case OMX_ErrorPortsNotCompatible:
//Ports being connected are not compatible.
return "OMX_ErrorPortsNotCompatible";
case OMX_ErrorResourcesLost:
//Resources allocated to an idle component have been lost resulting in the component returning to the loaded state.
return "OMX_ErrorResourcesLost";
case OMX_ErrorNoMore:
//No more indicies can be enumerated.
return "OMX_ErrorNoMore";
case OMX_ErrorVersionMismatch:
//The component detected a version mismatch.
return "OMX_ErrorVersionMismatch";
case OMX_ErrorNotReady:
//The component is not ready to return data at this time.
return "OMX_ErrorNotReady";
case OMX_ErrorTimeout:
//There was a timeout that occurred.
return "OMX_ErrorTimeout";
case OMX_ErrorSameState:
//This error occurs when trying to transition into the state you are already in.
return "OMX_ErrorSameState";
case OMX_ErrorResourcesPreempted:
//Resources allocated to an executing or paused component have been preempted, causing the component to return to the idle state.
return "OMX_ErrorResourcesPreempted";
case OMX_ErrorPortUnresponsiveDuringAllocation:
//A non-supplier port sends this error to the IL client (via the EventHandler callback) during the allocation of buffers (on a transition from the LOADED to the IDLE state or on a port restart) when it deems that it has waited an unusually long time for the supplier to send it an allocated buffer via a UseBuffer call.
return "OMX_ErrorPortUnresponsiveDuringAllocation";
case OMX_ErrorPortUnresponsiveDuringDeallocation:
//A non-supplier port sends this error to the IL client (via the EventHandler callback) during the deallocation of buffers (on a transition from the IDLE to LOADED state or on a port stop) when it deems that it has waited an unusually long time for the supplier to request the deallocation of a buffer header via a FreeBuffer call.
return "OMX_ErrorPortUnresponsiveDuringDeallocation";
case OMX_ErrorPortUnresponsiveDuringStop:
//A supplier port sends this error to the IL client (via the EventHandler callback) during the stopping of a port (either on a transition from the IDLE to LOADED state or a port stop) when it deems that it has waited an unusually long time for the non-supplier to return a buffer via an EmptyThisBuffer or FillThisBuffer call.
return "OMX_ErrorPortUnresponsiveDuringStop";
case OMX_ErrorIncorrectStateTransition:
//Attempting a state transtion that is not allowed.
return "OMX_ErrorIncorrectStateTransition";
case OMX_ErrorIncorrectStateOperation:
//Attempting a command that is not allowed during the present state.
return "OMX_ErrorIncorrectStateOperation";
case OMX_ErrorUnsupportedSetting:
//The values encapsulated in the parameter or config structure are not supported.
return "OMX_ErrorUnsupportedSetting";
case OMX_ErrorUnsupportedIndex:
//The parameter or config indicated by the given index is not supported.
return "OMX_ErrorUnsupportedIndex";
case OMX_ErrorBadPortIndex:
//The port index supplied is incorrect.
return "OMX_ErrorBadPortIndex";
case OMX_ErrorPortUnpopulated:
//The port has lost one or more of its buffers and it thus unpopulated.
return "OMX_ErrorPortUnpopulated";
case OMX_ErrorComponentSuspended:
//Component suspended due to temporary loss of resources.
return "OMX_ErrorComponentSuspended";
case OMX_ErrorDynamicResourcesUnavailable:
//Component suspended due to an inability to acquire dynamic resources.
return "OMX_ErrorDynamicResourcesUnavailable";
case OMX_ErrorMbErrorsInFrame:
//When the macroblock error reporting is enabled the component returns new error for every frame that has errors.
return "OMX_ErrorMbErrorsInFrame";
case OMX_ErrorFormatNotDetected:
//A component reports this error when it cannot parse or determine the format of an input stream.
return "OMX_ErrorFormatNotDetected";
case OMX_ErrorContentPipeOpenFailed:
//The content open operation failed.
return "OMX_ErrorContentPipeOpenFailed";
case OMX_ErrorContentPipeCreationFailed:
//The content creation operation failed.
return "OMX_ErrorContentPipeCreationFailed";
case OMX_ErrorSeperateTablesUsed:
//Separate table information is being used.
return "OMX_ErrorSeperateTablesUsed";
case OMX_ErrorTunnelingUnsupported:
//Tunneling is unsupported by the component.
return "OMX_ErrorTunnelingUnsupported";
//OMX_ErrorKhronosExtensions 0x8F000000 (Reserved region for introducing Khronos Standard Extensions.)
//OMX_ErrorVendorStartUnused 0x90000000 (Reserved region for introducing Vendor Extensions)
case OMX_ErrorDiskFull:
//Disk Full error.
return "OMX_ErrorDiskFull";
case OMX_ErrorMaxFileSize:
//Max file size is reached.
return "OMX_ErrorMaxFileSize";
case OMX_ErrorDrmUnauthorised:
//Unauthorised to play a DRM protected file.
return "OMX_ErrorDrmUnauthorised";
case OMX_ErrorDrmExpired:
//The DRM protected file has expired.
return "OMX_ErrorDrmExpired";
case OMX_ErrorDrmGeneral:
//Some other DRM library error.
return "OMX_ErrorDrmGeneral";
}
//unknown error
std::stringstream ss;
ss << "unknown OMX error: 0x" << std::hex << err;
return ss.str();
}
/**
* IL client reported errors.
*/
void AminoOmxVideoPlayer::omxErrorHandler(void *userData, COMPONENT_T *comp, OMX_U32 data) {
//see http://maemo.org/api_refs/5.0/beta/libomxil-bellagio/_o_m_x___core_8h.html
//filter harmless errors
OMX_S32 err = data;
if (err == OMX_ErrorSameState) {
return;
}
//output
std::string error = getOmxError(err);
fprintf(stderr, "OMX error: %s\n", error.c_str());
}
/**
* Initialize OpenMax.
*/
bool AminoOmxVideoPlayer::initOmx() {
int status = 0;
COMPONENT_T *video_decode = NULL;
COMPONENT_T *clock = NULL;
COMPONENT_T *video_scheduler = NULL;
if (DEBUG_OMX) {
printf("-> init OMX\n");
}
//VCOS log statements (Note: VCOS_LOG_CATEGORY has to be defined first)
//vcos_log_set_level(VCOS_LOG_CATEGORY, VCOS_LOG_TRACE);
//init il client
client = ilclient_init();
if (!client) {
lastError = "could not initialize ilclient";
status = -1;
goto end;
}
//set error handler
if (DEBUG_OMX_ERRORS) {
ilclient_set_error_callback(client, omxErrorHandler, this);
}
//set EOS callback
//TODO check if call works as expected
//ilclient_set_eos_callback(handle, omxEosHandler, NULL);
//init OMX
if (OMX_Init() != OMX_ErrorNone) {
lastError = "could not initialize OMX";
status = -2;
goto end;
}
//buffer callback
ilclient_set_fill_buffer_done_callback(client, handleFillBufferDone, this);
//create video_decode (input buffer)
if (ilclient_create_component(client, &video_decode, "video_decode", (ILCLIENT_CREATE_FLAGS_T)(ILCLIENT_DISABLE_ALL_PORTS | ILCLIENT_ENABLE_INPUT_BUFFERS)) != 0) {
lastError = "video_decode error";
status = -10;
goto end;
}
list[0] = video_decode;
//create egl_render (output buffer)
if (ilclient_create_component(client, &egl_render, "egl_render", (ILCLIENT_CREATE_FLAGS_T)(ILCLIENT_DISABLE_ALL_PORTS | ILCLIENT_ENABLE_OUTPUT_BUFFERS)) != 0) {
lastError = "egl_render error";
status = -11;
goto end;
}
list[1] = egl_render;
//create clock
if (ilclient_create_component(client, &clock, "clock", (ILCLIENT_CREATE_FLAGS_T)ILCLIENT_DISABLE_ALL_PORTS) != 0) {
lastError = "clock error";
status = -12;
goto end;
}
list[2] = clock;
//config clock (waiting for start time)
OMX_TIME_CONFIG_CLOCKSTATETYPE cstate;
memset(&cstate, 0, sizeof cstate);
cstate.nSize = sizeof cstate;
cstate.nVersion.nVersion = OMX_VERSION;
cstate.eState = OMX_TIME_ClockStateWaitingForStartTime;
cstate.nWaitMask = OMX_CLOCKPORT0;
/*
cstate.nOffset.nLowPart = -200 * 1000; //200 ms
cstate.nOffset.nHighPart = 0;
*/
if (OMX_SetParameter(ILC_GET_HANDLE(clock), OMX_IndexConfigTimeClockState, &cstate) != OMX_ErrorNone) {
lastError = "could not set clock";
status = -13;
goto end;
}
//HDMI sync (Note: not well documented; seeing no effect, probably not needed)
OMX_CONFIG_LATENCYTARGETTYPE lt;
memset(<, 0, sizeof lt);
lt.nSize = sizeof lt;
lt.nVersion.nVersion = OMX_VERSION;
lt.nPortIndex = OMX_ALL;
lt.bEnabled = OMX_TRUE;
lt.nFilter = 10;
lt.nTarget = 0;
lt.nShift = 3;
lt.nSpeedFactor = -60;
lt.nInterFactor = 100;
lt.nAdjCap = 100;
/*
lt.nPortIndex = OMX_ALL;
lt.bEnabled = OMX_TRUE;
lt.nFilter = 2;
lt.nTarget = 4000;
lt.nShift = 3;
lt.nSpeedFactor = -135;
lt.nInterFactor = 500;
lt.nAdjCap = 20;
*/
if (OMX_SetConfig(ILC_GET_HANDLE(clock), OMX_IndexConfigLatencyTarget, <) != OMX_ErrorNone) {
lastError = "could not set clock latency";
status = -14;
goto end;
}
//create video_scheduler
if (ilclient_create_component(client, &video_scheduler, "video_scheduler", (ILCLIENT_CREATE_FLAGS_T)ILCLIENT_DISABLE_ALL_PORTS) != 0) {
lastError = "video_scheduler error";
status = -15;
goto end;
}
list[3] = video_scheduler;
//set tunnels (source & sink ports)
set_tunnel(tunnel, video_decode, 131, video_scheduler, 10);
set_tunnel(tunnel + 1, video_scheduler, 11, egl_render, 220);
set_tunnel(tunnel + 2, clock, 80, video_scheduler, 12);
//setup clock tunnel first
if (ilclient_setup_tunnel(tunnel + 2, 0, 0) != 0) {
lastError = "tunnel setup error";
status = -16;
goto end;
}
//video reference clock
OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE arct;
memset(&arct, 0, sizeof arct);
arct.nSize = sizeof arct;
arct.nVersion.nVersion = OMX_VERSION;
arct.eClock = OMX_TIME_RefClockVideo;
if (OMX_SetConfig(ILC_GET_HANDLE(clock), OMX_IndexConfigTimeActiveRefClock, &arct) != OMX_ErrorNone) {
lastError = "could not set reference clock type";
status = -160;
goto end;
}
//set speed
setOmxSpeed(1 << 16);
//switch clock to executing state
ilclient_change_component_state(clock, OMX_StateExecuting);
//switch video decoder to idle state
ilclient_change_component_state(video_decode, OMX_StateIdle);
//video format
OMX_VIDEO_PARAM_PORTFORMATTYPE format;
memset(&format, 0, sizeof format);
format.nSize = sizeof format;
format.nVersion.nVersion = OMX_VERSION;
format.nPortIndex = 130; //input
format.eCompressionFormat = OMX_VIDEO_CodingAVC; //H264
format.xFramerate = getOmxFramerate();
/*
* TODO more formats
*
* - OMX_VIDEO_CodingMPEG4 non-H264 MP4 formats (H263, DivX, ...)
* - OMX_VIDEO_CodingMPEG2 needs license
* - OMX_VIDEO_CodingTheora Theora
*/
if (OMX_SetParameter(ILC_GET_HANDLE(video_decode), OMX_IndexParamVideoPortFormat, &format) != OMX_ErrorNone) {
lastError = "could not set video format";
status = -17;
goto end;
}
//show video_decode buffer sizes
/*
printf("video_decode input buffers:\n");
showOmxBufferInfo(video_decode, 130); //buffers=20 minBuffer=1 bufferSize=81920)
printf("video_decode output buffers:\n");
showOmxBufferInfo(video_decode, 131); //buffers=1 minBuffer=1 bufferSize=115200
*/
//free extra buffers
OMX_PARAM_U32TYPE eb;
memset(&eb, 0, sizeof eb);
eb.nSize = sizeof eb;
eb.nVersion.nVersion = OMX_VERSION;
eb.nU32 = 0;
if (OMX_SetParameter(ILC_GET_HANDLE(video_decode), OMX_IndexParamBrcmExtraBuffers, &eb) != OMX_ErrorNone) {
lastError = "could not set extra buffers";
status = -172;
goto end;
}
//create video decode input buffers
if (ilclient_enable_port_buffers(video_decode, 130, NULL, NULL, NULL) != 0) {
lastError = "video decode port error";
status = -18;
goto end;
}
//frame validation (see https://www.raspberrypi.org/forums/viewtopic.php?f=70&t=15983)
OMX_PARAM_BRCMVIDEODECODEERRORCONCEALMENTTYPE ec;
memset(&ec, 0, sizeof ec);
ec.nSize = sizeof ec;
ec.nVersion.nVersion = OMX_VERSION;
ec.bStartWithValidFrame = OMX_FALSE;
if (OMX_SetParameter(ILC_GET_HANDLE(video_decode), OMX_IndexParamBrcmVideoDecodeErrorConcealment, &ec) != OMX_ErrorNone) {
lastError = "error concealment type";
status = -19;
goto end;
}
//NALU (see https://www.khronos.org/registry/OpenMAX-IL/extensions/KHR/OpenMAX_IL_1_1_2_Extension%20NAL%20Unit%20Packaging.pdf)
if (stream->hasH264NaluStartCodes()) {
if (DEBUG_OMX) {
printf("-> set OMX_NaluFormatStartCodes\n");
}
OMX_NALSTREAMFORMATTYPE nsft;
memset(&nsft, 0, sizeof nsft);
nsft.nSize = sizeof nsft;
nsft.nVersion.nVersion = OMX_VERSION;
nsft.nPortIndex = 130; //input
nsft.eNaluFormat = OMX_NaluFormatStartCodes;
if (OMX_SetParameter(ILC_GET_HANDLE(video_decode), (OMX_INDEXTYPE)OMX_IndexParamNalStreamFormatSelect, &nsft) != OMX_ErrorNone) {
lastError = "NAL selection error";
status = -20;
goto end;
}
}
//debug
if (DEBUG_OMX) {
printf("OMX init done\n");
}
//playback
status = playOmx();
//done
end:
//debug
if (DEBUG_OMX) {
printf("OMX done status: %i\n", status);
}
//check status
if (status != 0) {
//add error code
std::ostringstream ss;
ss << lastError << " (" << status << ")";
lastError = ss.str();
//report error
if (!initDone) {
handleInitDone(false);
} else {
if (doStop) {
handlePlaybackStopped();
} else {
handlePlaybackError();
}
}
}
uv_mutex_lock(&destroyLock);
destroyOmx();
uv_mutex_unlock(&destroyLock);
if (status == 0) {
if (!initDone) {
handleInitDone(true);
}
if (doStop) {
handlePlaybackStopped();
} else {
handlePlaybackDone();
}
}
return status == 0;
}
/**
* OMX playback loop.
*/
int AminoOmxVideoPlayer::playOmx() {
if (DEBUG_OMX) {
printf("playOmx()\n");
}
COMPONENT_T *video_decode = list[0];
COMPONENT_T *video_scheduler = list[3];
//start decoding
OMX_BUFFERHEADERTYPE *buf;
bool port_settings_changed = false;
bool firstPacket = true;
int res = 0;
ilclient_change_component_state(video_decode, OMX_StateExecuting);
/*
* Works:
*
* - Digoo M1Q
* - h264 (Main), yuv420p, 1280x960
* - RTSP Bigbuckbunny
* - h264 (Constrained Baseline), yuv420p, 320x180
* - Note: playback issues seen on RPi and Mac, other RTSP examples work fine
* - M4V
* - h264 (Constrained Baseline), yuv420p, 480x270
* - HTTPS
* - h264 (Main), yuv420p, 1920x1080
*
*/
//data loop
while ((buf = ilclient_get_input_buffer(video_decode, 130, 1)) != NULL) {
if (DEBUG_OMX_READ) {
printf("-> got input buffer\n");
}
//check stop
if (doStop) {
break;
}
//check pause (prevent reading while paused; might not be called)
if (doPause) {
if (DEBUG_OMX) {
printf("pausing OMX thread\n");
}
//wait
doPause = false; //signal we are waiting
uv_sem_wait(&pauseSem);
if (doStop) {
break;
}
}
//feed data and wait until we get port settings changed
unsigned char *dest = buf->pBuffer;
//read from file
omx_metadata_t omxData;
unsigned int data_len = stream->read(dest, buf->nAllocLen, omxData);
//check end
if (data_len == 0 && stream->endOfStream()) {
//check if stream contained video data
if (!ready) {
//case: no video in stream
lastError = "stream without valid video data";
res = -30;
break;
}
//loop
if (loop > 0) {
loop--;
}
if (loop == 0) {
//end playback
if (DEBUG_OMX) {
printf("OMX: end playback (EOS)\n");
}
break;
}
if (DEBUG_OMX) {
printf("OMX: rewind stream\n");
}
if (!stream->rewind()) {
//could not rewind -> end playback
if (DEBUG_OMX) {
printf("-> rewind failed!\n");
}
break;
}
//Note: media time continues
handleRewind();
//read next block
data_len = stream->read(dest, buf->nAllocLen, omxData);
}
if (DEBUG_OMX_READ) {
printf("OMX: data read %i\n", (int)data_len);
}
//handle decoder output port settings changes
if (!port_settings_changed &&
((data_len > 0 && ilclient_remove_event(video_decode, OMX_EventPortSettingsChanged, 131, 0, 0, 1) == 0) ||
(data_len == 0 && ilclient_wait_for_event(video_decode, OMX_EventPortSettingsChanged, 131, 0, 0, 1, ILCLIENT_EVENT_ERROR | ILCLIENT_PARAMETER_CHANGED, 10000) == 0))) {
//process once
port_settings_changed = true;
if (DEBUG_OMX) {
printf("OMX: egl_render setup\n");
}
//setup video_scheduler tunnel
if (ilclient_setup_tunnel(tunnel, 0, 0) != 0) {
lastError = "video tunnel setup error";
res = -31;
break;
}
//debug video_scheduler buffers
/*
printf("video_scheduler buffers:\n");
showOmxBufferInfo(video_scheduler, 10); //buffers=0 minBuffer=0 bufferSize=3133440
showOmxBufferInfo(video_scheduler, 11); //buffers=1 minBuffer=1 bufferSize=3133440
showOmxBufferInfo(video_scheduler, 12); //buffers=1 minBuffer=1 bufferSize=48
*/
//start scheduler
ilclient_change_component_state(video_scheduler, OMX_StateExecuting);
//now setup tunnel to egl_render
if (ilclient_setup_tunnel(tunnel + 1, 0, 1000) != 0) {
lastError = "egl_render tunnel setup error";
res = -32;
break;
}
//set egl_render to idle
ilclient_change_component_state(egl_render, OMX_StateIdle);
//get video size
OMX_PARAM_PORTDEFINITIONTYPE portdef;
memset(&portdef, 0, sizeof portdef);
portdef.nSize = sizeof portdef;
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = 131; //output buffer
if (OMX_GetParameter(ILC_GET_HANDLE(video_decode), OMX_IndexParamPortDefinition, &portdef) != OMX_ErrorNone) {
lastError = "could not get video size";
res = -33;
break;
}
videoW = portdef.format.video.nFrameWidth;
videoH = portdef.format.video.nFrameHeight;
if (DEBUG_OMX) {
//Note: buffer count not set.
double fps = portdef.format.video.xFramerate / (float)(1 << 16);
printf("video: %dx%d@%.2f bitrate=%i minBuffers=%i buffer=%i bufferSize=%i\n", videoW, videoH, fps, (int)portdef.format.video.nBitrate, portdef.nBufferCountMin, portdef.nBufferCountActual, portdef.nBufferSize);
}
//show egl_render buffer sizes
/*
printf("egl_render input buffers:\n"); //buffers=0 minBuffer=0 bufferSize=3133440
showOmxBufferInfo(egl_render, 220);
printf("egl_render output buffers:\n"); //buffers=1 minBuffer=1 bufferSize=0
showOmxBufferInfo(egl_render, 221);
*/
//set egl render buffers (max 8; https://github.com/raspberrypi/firmware/issues/718)
setOmxBufferCount(egl_render, 221, OMX_EGL_BUFFERS);
//do not discard input buffers (needed to get smooth playback)
OMX_CONFIG_PORTBOOLEANTYPE dm;
memset(&dm, 0, sizeof dm);
dm.nSize = sizeof dm;
dm.nVersion.nVersion = OMX_VERSION;
dm.nPortIndex = 220; //input buffer
dm.bEnabled = OMX_FALSE;
if (OMX_SetParameter(ILC_GET_HANDLE(egl_render), OMX_IndexParamBrcmVideoEGLRenderDiscardMode, &dm) != OMX_ErrorNone) {
lastError = "could not disable discard mode";
res = -330;
break;
}
//switch to renderer thread (switches to playing state)
texture->initVideoTexture();
//wait for texture
uv_sem_wait(&textureSem);
if (!eglImagesReady || doStop) {
//failed to create texture
handleInitDone(false);
break;
}
//setup OMX texture
if (!setupOmxTexture()) {
res = -34;
break;
}
//texture ready
handleInitDone(true);
}
if (!data_len) {
//read error occured
lastError = "IO error";
res = -40;
break;
}
//empty buffer
buf->nFilledLen = data_len;
buf->nOffset = 0;
buf->nFlags = omxData.flags;
if (omxData.timeStamp) {
//in microseconds
buf->nTimeStamp.nLowPart = omxData.timeStamp;
buf->nTimeStamp.nHighPart = omxData.timeStamp >> 32;
}
//debug (Note: in presentation time order)
//printf("timestamp: %i %i\n", buf->nTimeStamp.nHighPart, buf->nTimeStamp.nLowPart);
if (firstPacket && (omxData.flags & OMX_BUFFERFLAG_CODECCONFIG) != OMX_BUFFERFLAG_CODECCONFIG) {
//first packet (contains start time)
buf->nFlags |= OMX_BUFFERFLAG_STARTTIME;
firstPacket = false;
} else {
//video packet
if (omxData.timeStamp) {
//Note: time is always in PTS (DTS not used)
//buf->nFlags |= OMX_BUFFERFLAG_TIME_IS_DTS;
} else {
buf->nFlags |= OMX_BUFFERFLAG_TIME_UNKNOWN;
}
}
if (OMX_EmptyThisBuffer(ILC_GET_HANDLE(video_decode), buf) != OMX_ErrorNone) {
lastError = "could not empty buffer";
res = -41;
break;
}
if (DEBUG_OMX_READ) {
printf("-> waiting for next input buffer\n");
}
}
//end of feeding loop (end of stream case)
if (DEBUG_OMX) {
printf("-> end of OMX data loop\n");
}
//send end of stream (if not aborted)
if (buf) {
buf->nFilledLen = 0;
buf->nFlags = OMX_BUFFERFLAG_TIME_UNKNOWN | OMX_BUFFERFLAG_EOS;
if (OMX_EmptyThisBuffer(ILC_GET_HANDLE(video_decode), buf) != OMX_ErrorNone) {
lastError = "could not empty buffer (2)";
res = -50;
}
if (DEBUG_OMX) {
printf("OMX: decoder EOS\n");
}
//wait for EOS from renderer
//Note: the following code is not working, getting a timeout after 10 s!
//ilclient_wait_for_event(egl_render, OMX_EventBufferFlag, 220, 0, OMX_BUFFERFLAG_EOS, 0, ILCLIENT_BUFFER_FLAG_EOS, 10000);
// -> monitor buffer update (last image was successfully shown)
while (bufferFilled && !doStop && res == 0) {
//wait 100 ms (enough time to show the next frame)
bufferFilled = false;
usleep(100 * 1000);
}
if (DEBUG_OMX) {
printf("OMX: renderer EOS\n");
}
}
//need to flush the renderer to allow video_decode to disable its input port
if (DEBUG_OMX) {
printf("OMX: flushing tunnels\n");
}
ilclient_flush_tunnels(tunnel, 0);
return res;
}
/**
* Display buffer details on given port of component.
*/
bool AminoOmxVideoPlayer::showOmxBufferInfo(COMPONENT_T *comp, int port) {
OMX_PARAM_PORTDEFINITIONTYPE portdef;
memset(&portdef, 0, sizeof portdef);
portdef.nSize = sizeof portdef;
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = port;
if (OMX_GetParameter(ILC_GET_HANDLE(comp), OMX_IndexParamPortDefinition, &portdef) != OMX_ErrorNone) {
printf("-> Could not get port definition!\n");
return false;
}
//show
printf("-> buffers=%i minBuffer=%i bufferSize=%i\n", portdef.nBufferCountActual, portdef.nBufferCountMin, portdef.nBufferSize);
return true;
}
/**
* Set the buffer count.
*/
bool AminoOmxVideoPlayer::setOmxBufferCount(COMPONENT_T *comp, int port, int count) {
OMX_PARAM_PORTDEFINITIONTYPE portdef;
memset(&portdef, 0, sizeof portdef);
portdef.nSize = sizeof portdef;
portdef.nVersion.nVersion = OMX_VERSION;
portdef.nPortIndex = port;
//get current settings
if (OMX_GetParameter(ILC_GET_HANDLE(comp), OMX_IndexParamPortDefinition, &portdef) != OMX_ErrorNone) {
printf("-> Could not get port definition!\n");
return false;
}
//change values
portdef.nPortIndex = port;
portdef.nBufferCountActual = count;
if (OMX_SetParameter(ILC_GET_HANDLE(comp), OMX_IndexParamPortDefinition, &portdef) != OMX_ErrorNone) {
printf("-> Could not set port definition!\n");
return false;
}
return true;
}
/**
* Stops the OMX playback thread (or software decoding).
*/
void AminoOmxVideoPlayer::stopOmx() {
uv_mutex_lock(&destroyLock);
if (!omxDestroyed) {
if (DEBUG_OMX) {
printf("stopping OMX\n");
}
doStop = true;
if (paused && !doPause) {
//resume thread
uv_sem_post(&pauseSem);
uv_sem_post(&textureSem);
} else {
doPause = false;
}
//prevent deadlock
COMPONENT_T *video_decode = list[0];
ilclient_stop_input_buffering(video_decode);
uv_mutex_unlock(&destroyLock);
//wait for thread
if (threadRunning) {
if (DEBUG_OMX) {
printf("waiting for OMX thread to end\n");
}
#ifdef USE_OMX_VCOS_THREAD
//VCOS
vcos_thread_join(&thread, NULL);
#else
int res = uv_thread_join(&thread);
assert(res == 0);
#endif
}
} else {
uv_mutex_unlock(&destroyLock);
}
}
/**
* Needed OpenGL textures.
*/
int AminoOmxVideoPlayer::getNeededTextures() {
return softwareDecoding ? 1:OMX_EGL_BUFFERS;
}
/**
* Init video texture on OpenGL thread.
*/
void AminoOmxVideoPlayer::initVideoTexture() {
if (DEBUG_VIDEOS) {
printf("video: init video texture\n");
}
if (!initTexture()) {
//stop thread
doStop = true;
uv_sem_post(&textureSem);
//signal error
handleInitDone(false);
return;
}
//ready
eglImagesReady = true;
uv_sem_post(&textureSem);
}
/**
* Setup texture.
*/
bool AminoOmxVideoPlayer::setupOmxTexture() {
//enable the output port and tell egl_render to use the texture as a buffer
OMX_HANDLETYPE eglHandle = ILC_GET_HANDLE(egl_render);
//Note: OMX_IndexConfigLatencyTarget not supported by egl_render (port 220)
//ilclient_enable_port(egl_render, 221); THIS BLOCKS SO CAN'T BE USED
if (OMX_SendCommand(eglHandle, OMX_CommandPortEnable, 221, NULL) != OMX_ErrorNone) {
lastError = "OMX_CommandPortEnable failed.";
return false;
}
for (int i = 0; i < OMX_EGL_BUFFERS; i++) {
//Note: pAppPrivate not used
if (OMX_UseEGLImage(eglHandle, &eglBuffers[i], 221, NULL, eglImages[i]) != OMX_ErrorNone) {
lastError = "OMX_UseEGLImage failed.";
return false;
}
if (!eglBuffers[i]) {
lastError = "could not get buffer";
return false;
}
}
if (DEBUG_OMX) {
printf("OMX: egl_render setup done\n");
}
//set egl_render to executing
ilclient_change_component_state(egl_render, OMX_StateExecuting);
if (DEBUG_OMX) {
printf("OMX: executing\n");
}
//request egl_render to write data to the texture buffer
if (!omxFillNextEglBuffer()) {
lastError = "OMX_FillThisBuffer failed.";
return false;
}
return true;
}
/**
* Fill the next egl_render buffer.
*/
bool AminoOmxVideoPlayer::omxFillNextEglBuffer() {
if (textureFilling == -1) {
return false;
}
OMX_BUFFERHEADERTYPE *eglBuffer = eglBuffers[textureFilling];
eglBuffer->nFlags = 0;
eglBuffer->nFilledLen = 0;
if (OMX_FillThisBuffer(ilclient_get_handle(egl_render), eglBuffer) != OMX_ErrorNone) {
bufferError = true;
printf("OMX_FillThisBuffer failed in callback\n");
return false;
}
bufferFilled = true;
return true;
}
/**
* Init texture (on rendering thread).
*/
bool AminoOmxVideoPlayer::initTexture() {
texture->activeTexture = 0;
int textureCount = getNeededTextures();
for (int i = 0; i < textureCount; i++) {
GLuint textureId = texture->textureIds[i];
assert(textureId != INVALID_TEXTURE);
glBindTexture(GL_TEXTURE_2D, textureId);
//size (has to be equal to video dimension!)
GLsizei textureW = videoW;
GLsizei textureH = videoH;
GLvoid *data = NULL;
if (softwareDecoding) {
data = stream->getDemuxer()->getFrameData(frameId);
assert(data);
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, textureW, textureH, 0,GL_RGBA, GL_UNSIGNED_BYTE, data);
//Note: no performance hit seen
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
/*
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
*/
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
if (!softwareDecoding) {
//create EGL Image
AminoGfxRPi *gfx = static_cast<AminoGfxRPi *>(texture->getEventHandler());
EGLImageKHR eglImage = gfx->createEGLImage(textureId);
eglImages[i] = eglImage;
if (eglImage == EGL_NO_IMAGE_KHR) {
lastError = "eglCreateImageKHR failed";
return false;
}
}
}
return true;
}
/**
* Update the video texture (on OpenGL thread).
*
* Displays the next frame once available.
*/
void AminoOmxVideoPlayer::updateVideoTexture(GLContext *ctx) {
uv_mutex_lock(&destroyLock);
if (paused || !playing || omxDestroyed) {
uv_mutex_unlock(&destroyLock);
return;
}
if (softwareDecoding) {
//get current frame
int id;
GLvoid *data = stream->getDemuxer()->getFrameData(id);
if (!data) {
uv_mutex_unlock(&destroyLock);
return;
}
if (id == frameId) {
//debug
//printf("skipping frame\n");
uv_mutex_unlock(&destroyLock);
return;
}
frameId = id;
glBindTexture(GL_TEXTURE_2D, texture->getTexture());
GLsizei textureW = videoW;
GLsizei textureH = videoH;
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, textureW, textureH, GL_RGB, GL_UNSIGNED_BYTE, data);
uv_mutex_unlock(&destroyLock);
return;
}
//hardware decoder
uv_mutex_lock(&bufferLock);
bool newBuffer = false;
//FIXME a few crashes seen in long running instances (sometimes each day)
if (!textureReady.empty()) {
//new frame available
//check media time
int nextFrame = textureReady.front();
OMX_BUFFERHEADERTYPE *eglBuffer = eglBuffers[nextFrame];
int64_t timestamp = eglBuffer->nTimeStamp.nLowPart | ((int64_t)eglBuffer->nTimeStamp.nHighPart << 32);
double timeSecs = timestamp / 1000000.f;
double timeNowSys = getTime() / 1000;
double playTime;
if (timeStartSys == -1) {
//start of playback
playTime = 0;
timeStartSys = timeNowSys;
} else {
//ongoing playback
playTime = timeNowSys - timeStartSys;
}
if (timeSecs < mediaTime || (mediaTime > 0 && timeSecs - mediaTime > 3.)) {
//rewind or sudden jump detected (for instance 1080p HTTP test case; in other cases no reset occurs)
//-> resync time
mediaTime = timeSecs;
timeStartSys = timeNowSys - mediaTime;
playTime = mediaTime;
if (DEBUG_VIDEO_TIMING) {
printf("-> resync time\n");
}
}
if (playTime >= timeSecs) {
//switch to next frame
textureNew.push(textureActive);
textureActive = nextFrame;
textureReady.pop();
//Note: not necessary
//ctx->unbindTexture();
texture->activeTexture = textureActive;
//update media time (use frame time, not actual time)
mediaTime = timeSecs;
//check buffer state
if (textureFilling == -1) {
//fill next buffer
textureFilling = textureNew.front();
textureNew.pop();
newBuffer = true;
}
//debug
if (DEBUG_VIDEO_TIMING) {
if (playTime - timeSecs > 0.2) {
float diff = playTime - timeSecs;
printf("-> frame shown too late (decoder too slow?; %f ms)\n", diff * 1000);
}
}
if (!textureReady.empty()) {
int nextFrame2 = textureReady.front();
OMX_BUFFERHEADERTYPE *eglBuffer2 = eglBuffers[nextFrame2];
int64_t timestamp2 = eglBuffer2->nTimeStamp.nLowPart | ((int64_t)eglBuffer2->nTimeStamp.nHighPart << 32);
double timeSecs2 = timestamp2 / 1000000.f;
if (playTime >= timeSecs2) {
if (DEBUG_VIDEO_TIMING) {
printf("-> playback queue lag (rendering too slow)\n");
}
//drop frame (-> playback no longer smooth)
/*
textureReady.pop();
textureNew.push(nextFrame2);
*/
//resync time
timeStartSys = timeNowSys - mediaTime;
}
}
if (DEBUG_VIDEO_TIMING) {
printf("-> displaying: %i (pos: %f s)\n", textureActive, timeSecs);
}
} else {
//waiting
//debug
if (DEBUG_VIDEO_TIMING) {
printf("-> next frame is ready (wait: %f s)\n", timeSecs - playTime);
}
}
} else {
//no new frame
//debug
//printf("-> underflow\n");
}
uv_mutex_unlock(&bufferLock);
uv_mutex_unlock(&destroyLock);
if (newBuffer) {
omxFillNextEglBuffer();
}
}
/**
* Destroy OMX.
*/
void AminoOmxVideoPlayer::destroyOmx() {
if (DEBUG_OMX) {
printf("OMX: destroying instance\n");
}
omxDestroyed = true;
//disable tunnels
ilclient_disable_tunnel(tunnel);
ilclient_disable_tunnel(tunnel + 1);
ilclient_disable_tunnel(tunnel + 2);
if (DEBUG_OMX) {
printf("-> tunnels disabled\n");
}
//free buffers
COMPONENT_T *video_decode = list[0];
ilclient_disable_port_buffers(video_decode, 130, NULL, NULL, NULL); //input
if (DEBUG_OMX) {
printf("-> buffers disabled\n");
}
//close tunnels
ilclient_teardown_tunnels(tunnel);
memset(tunnel, 0, sizeof tunnel);
if (DEBUG_OMX) {
printf("-> tunnels closed\n");
}
//idle state
ilclient_state_transition(list, OMX_StateIdle);
//Note: blocks forever!!! Anyway, we are not re-using this player instance.
//ilclient_state_transition(list, OMX_StateLoaded);
for (int i = 0; i < OMX_EGL_BUFFERS; i++) {
if (eglBuffers[i]) {
OMX_FreeBuffer(ILC_GET_HANDLE(egl_render), 221, eglBuffers[i]);
eglBuffers[i] = NULL;
}
}
egl_render = NULL;
ilclient_cleanup_components(list);
if (DEBUG_OMX) {
printf("-> components closed\n");
}
//destroy OMX
OMX_Deinit(); //Note: decreases instance counter
if (client) {
ilclient_destroy(client);
client = NULL;
}
if (DEBUG_OMX) {
printf("OMX: instance destroyed\n");
}
}
/**
* Get current media time.
*/
double AminoOmxVideoPlayer::getMediaTime() {
if ((!playing && !paused) || !list) {
return -1;
}
return mediaTime;
/*
//OMX decoder (Note: blocks sometimes)
COMPONENT_T *clock = list[2];
OMX_TIME_CONFIG_TIMESTAMPTYPE ts;
memset(&ts, 0, sizeof ts);
ts.nSize = sizeof ts;
ts.nVersion.nVersion = OMX_VERSION;
ts.nPortIndex = OMX_ALL;
if (OMX_GetConfig(ILC_GET_HANDLE(clock), OMX_IndexConfigTimeCurrentMediaTime, &ts) != OMX_ErrorNone) {
return -1;
}
//microseconds
int64_t timestamp = ts.nTimestamp.nLowPart | ((int64_t)ts.nTimestamp.nHighPart << 32);
return timestamp / 1000000.f;
*/
}
/**
* Get video duration (-1 if unknown).
*/
double AminoOmxVideoPlayer::getDuration() {
if (stream) {
return stream->getDuration();
}
return -1;
}
/**
* Get the framerate (0 if unknown).
*/
double AminoOmxVideoPlayer::getFramerate() {
if (stream) {
return stream->getFramerate();
}
return 0;
}
/**
* Get OMX framerate.
*/
OMX_U32 AminoOmxVideoPlayer::getOmxFramerate() {
double framerate = getFramerate();
if (framerate > 0) {
return framerate * (1 << 16);
}
//default: 25 fps
return 25 * (1 << 16);
}
/**
* Stop playback.
*/
void AminoOmxVideoPlayer::stopPlayback() {
if (!playing && !paused) {
return;
}
//stop (currently blocking implementation)
stopOmx();
}
/**
* Pause playback.
*/
bool AminoOmxVideoPlayer::pausePlayback() {
if (!playing) {
return true;
}
//pause OMX (stops reading)
if (DEBUG_OMX) {
printf("pausing OMX\n");
}
doPause = true; //signal thread to pause
pauseTime = getTime() / 1000;
if (!softwareDecoding) {
if (!setOmxSpeed(0)) {
return false;
}
}
if (DEBUG_OMX) {
printf("paused OMX\n");
}
//pause stream
stream->pause();
if (DEBUG_OMX) {
printf("paused stream\n");
}
//set state
handlePlaybackPaused();
return true;
}
/**
* Resume (stopped) playback.
*/
bool AminoOmxVideoPlayer::resumePlayback() {
if (!paused) {
return true;
}
//change time
double resumeTime = getTime() / 1000;
timeStartSys += resumeTime - pauseTime;
//resume stream
stream->resume();
//resume thread
if (!doPause) {
uv_sem_post(&pauseSem);
} else {
doPause = false;
}
//resume OMX
if (DEBUG_OMX) {
printf("resume OMX\n");
}
if (!softwareDecoding) {
setOmxSpeed(1 << 16);
}
//set state
handlePlaybackResumed();
return true;
}
/**
* Set OMX playback speed.
*/
bool AminoOmxVideoPlayer::setOmxSpeed(OMX_S32 speed) {
COMPONENT_T *clock = list[2];
OMX_TIME_CONFIG_SCALETYPE st;
memset(&st, 0, sizeof st);
st.nSize = sizeof st;
st.nVersion.nVersion = OMX_VERSION;
st.xScale = speed;
bool res = OMX_SetConfig(ILC_GET_HANDLE(clock), OMX_IndexConfigTimeScale, &st) == OMX_ErrorNone;
if (DEBUG_OMX && !res) {
printf("-> could not set OMX time scale!\n");
}
return res;
}
/**
* Software decoder.
*/
void* AminoOmxVideoPlayer::decoderThread(void *arg) {
AminoOmxVideoPlayer *player = static_cast<AminoOmxVideoPlayer *>(arg);
assert(player);
//init demuxer
player->initDemuxer();
//close stream
player->closeStream();
//done
player->threadRunning = false;
return NULL;
}
/**
* Software decoding loop.
*/
void AminoOmxVideoPlayer::initDemuxer() {
VideoDemuxer *demuxer = stream->getDemuxer();
assert(demuxer);
//set video size
videoW = demuxer->width;
videoH = demuxer->height;
//read first frame
double timeStart;
READ_FRAME_RESULT res = demuxer->readRGBFrame(timeStart);
timeStartSys = getTime() / 1000;
if (res == READ_END_OF_VIDEO) {
lastError = "empty video";
handleInitDone(false);
return;
}
if (res == READ_ERROR) {
lastError = "could not load video stream";
handleInitDone(false);
return;
}
//switch to renderer thread
texture->initVideoTexture();
//wait for texture
uv_sem_wait(&textureSem);
if (!eglImagesReady || doStop) {
//failed to create texture
handleInitDone(false);
return;
}
//texture ready
handleInitDone(true);
//playback loop
while (true) {
//check stop
if (doStop) {
//end playback
handlePlaybackStopped();
return;
}
//check pause
if (doPause) {
//wait
doPause = false; //signal we are waiting
uv_sem_wait(&pauseSem);
//next
continue;
}
//next frame
double time;
int res = demuxer->readRGBFrame(time);
double timeSys = getTime() / 1000;
if (res == READ_ERROR) {
if (DEBUG_VIDEOS) {
printf("-> read error\n");
}
handlePlaybackError();
return;
}
if (res == READ_END_OF_VIDEO) {
if (DEBUG_VIDEOS) {
printf("-> end of video\n");
}
if (loop > 0) {
loop--;
}
if (loop == 0) {
//end playback
handlePlaybackDone();
return;
}
//rewind
if (!demuxer->rewindRGB(timeStart)) {
handlePlaybackError();
return;
}
timeStartSys = getTime() / 1000;
timeSys = timeStartSys;
time = timeStart;
handleRewind();
if (DEBUG_VIDEOS) {
printf("-> rewind\n");
}
}
//correct timing
if (!demuxer->realtime) {
double timeSleep = (time - timeStart) - (timeSys - timeStartSys);
if (timeSleep > 0) {
usleep(timeSleep * 1000000);
if (DEBUG_VIDEO_TIMING) {
printf("sleep: %f ms\n", timeSleep * 1000);
}
}
}
//show
demuxer->switchRGBFrame();
//update media time
mediaTime = getTime() / 1000 - timeStartSys;
}
} | [
"bratschi@appamics.com"
] | bratschi@appamics.com |
f30461dcc74a1e7761e388187a8e9833c1f421dc | ba384da5689a4764fa9651b9a4eb7b33e4c2ab8a | /clovertrail/amc/modem-audio-manager/ModemAudioManagerInstance.h | 39a35f2e04dc1e549e18cde05787fd0b3530197e | [] | no_license | locng/android_hardware_intel | 0da734d160e941d755e709696b9409470466e04c | bc7b3b1b9786c758344443111ce6f3e870258413 | refs/heads/master | 2021-01-21T07:14:56.549271 | 2015-03-05T15:10:48 | 2015-03-05T15:14:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,083 | h | /* ModemAudioManagerInstance.h
**
** Copyright 2011 Intel Corporation
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
#pragma once
#include "ModemAudioManager.h"
#include "DualSimModemAudioManager.h"
#include "AudioATModemTypes.h"
using namespace std;
class CModemAudioManagerInstance {
public:
// Kind of factory to create either ATModemManager or DualSimATModemManager
static CModemAudioManager* get();
static CModemAudioManager* create(IModemStatusNotifier *observer);
private:
static CModemAudioManager* _pModemAudioManager;
};
| [
"angel666.ib@gmail.com"
] | angel666.ib@gmail.com |
d3d633c2758301140ad80d4d9c34083725dad951 | 367fba5df552aef1ee9aa6add6bb512b781bc6d4 | /3rdParty/nodejs/8.0.0/source/src/node_win32_etw_provider-inl.h | 9e3f088ff485db5650d1d7977c75191e2f7ce19a | [
"ICU",
"NTP",
"ISC",
"LicenseRef-scancode-openssl",
"Artistic-2.0",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause",
"NAIST-2003",
"BSD-3-Clause",
"Zlib",
"LicenseRef-scancode-unknown-license-reference",
"MIT",
"LicenseRef-scancode-unicode",
"LicenseRef-scancode-free-unknown"
] | permissive | hamoriakos/ApertusVR | 2d3e5736b26404198b222d24388bb3c1c162ee69 | 14303ab54963e52409ed376cdafae5c43004074b | refs/heads/master | 2021-09-16T00:13:48.980732 | 2017-06-28T18:23:14 | 2017-06-28T18:23:14 | 105,749,913 | 0 | 1 | MIT | 2018-06-13T13:54:38 | 2017-10-04T09:11:13 | C++ | UTF-8 | C++ | false | false | 12,094 | h | // Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
#ifndef SRC_NODE_WIN32_ETW_PROVIDER_INL_H_
#define SRC_NODE_WIN32_ETW_PROVIDER_INL_H_
#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#include "node_win32_etw_provider.h"
#include "node_etw_provider.h"
#if defined(_WIN64)
# define ETW_WRITE_INTPTR_DATA ETW_WRITE_INT64_DATA
#else
# define ETW_WRITE_INTPTR_DATA ETW_WRITE_INT32_DATA
#endif
namespace node {
// From node_win32_etw_provider.cc
extern REGHANDLE node_provider;
extern EventWriteFunc event_write;
extern int events_enabled;
#define ETW_WRITE_STRING_DATA(data_descriptor, data) \
EventDataDescCreate(data_descriptor, \
data, \
(strlen(data) + 1) * sizeof(*data));
#define ETW_WRITE_INT32_DATA(data_descriptor, data) \
EventDataDescCreate(data_descriptor, data, sizeof(int32_t));
#define ETW_WRITE_INT64_DATA(data_descriptor, data) \
EventDataDescCreate(data_descriptor, data, sizeof(int64_t));
#define ETW_WRITE_ADDRESS_DATA(data_descriptor, data) \
EventDataDescCreate(data_descriptor, data, sizeof(intptr_t));
#define ETW_WRITE_INT16_DATA(data_descriptor, data) \
EventDataDescCreate(data_descriptor, data, sizeof(int16_t));
#define ETW_WRITE_WSTRING_DATA_LENGTH(data_descriptor, data, data_len_bytes) \
EventDataDescCreate(data_descriptor, \
data, \
data_len_bytes);
#define ETW_WRITE_NET_CONNECTION(descriptors, conn) \
ETW_WRITE_INT32_DATA(descriptors, &conn->fd); \
ETW_WRITE_INT32_DATA(descriptors + 1, &conn->port); \
ETW_WRITE_STRING_DATA(descriptors + 2, conn->remote); \
ETW_WRITE_INT32_DATA(descriptors + 3, &conn->buffered);
#define ETW_WRITE_HTTP_SERVER_REQUEST(descriptors, req) \
ETW_WRITE_STRING_DATA(descriptors, req->url); \
ETW_WRITE_STRING_DATA(descriptors + 1, req->method); \
ETW_WRITE_STRING_DATA(descriptors + 2, req->forwardedFor);
#define ETW_WRITE_HTTP_CLIENT_REQUEST(descriptors, req) \
ETW_WRITE_STRING_DATA(descriptors, req->url); \
ETW_WRITE_STRING_DATA(descriptors + 1, req->method);
#define ETW_WRITE_GC(descriptors, type, flags) \
ETW_WRITE_INT32_DATA(descriptors, &type); \
ETW_WRITE_INT32_DATA(descriptors + 1, &flags);
#define ETW_WRITE_V8ADDRESSCHANGE(descriptors, addr1, addr2) \
ETW_WRITE_ADDRESS_DATA(descriptors, &addr1); \
ETW_WRITE_ADDRESS_DATA(descriptors + 1, &addr2);
#define ETW_WRITE_JSMETHOD_LOADUNLOAD(descriptors, \
context, \
startAddr, \
size, \
id, \
flags, \
rangeId, \
sourceId, \
line, \
col, \
name, \
name_len_bytes) \
ETW_WRITE_ADDRESS_DATA(descriptors, &context); \
ETW_WRITE_ADDRESS_DATA(descriptors + 1, &startAddr); \
ETW_WRITE_INT64_DATA(descriptors + 2, &size); \
ETW_WRITE_INTPTR_DATA(descriptors + 3, &id); \
ETW_WRITE_INT16_DATA(descriptors + 4, &flags); \
ETW_WRITE_INT16_DATA(descriptors + 5, &rangeId); \
ETW_WRITE_INT64_DATA(descriptors + 6, &sourceId); \
ETW_WRITE_INT32_DATA(descriptors + 7, &line); \
ETW_WRITE_INT32_DATA(descriptors + 8, &col); \
ETW_WRITE_WSTRING_DATA_LENGTH(descriptors + 9, name, name_len_bytes);
#define ETW_WRITE_EVENT(eventDescriptor, dataDescriptors) \
DWORD status = event_write(node_provider, \
&eventDescriptor, \
sizeof(dataDescriptors) / \
sizeof(*dataDescriptors), \
dataDescriptors); \
CHECK_EQ(status, ERROR_SUCCESS);
#define ETW_WRITE_EMPTY_EVENT(eventDescriptor) \
DWORD status = event_write(node_provider, \
&eventDescriptor, \
0, \
NULL); \
CHECK_EQ(status, ERROR_SUCCESS);
void NODE_HTTP_SERVER_REQUEST(node_dtrace_http_server_request_t* req,
node_dtrace_connection_t* conn, const char *remote, int port,
const char *method, const char *url, int fd) {
EVENT_DATA_DESCRIPTOR descriptors[7];
ETW_WRITE_HTTP_SERVER_REQUEST(descriptors, req);
ETW_WRITE_NET_CONNECTION(descriptors + 3, conn);
ETW_WRITE_EVENT(NODE_HTTP_SERVER_REQUEST_EVENT, descriptors);
}
void NODE_HTTP_SERVER_RESPONSE(node_dtrace_connection_t* conn,
const char *remote, int port, int fd) {
EVENT_DATA_DESCRIPTOR descriptors[4];
ETW_WRITE_NET_CONNECTION(descriptors, conn);
ETW_WRITE_EVENT(NODE_HTTP_SERVER_RESPONSE_EVENT, descriptors);
}
void NODE_HTTP_CLIENT_REQUEST(node_dtrace_http_client_request_t* req,
node_dtrace_connection_t* conn, const char *remote, int port,
const char *method, const char *url, int fd) {
EVENT_DATA_DESCRIPTOR descriptors[6];
ETW_WRITE_HTTP_CLIENT_REQUEST(descriptors, req);
ETW_WRITE_NET_CONNECTION(descriptors + 2, conn);
ETW_WRITE_EVENT(NODE_HTTP_CLIENT_REQUEST_EVENT, descriptors);
}
void NODE_HTTP_CLIENT_RESPONSE(node_dtrace_connection_t* conn,
const char *remote, int port, int fd) {
EVENT_DATA_DESCRIPTOR descriptors[4];
ETW_WRITE_NET_CONNECTION(descriptors, conn);
ETW_WRITE_EVENT(NODE_HTTP_CLIENT_RESPONSE_EVENT, descriptors);
}
void NODE_NET_SERVER_CONNECTION(node_dtrace_connection_t* conn,
const char *remote, int port, int fd) {
EVENT_DATA_DESCRIPTOR descriptors[4];
ETW_WRITE_NET_CONNECTION(descriptors, conn);
ETW_WRITE_EVENT(NODE_NET_SERVER_CONNECTION_EVENT, descriptors);
}
void NODE_NET_STREAM_END(node_dtrace_connection_t* conn,
const char *remote, int port, int fd) {
EVENT_DATA_DESCRIPTOR descriptors[4];
ETW_WRITE_NET_CONNECTION(descriptors, conn);
ETW_WRITE_EVENT(NODE_NET_STREAM_END_EVENT, descriptors);
}
void NODE_GC_START(v8::GCType type,
v8::GCCallbackFlags flags,
v8::Isolate* isolate) {
if (events_enabled > 0) {
EVENT_DATA_DESCRIPTOR descriptors[2];
ETW_WRITE_GC(descriptors, type, flags);
ETW_WRITE_EVENT(NODE_GC_START_EVENT, descriptors);
}
}
void NODE_GC_DONE(v8::GCType type,
v8::GCCallbackFlags flags,
v8::Isolate* isolate) {
if (events_enabled > 0) {
EVENT_DATA_DESCRIPTOR descriptors[2];
ETW_WRITE_GC(descriptors, type, flags);
ETW_WRITE_EVENT(NODE_GC_DONE_EVENT, descriptors);
}
}
void NODE_V8SYMBOL_REMOVE(const void* addr1, const void* addr2) {
if (events_enabled > 0) {
EVENT_DATA_DESCRIPTOR descriptors[2];
ETW_WRITE_V8ADDRESSCHANGE(descriptors, addr1, addr2);
ETW_WRITE_EVENT(NODE_V8SYMBOL_REMOVE_EVENT, descriptors);
}
}
void NODE_V8SYMBOL_MOVE(const void* addr1, const void* addr2) {
if (events_enabled > 0) {
EVENT_DATA_DESCRIPTOR descriptors[2];
ETW_WRITE_V8ADDRESSCHANGE(descriptors, addr1, addr2);
ETW_WRITE_EVENT(NODE_V8SYMBOL_MOVE_EVENT, descriptors);
}
}
void NODE_V8SYMBOL_RESET() {
if (events_enabled > 0) {
ETW_WRITE_EMPTY_EVENT(NODE_V8SYMBOL_RESET_EVENT);
}
}
#define SETSYMBUF(s) \
wcscpy(symbuf, s); \
symbol_len = arraysize(s) - 1;
void NODE_V8SYMBOL_ADD(LPCSTR symbol,
int symbol_len,
const void* addr1,
int len) {
if (events_enabled > 0) {
wchar_t symbuf[128];
if (symbol == nullptr) {
SETSYMBUF(L"nullptr");
} else {
symbol_len = MultiByteToWideChar(CP_ACP,
0,
symbol,
symbol_len,
symbuf,
128);
if (symbol_len == 0) {
SETSYMBUF(L"Invalid");
} else {
if (symbol_len > 127) {
symbol_len = 127;
}
symbuf[symbol_len] = L'\0';
}
}
void* context = nullptr;
INT64 size = (INT64)len;
INT_PTR id = (INT_PTR)addr1;
INT16 flags = 0;
INT16 rangeid = 1;
INT32 col = 1;
INT32 line = 1;
INT64 sourceid = 0;
EVENT_DATA_DESCRIPTOR descriptors[10];
ETW_WRITE_JSMETHOD_LOADUNLOAD(descriptors,
context,
addr1,
size,
id,
flags,
rangeid,
sourceid,
line,
col,
symbuf,
(symbol_len + 1) * sizeof(symbuf[0]));
ETW_WRITE_EVENT(MethodLoad, descriptors);
}
}
#undef SETSYMBUF
bool NODE_HTTP_SERVER_REQUEST_ENABLED() { return events_enabled > 0; }
bool NODE_HTTP_SERVER_RESPONSE_ENABLED() { return events_enabled > 0; }
bool NODE_HTTP_CLIENT_REQUEST_ENABLED() { return events_enabled > 0; }
bool NODE_HTTP_CLIENT_RESPONSE_ENABLED() { return events_enabled > 0; }
bool NODE_NET_SERVER_CONNECTION_ENABLED() { return events_enabled > 0; }
bool NODE_NET_STREAM_END_ENABLED() { return events_enabled > 0; }
bool NODE_V8SYMBOL_ENABLED() { return events_enabled > 0; }
} // namespace node
#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
#endif // SRC_NODE_WIN32_ETW_PROVIDER_INL_H_
| [
"akos.hamori@sztaki.mta.hu"
] | akos.hamori@sztaki.mta.hu |
644867459bbdc766411cc836cacb6675f95776db | 6b2a8dd202fdce77c971c412717e305e1caaac51 | /solutions_5662291475300352_1/C++/pwahs/c.cpp | 146b16b18a98638c9e519e27f8d3bd370b2bcef4 | [] | no_license | alexandraback/datacollection | 0bc67a9ace00abbc843f4912562f3a064992e0e9 | 076a7bc7693f3abf07bfdbdac838cb4ef65ccfcf | refs/heads/master | 2021-01-24T18:27:24.417992 | 2017-05-23T09:23:38 | 2017-05-23T09:23:38 | 84,313,442 | 2 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 2,174 | cpp | #include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
using namespace std;
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define dbg(args...) {debug,args; cerr << endl;}
#define mp make_pair
#define mt(a,b,c) mp(a,mp(b,c))
#define P1(a) (a).first
#define P2(a) (a).second
#define T1(a) (a).first
#define T2(a) (a).second.first
#define T3(a) (a).second.second
#define INF 1e20
#define EPS 1e-8
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<int,pii> tiii;
class debu{
public:
template<class someClass>
debu & operator,(someClass arg){
cerr << arg << " ";
return *this;
}
} debug;
void init(){
cout << setprecision(8)<< fixed;
}
int solve(int testnr){
int N;
cin >> N;
vector<int> D(N), H(N), M(N);
vector<int> d, m;
for(int i=0;i<N;i++){
cin >> D[i] >> H[i] >> M[i];
for(int j=0;j<H[i];j++) {
d.push_back(D[i]);
m.push_back(M[i] + j);
}
}
vector< pair<double, int> > times;
double longest = 0;
for (int i=0;i<d.size();i++){
double time = m[i] / 360.0 * (360.0 - d[i]);
times.push_back(make_pair(time, i));
longest = max(longest, time);
}
sort(times.begin(), times.end());
int best = times.size();
for (int infront = 0; infront < times.size(); infront++) {
int take_over = times.size() - 1 - infront;
double arrive_at_goal = times[infront].first;
for (int i=0;i < infront;i++){
double first_arrival = times[i].first;
take_over += (((int)(arrive_at_goal - first_arrival + 1e-6)) / m[times[i].second]);
}
best = min(best, take_over);
}
return best;
}
int main(){
init();
int T;
cin >> T;
for(int i=1;i<=T;i++){
cout << "Case #" << i << ": " << solve(i) << "\n";
}
return 0;
}
| [
"eewestman@gmail.com"
] | eewestman@gmail.com |
cb17c0dae1dafcefdd38e4e05f41b8803b566568 | 84a557805488ebd5fedcef318d4af5f308d4bb70 | /engine/InputSystem.hpp | 6a06cdaae601ac2979388381d767aded5f5cf544 | [
"CC-BY-4.0"
] | permissive | GenBrg/MagicCastlevania | 42e3e49b25d60e240bce335d755650f2fee1f6c1 | 76ed248d4f0362ea92d29a159a2027d5b16c8a7b | refs/heads/main | 2023-01-30T07:44:33.987324 | 2020-12-12T03:41:39 | 2020-12-12T03:41:39 | 307,784,734 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 781 | hpp | #pragma once
#include "Singleton.hpp"
#include <SDL.h>
#include <unordered_map>
#include <string>
#include <functional>
class InputSystem;
/**
* Input system that maps each key code to action.
* @author Jiasheng Zhou
*/
class InputSystem : public Singleton<InputSystem> {
public:
struct KeyState {
uint8_t downs = 0;
uint8_t pressed = 0;
bool released = false;
void Clear();
};
void Register(SDL_Keycode keycode, const std::function<void(KeyState&, float)>& action);
void Unregister(SDL_Keycode keycode);
bool OnKeyEvent(const SDL_Event& evt);
void Update(float elapsed);
void ClearKeyStates();
private:
std::unordered_map<SDL_Keycode, std::function<void(KeyState&, float)>> input_action_map_;
std::unordered_map<SDL_Keycode, KeyState> key_states_;
};
| [
"2322168080@qq.com"
] | 2322168080@qq.com |
ad3070cb3c2f597cc3fde4ce41abe31d92c97e64 | f0b7bcc41298354b471a72a7eeafe349aa8655bf | /codebase/apps/Radx/src/RadxApRemoval/Args.cc | 44d64795f577633df4f9ac34829d1926bb319da6 | [
"BSD-3-Clause"
] | permissive | NCAR/lrose-core | 23abeb4e4f1b287725dc659fb566a293aba70069 | be0d059240ca442883ae2993b6aa112011755688 | refs/heads/master | 2023-09-01T04:01:36.030960 | 2023-08-25T00:41:16 | 2023-08-25T00:41:16 | 51,408,988 | 90 | 53 | NOASSERTION | 2023-08-18T21:59:40 | 2016-02-09T23:36:25 | C++ | UTF-8 | C++ | false | false | 23,112 | cc | // *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*
// ** Copyright UCAR (c) 1990 - 2016
// ** University Corporation for Atmospheric Research (UCAR)
// ** National Center for Atmospheric Research (NCAR)
// ** Boulder, Colorado, USA
// ** BSD licence applies - redistribution and use in source and binary
// ** forms, with or without modification, are permitted provided that
// ** the following conditions are met:
// ** 1) If the software is modified to produce derivative works,
// ** such modified software should be clearly marked, so as not
// ** to confuse it with the version available from UCAR.
// ** 2) Redistributions of source code must retain the above copyright
// ** notice, this list of conditions and the following disclaimer.
// ** 3) 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.
// ** 4) Neither the name of UCAR nor the names of its contributors,
// ** if any, may be used to endorse or promote products derived from
// ** this software without specific prior written permission.
// ** DISCLAIMER: THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS
// ** OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
// ** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
// *=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*
//////////////////////////////////////////////////////////
// Args.cc : command line args
//
// Mike Dixon, RAP, NCAR, P.O.Box 3000, Boulder, CO, 80307-3000, USA
//
// March 2014
//
//////////////////////////////////////////////////////////
#include "Args.hh"
#include "Params.hh"
#include <string>
#include <iostream>
#include <Radx/RadxTime.hh>
using namespace std;
// Constructor
Args::Args ()
{
TDRP_init_override(&override);
startTime = 0;
endTime = 0;
}
// Destructor
Args::~Args ()
{
TDRP_free_override(&override);
}
// parse the command line
//
// returns 0 on success, -1 on failure
int Args::parse (int argc, char **argv, string &prog_name)
{
_progName = prog_name;
char tmp_str[BUFSIZ];
bool OK = true;
vector<string> fields;
// loop through args
for (int i = 1; i < argc; i++) {
if (!strcmp(argv[i], "--") ||
!strcmp(argv[i], "-h") ||
!strcmp(argv[i], "-help") ||
!strcmp(argv[i], "-man")) {
_usage(cout);
exit (0);
} else if (!strcmp(argv[i], "-d") ||
!strcmp(argv[i], "-debug")) {
sprintf(tmp_str, "debug = DEBUG_NORM;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-v") ||
!strcmp(argv[i], "-verbose")) {
sprintf(tmp_str, "debug = DEBUG_VERBOSE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-vv") ||
!strcmp(argv[i], "-extra")) {
sprintf(tmp_str, "debug = DEBUG_EXTRA;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-instance")) {
if (i < argc - 1) {
sprintf(tmp_str, "instance = %s;", argv[i+1]);
TDRP_add_override(&override, tmp_str);
}
} else if (!strcmp(argv[i], "-ag")) {
sprintf(tmp_str, "aggregate_sweep_files_on_read = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-ag_all")) {
sprintf(tmp_str, "aggregate_all_files_on_read = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-disag")) {
sprintf(tmp_str, "write_individual_sweeps = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-native")) {
sprintf(tmp_str, "output_native_byte_order = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-cfradial")) {
sprintf(tmp_str, "output_format = OUTPUT_FORMAT_CFRADIAL;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-dorade")) {
sprintf(tmp_str, "output_format = OUTPUT_FORMAT_DORADE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-foray")) {
sprintf(tmp_str, "output_format = OUTPUT_FORMAT_FORAY;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-nexrad")) {
sprintf(tmp_str, "output_format = OUTPUT_FORMAT_NEXRAD;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-uf")) {
sprintf(tmp_str, "output_format = OUTPUT_FORMAT_UF;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-mdv")) {
sprintf(tmp_str, "output_format = OUTPUT_FORMAT_MDV_RADIAL;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-cf_classic")) {
sprintf(tmp_str, "netcdf_style = CLASSIC;");
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "output_format = OUTPUT_FORMAT_CFRADIAL;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-cf_nc64bit")) {
sprintf(tmp_str, "netcdf_style = NC64BIT;");
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "output_format = OUTPUT_FORMAT_CFRADIAL;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-cf_netcdf4")) {
sprintf(tmp_str, "netcdf_style = NETCDF4;");
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "output_format = OUTPUT_FORMAT_CFRADIAL;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-cf_netcdf4_classic")) {
sprintf(tmp_str, "netcdf_style = NETCDF4_CLASSIC;");
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "output_format = OUTPUT_FORMAT_CFRADIAL;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-force_vary")) {
sprintf(tmp_str, "output_force_ngates_vary = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-out_start")) {
sprintf(tmp_str, "output_filename_mode = START_TIME_ONLY;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-out_end")) {
sprintf(tmp_str, "output_filename_mode = END_TIME_ONLY;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-rem_miss")) {
sprintf(tmp_str, "remove_rays_with_all_data_missing = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-rem_trans")) {
sprintf(tmp_str, "remove_rays_with_antenna_transitions = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-preserve_sweeps")) {
sprintf(tmp_str, "preserve_sweeps = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-keep_long")) {
sprintf(tmp_str, "remove_long_range_rays = FALSE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-rem_short")) {
sprintf(tmp_str, "remove_short_range_rays = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-trim_sur")) {
sprintf(tmp_str, "trim_surveillance_sweeps_to_360deg = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-const_ngates")) {
sprintf(tmp_str, "set_ngates_constant = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-ldata")) {
sprintf(tmp_str, "write_latest_data_info = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-change_lat_sign")) {
sprintf(tmp_str, "change_radar_latitude_sign = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-apply_georefs")) {
sprintf(tmp_str, "apply_georeference_corrections = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-to_float32")) {
sprintf(tmp_str, "set_output_encoding_for_all_fields = TRUE;");
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "output_encoding = OUTPUT_ENCODING_FLOAT32;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-to_int32")) {
sprintf(tmp_str, "set_output_encoding_for_all_fields = TRUE;");
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "output_encoding = OUTPUT_ENCODING_INT32;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-to_int16")) {
sprintf(tmp_str, "set_output_encoding_for_all_fields = TRUE;");
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "output_encoding = OUTPUT_ENCODING_INT16;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-to_int08")) {
sprintf(tmp_str, "set_output_encoding_for_all_fields = TRUE;");
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "output_encoding = OUTPUT_ENCODING_INT08;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-start")) {
if (i < argc - 1) {
startTime = RadxTime::parseDateTime(argv[++i]);
if (startTime == RadxTime::NEVER) {
OK = false;
} else {
sprintf(tmp_str, "mode = ARCHIVE;");
TDRP_add_override(&override, tmp_str);
}
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-end")) {
if (i < argc - 1) {
endTime = RadxTime::parseDateTime(argv[++i]);
if (endTime == RadxTime::NEVER) {
OK = false;
} else {
sprintf(tmp_str, "mode = ARCHIVE;");
TDRP_add_override(&override, tmp_str);
}
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-path") || !strcmp(argv[i], "-f")) {
if (i < argc - 1) {
// load up file list vector. Break at next arg which
// start with -
for (int j = i + 1; j < argc; j++) {
if (argv[j][0] == '-') {
break;
} else {
inputFileList.push_back(argv[j]);
}
}
sprintf(tmp_str, "mode = FILELIST;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-field")) {
if (i < argc - 1) {
fields.push_back(argv[++i]);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-write_other")) {
sprintf(tmp_str, "write_other_fields_unchanged = TRUE;");
TDRP_add_override(&override, tmp_str);
} else if (!strcmp(argv[i], "-lat")) {
if (i < argc - 1) {
sprintf(tmp_str, "radar_latitude_deg = %s;", argv[++i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "override_radar_location = TRUE;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-lon")) {
if (i < argc - 1) {
sprintf(tmp_str, "radar_longitude_deg = %s;", argv[++i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "override_radar_location = TRUE;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-alt")) {
if (i < argc - 1) {
sprintf(tmp_str, "radar_altitude_meters = %s;", argv[++i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "override_radar_location = TRUE;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-name")) {
if (i < argc - 1) {
sprintf(tmp_str, "instrument_name = \"%s\";", argv[++i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "override_instrument_name = TRUE;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-max_range")) {
if (i < argc - 1) {
sprintf(tmp_str, "max_range_km = %s;", argv[++i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "set_max_range = TRUE;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-compress")) {
if (i < argc - 1) {
sprintf(tmp_str, "output_compressed = TRUE;");
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "compression_level = %s;", argv[++i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "netcdf_style = NETCDF4;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-indir")) {
if (i < argc - 1) {
sprintf(tmp_str, "input_dir = \"%s\";", argv[++i]);
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-outdir")) {
if (i < argc - 1) {
sprintf(tmp_str, "output_dir = \"%s\";", argv[++i]);
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-fixed_angle")) {
if (i < argc - 1) {
i++;
sprintf(tmp_str, "lower_fixed_angle_limit = %s;", argv[i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "upper_fixed_angle_limit = %s;", argv[i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "set_fixed_angle_limits = true;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-fixed_angle_max")) {
if (i < argc - 1) {
i++;
sprintf(tmp_str, "upper_fixed_angle_limit = %s;", argv[i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "set_fixed_angle_limits = true;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-sweep")) {
if (i < argc - 1) {
i++;
sprintf(tmp_str, "lower_sweep_num = %s;", argv[i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "upper_sweep_num = %s;", argv[i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "set_sweep_num_limits = true;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-sweep_max")) {
if (i < argc - 1) {
i++;
sprintf(tmp_str, "read_upper_sweep_num = %s;", argv[i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "set_sweep_num_limits = true;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
} else if (!strcmp(argv[i], "-radar_num")) {
if (i < argc - 1) {
i++;
sprintf(tmp_str, "read_radar_num = %s;", argv[i]);
TDRP_add_override(&override, tmp_str);
sprintf(tmp_str, "read_set_radar_num = true;");
TDRP_add_override(&override, tmp_str);
} else {
OK = false;
}
}
} // i
// set fields if specified
if (fields.size() > 0) {
sprintf(tmp_str, "set_output_fields = true;");
TDRP_add_override(&override, tmp_str);
string nameStr = "output_fields = { ";
for (size_t ii = 0; ii < fields.size(); ii++) {
string fieldStr = "\"";
fieldStr += fields[ii];
fieldStr += "\", ";
nameStr += "{ ";
nameStr += fieldStr;
nameStr += fieldStr;
nameStr += fieldStr;
nameStr += fieldStr;
nameStr += "\"\", ";
nameStr += "OUTPUT_ENCODING_ASIS, ";
nameStr += "SCALING_DYNAMIC, ";
nameStr += "0.01, ";
nameStr += "0.0 ";
nameStr += " }";
if (ii != fields.size() - 1) {
nameStr += ", ";
} else {
nameStr += " ";
}
}
nameStr += "};";
TDRP_add_override(&override, nameStr.c_str());
} // if (fields.size() ...
if (!OK) {
_usage(cerr);
return -1;
}
return 0;
}
void Args::_usage(ostream &out)
{
out << "Usage: " << _progName << " [args as below]\n"
<< "Options:\n"
<< "\n"
<< " [ -h ] produce this list.\n"
<< "\n"
<< " [ -ag ] aggregate sweep files into volume on read.\n"
<< " Files with the SAME VOLUME NUMBER in the name are aggregated.\n"
<< " Applies to CfRadial and DORADE sweep files.\n"
<< "\n"
<< " [ -ag_all ] aggregate files in input list on read.\n"
<< " ALL FILES in the input list are aggregated into a volume.\n"
<< " See '-f' option.\n"
<< "\n"
<< " [ -alt ? ] override radar altitude (m)\n"
<< "\n"
<< " [ -apply_georefs] apply georeference corrections on read.\n"
<< " For moving platforms, measured georeference information is sometimes\n"
<< " available. If so, this is applied and appropriate corrections made.\n"
<< " Earth-centric azimuth and elevation angles will be computed.\n"
<< "\n"
<< " [ -change_lat_sign] change the sign of the radar latitude\n"
<< " Useful for RAPIC files that always have a positive latitude.\n"
<< "\n"
<< " [ -cfradial ] convert to cfradial (the default)\n"
<< "\n"
<< " [ -cf_classic ] output classic-style netcdf (the default)\n"
<< " [ -cf_netcdf4 ] output netcdf4 style\n"
<< " [ -cf_classic4 ] output classic-style netcdf4\n"
<< " [ -cf_nc64bit ] output 64-bit NC netcdf\n"
<< " The above only apply to cfradial output.\n"
<< "\n"
<< " [ -const_ngates ] force number of gates constant for all rays\n"
<< " Added gates will be filled with missing values\n"
<< "\n"
<< " [ -compress ? ] compress output\n"
<< " specifiy compression level [1-9]\n"
<< " For cfradial, forces netcdf4 mode\n"
<< "\n"
<< " [ -d, -debug ] print debug messages\n"
<< "\n"
<< " [ -dorade ] convert to dorade\n"
<< "\n"
<< " [ -disag ] dis-aggregate into sweep files on write\n"
<< " optional for CfRadial files\n"
<< " always applies to DORADE sweep files\n"
<< "\n"
<< " [ -fixed_angle ? ] set single fixed_angle\n"
<< " or minimum - see '-fixed_ang_max'\n"
<< "\n"
<< " [ -fixed_angle_max ? ] set max fixed_angle\n"
<< " use '-fixed_ang' for setting minimum\n"
<< "\n"
<< " [ -end \"yyyy mm dd hh mm ss\"] end time\n"
<< " Sets mode to ARCHIVE\n"
<< "\n"
<< " [ -f, -paths ? ] set file paths\n"
<< " Sets mode to FILELIST\n"
<< "\n"
<< " [ -field ? ] Specify particular field\n"
<< " Specify name or number\n"
<< " Use multiple -field args for multiple fields\n"
<< " If not specified, all fields will be used\n"
<< "\n"
<< " [ -foray ] convert to FORAY-1 netcdf\n"
<< "\n"
<< " [ -force_vary ] force use of ragged arrays for CfRadial\n"
<< " even if ngates is constant for all rays\n"
<< "\n"
<< " [ -indir ? ] set input directory\n"
<< "\n"
<< " [ -instance ?] specify the instance\n"
<< "\n"
<< " [ -keep_long ] keep long range rays\n"
<< " Keep NEXRAD long-range non-Doppler sweeps\n"
<< " Default is to remove them\n"
<< "\n"
<< " [ -lat ? ] override radar latitude (deg)\n"
<< "\n"
<< " [ -lon ? ] override radar longitude (deg)\n"
<< "\n"
<< " [ -ldata ] write _latest_data_info files\n"
<< "\n"
<< " [ -max_range ? ] set max range (km)\n"
<< "\n"
<< " [ -mdv ] convert to MDV in radial coords\n"
<< "\n"
<< " [ -native ] output in host-native byte ordering\n"
<< "\n"
<< " [ -name ? ] override instrument name\n"
<< "\n"
<< " [ -nexrad ] convert to NEXRAD archive level 2\n"
<< "\n"
<< " [ -outdir ? ] set output directory\n"
<< "\n"
<< " [ -out_end ? ] compute output path using end time\n"
<< " default is to use both start and end times\n"
<< "\n"
<< " [ -out_start ? ] compute output path using start time\n"
<< " default is to use both start and end times\n"
<< "\n"
<< " [ -preserve_sweeps ] preserve sweep details as they are in file.\n"
<< " This generally applies to NEXRAD data - by default we\n"
<< " consolidate sweeps by combining split-cut sweeps\n"
<< " into a single sweep.\n"
<< " If this flag is true, we leave the sweeps unchanged.\n"
<< "\n"
<< " [ -radar_num ? ] set radar number\n"
<< " Applies to NOAA HRD data. LF radar = 1, TA radar = 2\n"
<< " Generally not needed\n"
<< "\n"
<< " [ -rem_miss ] remove rays in which data at all gates and\n"
<< " for all fields is missing\n"
<< "\n"
<< " [ -rem_short ] remove short range rays\n"
<< " Remove NEXRAD short-range Doppler sweeps\n"
<< "\n"
<< " [ -rem_trans ] remove rays with antenna transitions\n"
<< "\n"
<< " [ -start \"yyyy mm dd hh mm ss\"] start time\n"
<< " Sets mode to ARCHIVE\n"
<< "\n"
<< " [ -sweep ? ] set single sweep number\n"
<< " or minimum - see '-sweep_max'\n"
<< "\n"
<< " [ -sweep_max ? ] set max sweep number\n"
<< " use '-sweep' for setting minimum\n"
<< "\n"
<< " [ -trim_sur ] trim surveillance sweeps to 360 degrees\n"
<< " Remove extra rays in each surveillance sweep\n"
<< "\n"
<< " [ -to_float32 ] convert all fields to 32-bit floats\n"
<< " [ -to_int32 ] convert all fields to 16-bit signed integers\n"
<< " [ -to_int16 ] convert all fields to 16-bit signed integers\n"
<< " [ -to_in08 ] convert all fields to 8-bit signed integers\n"
<< "\n"
<< " [ -uf ] convert to universal format\n"
<< "\n"
<< " [ -v, -verbose ] print verbose debug messages\n"
<< "\n"
<< " [ -vv, -extra ] print extra verbose debug messages\n"
<< "\n"
<< " [ -write_other ] option to write other fields unchanged.\n"
<< " Default is that if -fields is used, only the specified fields\n"
<< " will be written in the output files.\n"
<< "\n"
<< endl;
out << "NOTE: You do not need to use the params option (see below).\n"
<< " If no params are specified, you deal with the whole file.\n"
<< endl;
Params::usage(out);
}
| [
"dixon@ucar.edu"
] | dixon@ucar.edu |
c6dfe0f12986f040b7f134dcf78fbbf676333692 | 9c434860e19c54936a9c4626779690a98025b022 | /include/physics/CollisionData.hpp | 29546c37233ff0dba55036b38625a270a8442a76 | [] | no_license | lihaisa/kabanero | 2ddf8fbfbd7e774211037cde373a3e00108a899f | 7b6cb99118f9acd0f373c7ecc6e6a1a0db29da2f | refs/heads/master | 2021-01-11T11:33:31.464529 | 2016-12-18T21:25:43 | 2016-12-18T21:25:43 | 79,952,386 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 596 | hpp | #pragma once
#include "minebombers/attachments/CollisionMaterialAttachment.hpp"
#include <string>
#include <memory>
class CollisionData {
public:
CollisionData(std::string path, std::shared_ptr<CollisionMaterialAttachment> materialAttachment) :
_path(path),
_materialAttachment(materialAttachment) {}
auto path() -> std::string {
return _path;
}
auto collisionMaterialAttachment() -> std::shared_ptr<CollisionMaterialAttachment> {
return _materialAttachment;
}
private:
std::string _path;
std::shared_ptr<CollisionMaterialAttachment> _materialAttachment;
};
| [
"pesola.toni@gmail.com"
] | pesola.toni@gmail.com |
2700d334d5211a2d22743f81b82d83cb7105e06d | 0783dd95ede971b91728a21074f11b70fd20aa55 | /backwardFacingStep_baseCase_LRR/1500/R | 3852954eae88310a1d360db8e74429478dd449a1 | [] | no_license | bshambaugh/openfoam-experiments2 | 0c5430940ddb04c5f85d0fbdd09a7ae01f0ed3f1 | dbd9ce7bec30d897f34da8871188fce3a5564a4d | refs/heads/master | 2020-04-14T06:49:39.690493 | 2019-01-01T23:03:39 | 2019-01-01T23:03:39 | 163,696,599 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 314,883 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 4.1 |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volSymmTensorField;
location "1500";
object R;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 2 -2 0 0 0 0];
internalField nonuniform List<symmTensor>
6820
(
(0.205732 -0.0655181 0 0.119059 0 0.158783)
(0.282327 -0.0957377 0 0.109535 0 0.187468)
(0.351932 -0.111301 0 0.106212 0 0.215544)
(0.414145 -0.120959 0 0.107184 0 0.242572)
(0.468925 -0.12821 0 0.110858 0 0.268123)
(0.516415 -0.134402 0 0.116011 0 0.291794)
(0.556894 -0.139947 0 0.121756 0 0.313246)
(0.590786 -0.144894 0 0.127486 0 0.332258)
(0.618629 -0.149196 0 0.132821 0 0.348735)
(0.641034 -0.152808 0 0.137552 0 0.362695)
(0.658635 -0.155725 0 0.141583 0 0.374247)
(0.672059 -0.157978 0 0.144898 0 0.383564)
(0.681903 -0.15962 0 0.147528 0 0.390858)
(0.688719 -0.160724 0 0.149532 0 0.396359)
(0.693005 -0.161362 0 0.15098 0 0.4003)
(0.695201 -0.161607 0 0.151946 0 0.402904)
(0.695691 -0.161527 0 0.152504 0 0.40438)
(0.694804 -0.161183 0 0.152719 0 0.404916)
(0.692823 -0.160629 0 0.152653 0 0.404681)
(0.689983 -0.15991 0 0.152359 0 0.40382)
(0.686485 -0.159065 0 0.151883 0 0.402461)
(0.682494 -0.158128 0 0.151264 0 0.40071)
(0.678145 -0.157125 0 0.150536 0 0.39866)
(0.673552 -0.15608 0 0.149727 0 0.396388)
(0.668807 -0.15501 0 0.14886 0 0.393956)
(0.663984 -0.15393 0 0.147955 0 0.391418)
(0.659144 -0.152853 0 0.147027 0 0.388817)
(0.654334 -0.151789 0 0.14609 0 0.386189)
(0.649592 -0.150745 0 0.145154 0 0.383563)
(0.644952 -0.149726 0 0.144227 0 0.380963)
(0.640427 -0.148745 0 0.143317 0 0.378403)
(0.636119 -0.147817 0 0.142462 0 0.375936)
(0.633189 -0.147815 0 0.142585 0 0.37401)
(0.141614 -0.00846611 0 0.126763 0 0.13657)
(0.150539 -0.0154135 0 0.119378 0 0.139441)
(0.159409 -0.0210922 0 0.112607 0 0.141974)
(0.168024 -0.0259312 0 0.106663 0 0.144249)
(0.176201 -0.0301002 0 0.101596 0 0.146285)
(0.183857 -0.0337139 0 0.097394 0 0.148111)
(0.190973 -0.0368714 0 0.0939942 0 0.149758)
(0.197552 -0.0396512 0 0.0913087 0 0.151252)
(0.20361 -0.0421152 0 0.0892405 0 0.152615)
(0.20918 -0.0443157 0 0.0876945 0 0.153866)
(0.214303 -0.0462989 0 0.0865824 0 0.155023)
(0.219029 -0.0481053 0 0.0858255 0 0.156102)
(0.223409 -0.0497697 0 0.0853555 0 0.15712)
(0.227493 -0.0513217 0 0.0851151 0 0.158091)
(0.23133 -0.0527853 0 0.0850569 0 0.159027)
(0.234967 -0.0541803 0 0.0851425 0 0.159941)
(0.238442 -0.055522 0 0.0853412 0 0.160843)
(0.24179 -0.0568222 0 0.0856288 0 0.161742)
(0.245043 -0.0580899 0 0.085986 0 0.162644)
(0.248222 -0.0593317 0 0.0863981 0 0.163557)
(0.25135 -0.0605522 0 0.0868532 0 0.164484)
(0.254442 -0.061755 0 0.0873424 0 0.16543)
(0.257512 -0.0629425 0 0.0878586 0 0.166396)
(0.260568 -0.0641161 0 0.0883963 0 0.167385)
(0.263616 -0.0652763 0 0.0889509 0 0.168397)
(0.266662 -0.0664232 0 0.0895188 0 0.169433)
(0.269705 -0.0675565 0 0.0900969 0 0.170491)
(0.272747 -0.0686756 0 0.0906824 0 0.17157)
(0.275786 -0.0697801 0 0.0912733 0 0.172669)
(0.27882 -0.0708678 0 0.0918669 0 0.173786)
(0.281847 -0.0719427 0 0.0924642 0 0.174917)
(0.284862 -0.0729913 0 0.093058 0 0.176064)
(0.288416 -0.0742581 0 0.0939424 0 0.177423)
(0.135647 -0.00198165 0 0.129365 0 0.13447)
(0.138143 -0.00333272 0 0.124875 0 0.135413)
(0.140543 -0.00436743 0 0.120286 0 0.136113)
(0.142758 -0.00525002 0 0.115857 0 0.136577)
(0.144727 -0.00600338 0 0.111694 0 0.136818)
(0.146449 -0.00665866 0 0.107826 0 0.136871)
(0.147943 -0.00725513 0 0.104253 0 0.136769)
(0.149225 -0.00782148 0 0.100966 0 0.136541)
(0.150314 -0.00837534 0 0.0979486 0 0.136207)
(0.151228 -0.00892807 0 0.0951834 0 0.135788)
(0.151988 -0.00948721 0 0.0926519 0 0.135301)
(0.152613 -0.0100575 0 0.0903353 0 0.134761)
(0.153124 -0.0106413 0 0.0882154 0 0.134182)
(0.153539 -0.0112398 0 0.0862748 0 0.133575)
(0.153876 -0.0118528 0 0.0844974 0 0.13295)
(0.15415 -0.0124797 0 0.0828685 0 0.132316)
(0.154376 -0.0131192 0 0.0813746 0 0.131681)
(0.154569 -0.0137699 0 0.0800036 0 0.131051)
(0.154739 -0.0144303 0 0.0787445 0 0.130433)
(0.154899 -0.0150985 0 0.0775878 0 0.12983)
(0.155056 -0.0157729 0 0.0765245 0 0.129248)
(0.155216 -0.0164511 0 0.0755465 0 0.128687)
(0.155384 -0.0171311 0 0.0746463 0 0.12815)
(0.155565 -0.0178111 0 0.0738173 0 0.127638)
(0.155761 -0.0184892 0 0.0730537 0 0.127152)
(0.155975 -0.0191641 0 0.0723504 0 0.126693)
(0.156209 -0.0198343 0 0.0717026 0 0.12626)
(0.156465 -0.0204987 0 0.0711062 0 0.125854)
(0.156744 -0.0211561 0 0.0705573 0 0.125476)
(0.157046 -0.0218057 0 0.0700529 0 0.125125)
(0.15737 -0.0224458 0 0.0695882 0 0.1248)
(0.157722 -0.0230796 0 0.0691668 0 0.124503)
(0.158142 -0.0237186 0 0.0688028 0 0.124244)
(0.134186 -0.000783012 0 0.130263 0 0.133857)
(0.135191 -0.00139797 0 0.126844 0 0.134317)
(0.136192 -0.00188094 0 0.123377 0 0.134657)
(0.13712 -0.00231652 0 0.120006 0 0.134859)
(0.137922 -0.00270631 0 0.116774 0 0.134922)
(0.138592 -0.0030531 0 0.11369 0 0.13486)
(0.139141 -0.00336936 0 0.110759 0 0.134693)
(0.139579 -0.00366508 0 0.107987 0 0.134437)
(0.139912 -0.00394647 0 0.105372 0 0.134105)
(0.14015 -0.00421838 0 0.10291 0 0.133709)
(0.140302 -0.00448512 0 0.100594 0 0.13326)
(0.140379 -0.00475017 0 0.0984175 0 0.132768)
(0.140389 -0.00501617 0 0.0963717 0 0.13224)
(0.140342 -0.00528505 0 0.0944484 0 0.131685)
(0.140246 -0.00555815 0 0.0926395 0 0.131109)
(0.140107 -0.0058364 0 0.0909373 0 0.130516)
(0.139935 -0.00612036 0 0.0893343 0 0.129913)
(0.139734 -0.00641027 0 0.0878237 0 0.129304)
(0.139511 -0.00670619 0 0.086399 0 0.128692)
(0.139273 -0.00700798 0 0.0850544 0 0.128081)
(0.139022 -0.00731534 0 0.0837845 0 0.127473)
(0.138764 -0.00762773 0 0.0825843 0 0.126872)
(0.138502 -0.0079445 0 0.0814491 0 0.126278)
(0.138238 -0.00826499 0 0.0803747 0 0.125693)
(0.137974 -0.00858852 0 0.0793572 0 0.125119)
(0.137714 -0.0089144 0 0.0783929 0 0.124556)
(0.137459 -0.00924197 0 0.0774785 0 0.124006)
(0.137209 -0.00957058 0 0.0766109 0 0.123468)
(0.136967 -0.00989962 0 0.0757874 0 0.122944)
(0.136734 -0.0102284 0 0.0750053 0 0.122434)
(0.13651 -0.0105565 0 0.0742622 0 0.121938)
(0.136295 -0.0108841 0 0.0735561 0 0.121456)
(0.13609 -0.0112142 0 0.0728905 0 0.120984)
(0.133619 -0.000369894 0 0.1308 0 0.133544)
(0.133991 -0.000663439 0 0.128074 0 0.133735)
(0.134406 -0.000892727 0 0.12533 0 0.133878)
(0.134816 -0.00111606 0 0.122627 0 0.133954)
(0.135172 -0.0013308 0 0.119998 0 0.133949)
(0.135457 -0.0015294 0 0.117456 0 0.133864)
(0.135676 -0.00171501 0 0.115009 0 0.133709)
(0.135831 -0.00189193 0 0.112665 0 0.133493)
(0.135924 -0.00206238 0 0.110424 0 0.133222)
(0.135958 -0.00222795 0 0.108285 0 0.132904)
(0.135941 -0.00239026 0 0.106247 0 0.132546)
(0.135875 -0.00255075 0 0.104304 0 0.132153)
(0.135768 -0.00271053 0 0.102455 0 0.131733)
(0.135623 -0.00287044 0 0.100694 0 0.131289)
(0.135444 -0.00303113 0 0.0990169 0 0.130826)
(0.135238 -0.00319308 0 0.0974205 0 0.130347)
(0.135006 -0.00335665 0 0.0959005 0 0.129857)
(0.134754 -0.00352207 0 0.0944528 0 0.129359)
(0.134485 -0.00368946 0 0.0930736 0 0.128854)
(0.134201 -0.00385888 0 0.0917593 0 0.128346)
(0.133906 -0.00403033 0 0.0905065 0 0.127836)
(0.133603 -0.00420371 0 0.0893117 0 0.127327)
(0.133293 -0.00437884 0 0.0881719 0 0.12682)
(0.132979 -0.00455553 0 0.0870843 0 0.126316)
(0.132662 -0.00473354 0 0.086046 0 0.125817)
(0.132344 -0.0049126 0 0.0850543 0 0.125323)
(0.132026 -0.00509244 0 0.0841069 0 0.124836)
(0.13171 -0.00527278 0 0.0832014 0 0.124356)
(0.131395 -0.00545333 0 0.0823357 0 0.123883)
(0.131084 -0.00563381 0 0.0815077 0 0.123418)
(0.130776 -0.00581399 0 0.0807154 0 0.122961)
(0.130472 -0.00599397 0 0.0799572 0 0.122513)
(0.130166 -0.00617568 0 0.0792297 0 0.122066)
(0.133352 -0.000209946 0 0.131145 0 0.133354)
(0.133395 -0.000362812 0 0.128832 0 0.133363)
(0.133482 -0.000470621 0 0.126514 0 0.13336)
(0.133597 -0.000577732 0 0.124222 0 0.133333)
(0.1337 -0.000685296 0 0.121981 0 0.133264)
(0.133774 -0.000786661 0 0.119804 0 0.133149)
(0.133814 -0.000882998 0 0.117695 0 0.132989)
(0.133819 -0.000976802 0 0.115661 0 0.132788)
(0.133788 -0.00106882 0 0.113702 0 0.132549)
(0.133721 -0.00115929 0 0.11182 0 0.132277)
(0.133622 -0.00124871 0 0.110014 0 0.131975)
(0.133493 -0.00133764 0 0.108282 0 0.131647)
(0.133336 -0.00142657 0 0.106622 0 0.131298)
(0.133154 -0.00151586 0 0.105032 0 0.130931)
(0.13295 -0.00160583 0 0.10351 0 0.130547)
(0.132727 -0.00169672 0 0.102052 0 0.130152)
(0.132487 -0.00178871 0 0.100656 0 0.129746)
(0.132232 -0.0018819 0 0.0993187 0 0.129332)
(0.131964 -0.00197638 0 0.0980383 0 0.128911)
(0.131686 -0.00207216 0 0.0968116 0 0.128487)
(0.131399 -0.00216922 0 0.0956363 0 0.12806)
(0.131105 -0.00226752 0 0.0945098 0 0.127632)
(0.130806 -0.00236697 0 0.0934299 0 0.127204)
(0.130502 -0.00246745 0 0.0923943 0 0.126777)
(0.130196 -0.00256882 0 0.0914009 0 0.126352)
(0.129888 -0.00267093 0 0.0904478 0 0.12593)
(0.129579 -0.0027736 0 0.089533 0 0.125512)
(0.129269 -0.00287666 0 0.0886549 0 0.125097)
(0.128961 -0.00297991 0 0.0878117 0 0.124688)
(0.128654 -0.00308316 0 0.0870019 0 0.124283)
(0.128348 -0.00318623 0 0.0862238 0 0.123884)
(0.128044 -0.00328914 0 0.0854758 0 0.12349)
(0.127736 -0.00339284 0 0.0847517 0 0.123095)
(0.133205 -0.000140255 0 0.131382 0 0.133226)
(0.133061 -0.000232535 0 0.129345 0 0.133103)
(0.132946 -0.000282297 0 0.127332 0 0.132983)
(0.132865 -0.000325301 0 0.12535 0 0.13286)
(0.132794 -0.000369123 0 0.12341 0 0.132722)
(0.132719 -0.000411025 0 0.121516 0 0.132563)
(0.132633 -0.00045179 0 0.119673 0 0.132379)
(0.132532 -0.000493015 0 0.117884 0 0.132171)
(0.132415 -0.000534932 0 0.116153 0 0.13194)
(0.132278 -0.000577353 0 0.11448 0 0.131686)
(0.132123 -0.000620329 0 0.112867 0 0.131413)
(0.131951 -0.000664033 0 0.111311 0 0.131121)
(0.131761 -0.00070861 0 0.109813 0 0.130814)
(0.131556 -0.000754158 0 0.108371 0 0.130494)
(0.131338 -0.000800758 0 0.106983 0 0.130162)
(0.131106 -0.000848469 0 0.105647 0 0.12982)
(0.130863 -0.000897323 0 0.104363 0 0.12947)
(0.130611 -0.000947327 0 0.103127 0 0.129114)
(0.13035 -0.000998466 0 0.101939 0 0.128752)
(0.130082 -0.00105071 0 0.100796 0 0.128387)
(0.129808 -0.00110399 0 0.099696 0 0.12802)
(0.129529 -0.00115826 0 0.0986382 0 0.127651)
(0.129246 -0.00121343 0 0.0976206 0 0.127282)
(0.128961 -0.00126941 0 0.0966414 0 0.126913)
(0.128673 -0.00132608 0 0.095699 0 0.126545)
(0.128384 -0.00138332 0 0.094792 0 0.126179)
(0.128094 -0.00144101 0 0.0939189 0 0.125816)
(0.127804 -0.00149901 0 0.0930782 0 0.125455)
(0.127514 -0.00155716 0 0.0922687 0 0.125097)
(0.127225 -0.0016153 0 0.0914891 0 0.124743)
(0.126938 -0.00167327 0 0.0907382 0 0.124394)
(0.126651 -0.00173097 0 0.0900139 0 0.124047)
(0.12636 -0.00178877 0 0.089309 0 0.123698)
(0.133111 -0.000104767 0 0.131554 0 0.133134)
(0.132855 -0.000171958 0 0.12971 0 0.132914)
(0.132611 -0.000199602 0 0.12791 0 0.1327)
(0.132395 -0.000214154 0 0.126145 0 0.132493)
(0.132198 -0.000225683 0 0.124419 0 0.132287)
(0.132008 -0.000234567 0 0.122733 0 0.132075)
(0.131822 -0.00024224 0 0.121088 0 0.131854)
(0.131636 -0.000250567 0 0.119488 0 0.131623)
(0.131446 -0.000260181 0 0.117934 0 0.13138)
(0.13125 -0.000271097 0 0.116428 0 0.131124)
(0.131046 -0.000283345 0 0.114969 0 0.130858)
(0.130835 -0.000296988 0 0.113558 0 0.130581)
(0.130615 -0.000312042 0 0.112195 0 0.130294)
(0.130387 -0.000328488 0 0.110878 0 0.129998)
(0.130152 -0.0003463 0 0.109607 0 0.129694)
(0.12991 -0.000365447 0 0.10838 0 0.129385)
(0.129661 -0.000385888 0 0.107197 0 0.12907)
(0.129408 -0.000407574 0 0.106055 0 0.12875)
(0.129149 -0.000430446 0 0.104954 0 0.128428)
(0.128887 -0.000454439 0 0.103892 0 0.128103)
(0.128621 -0.000479478 0 0.102868 0 0.127776)
(0.128353 -0.000505481 0 0.10188 0 0.127449)
(0.128082 -0.00053236 0 0.100928 0 0.127121)
(0.127811 -0.000560019 0 0.100009 0 0.126794)
(0.127538 -0.000588354 0 0.0991231 0 0.126467)
(0.127265 -0.000617255 0 0.0982682 0 0.126143)
(0.126991 -0.000646604 0 0.0974434 0 0.12582)
(0.126719 -0.000676272 0 0.0966476 0 0.1255)
(0.126447 -0.000706121 0 0.0958796 0 0.125182)
(0.126176 -0.000736 0 0.0951384 0 0.124867)
(0.125907 -0.000765736 0 0.0944228 0 0.124556)
(0.125638 -0.000795194 0 0.0937309 0 0.124247)
(0.125366 -0.00082447 0 0.0930545 0 0.123936)
(0.133044 -8.35373e-05 0 0.131686 0 0.133064)
(0.132713 -0.000139544 0 0.129983 0 0.132771)
(0.132385 -0.000160936 0 0.128336 0 0.132484)
(0.132077 -0.000165383 0 0.126731 0 0.132208)
(0.131788 -0.000162596 0 0.125168 0 0.131939)
(0.131512 -0.000154876 0 0.123645 0 0.131674)
(0.131246 -0.000144421 0 0.122161 0 0.13141)
(0.130988 -0.000133546 0 0.120715 0 0.131145)
(0.130735 -0.000123415 0 0.119308 0 0.130878)
(0.130484 -0.000114424 0 0.117942 0 0.130607)
(0.130234 -0.000106795 0 0.116616 0 0.130332)
(0.129983 -0.000100684 0 0.11533 0 0.130053)
(0.129732 -9.61525e-05 0 0.114084 0 0.12977)
(0.129478 -9.32007e-05 0 0.112877 0 0.129482)
(0.129223 -9.17968e-05 0 0.111708 0 0.129191)
(0.128966 -9.18927e-05 0 0.110578 0 0.128898)
(0.128707 -9.34258e-05 0 0.109484 0 0.128601)
(0.128447 -9.63221e-05 0 0.108426 0 0.128303)
(0.128185 -0.0001005 0 0.107404 0 0.128004)
(0.127922 -0.000105872 0 0.106415 0 0.127703)
(0.127658 -0.000112345 0 0.105459 0 0.127403)
(0.127394 -0.000119823 0 0.104535 0 0.127102)
(0.127129 -0.000128205 0 0.103642 0 0.126802)
(0.126865 -0.000137388 0 0.102779 0 0.126504)
(0.126602 -0.000147265 0 0.101944 0 0.126206)
(0.126339 -0.000157723 0 0.101138 0 0.125911)
(0.126077 -0.000168644 0 0.100358 0 0.125617)
(0.125816 -0.000179904 0 0.0996041 0 0.125326)
(0.125557 -0.000191368 0 0.0988753 0 0.125037)
(0.1253 -0.00020289 0 0.0981707 0 0.124752)
(0.125044 -0.0002143 0 0.0974891 0 0.124469)
(0.12479 -0.000225435 0 0.0968287 0 0.124188)
(0.124533 -0.000236172 0 0.0961811 0 0.123906)
(0.132993 -6.90284e-05 0 0.131791 0 0.133009)
(0.132608 -0.000118691 0 0.130196 0 0.132659)
(0.132222 -0.000139676 0 0.128662 0 0.132315)
(0.13185 -0.000142971 0 0.127177 0 0.131982)
(0.131495 -0.00013664 0 0.125735 0 0.13166)
(0.131153 -0.000123573 0 0.124334 0 0.131346)
(0.130824 -0.000106105 0 0.12297 0 0.131039)
(0.130506 -8.66113e-05 0 0.121643 0 0.130738)
(0.130198 -6.65821e-05 0 0.120353 0 0.13044)
(0.129899 -4.67775e-05 0 0.119098 0 0.130145)
(0.129605 -2.76851e-05 0 0.117878 0 0.129852)
(0.129316 -9.65134e-06 0 0.116694 0 0.12956)
(0.129032 7.1172e-06 0 0.115545 0 0.129268)
(0.128751 2.25195e-05 0 0.11443 0 0.128977)
(0.128472 3.65173e-05 0 0.113349 0 0.128686)
(0.128196 4.91123e-05 0 0.112301 0 0.128396)
(0.127921 6.03357e-05 0 0.111286 0 0.128106)
(0.127649 7.02396e-05 0 0.110302 0 0.127816)
(0.127378 7.88907e-05 0 0.109349 0 0.127528)
(0.127109 8.63659e-05 0 0.108427 0 0.127241)
(0.126841 9.27496e-05 0 0.107533 0 0.126954)
(0.126575 9.81315e-05 0 0.106668 0 0.12667)
(0.126311 0.000102606 0 0.10583 0 0.126387)
(0.126049 0.000106271 0 0.105019 0 0.126106)
(0.125789 0.00010923 0 0.104234 0 0.125827)
(0.12553 0.000111587 0 0.103474 0 0.125551)
(0.125274 0.000113455 0 0.102739 0 0.125277)
(0.125021 0.000114952 0 0.102026 0 0.125006)
(0.124769 0.000116202 0 0.101336 0 0.124737)
(0.12452 0.000117345 0 0.100669 0 0.124472)
(0.124274 0.000118535 0 0.100022 0 0.12421)
(0.12403 0.000119937 0 0.0993936 0 0.12395)
(0.123783 0.0001218 0 0.0987762 0 0.123689)
(0.132951 -5.8204e-05 0 0.131876 0 0.132965)
(0.132525 -0.000103076 0 0.130367 0 0.132569)
(0.132097 -0.00012498 0 0.128922 0 0.13218)
(0.131679 -0.000130296 0 0.127527 0 0.131802)
(0.131275 -0.000125138 0 0.126178 0 0.131436)
(0.130884 -0.000112262 0 0.12487 0 0.13108)
(0.130507 -9.37982e-05 0 0.123601 0 0.130734)
(0.130142 -7.19456e-05 0 0.122369 0 0.130397)
(0.129789 -4.83012e-05 0 0.121171 0 0.130068)
(0.129447 -2.38441e-05 0 0.120007 0 0.129746)
(0.129115 7.48564e-07 0 0.118877 0 0.129429)
(0.128791 2.4974e-05 0 0.117778 0 0.129118)
(0.128475 4.84889e-05 0 0.116712 0 0.128811)
(0.128165 7.10763e-05 0 0.115677 0 0.128508)
(0.127862 9.26045e-05 0 0.114672 0 0.128209)
(0.127564 0.000113001 0 0.113696 0 0.127913)
(0.127271 0.000132236 0 0.11275 0 0.12762)
(0.126983 0.000150317 0 0.111832 0 0.12733)
(0.126699 0.000167272 0 0.110942 0 0.127044)
(0.126419 0.000183149 0 0.110078 0 0.12676)
(0.126143 0.000198009 0 0.109241 0 0.126479)
(0.12587 0.000211923 0 0.108429 0 0.126201)
(0.125602 0.000224971 0 0.107642 0 0.125927)
(0.125336 0.000237238 0 0.106879 0 0.125655)
(0.125074 0.000248815 0 0.106139 0 0.125386)
(0.124816 0.000259798 0 0.105421 0 0.125121)
(0.124561 0.000270289 0 0.104726 0 0.124859)
(0.124309 0.000280395 0 0.104052 0 0.1246)
(0.12406 0.000290231 0 0.103398 0 0.124345)
(0.123815 0.000299919 0 0.102765 0 0.124092)
(0.123573 0.000309597 0 0.10215 0 0.123844)
(0.123334 0.000319423 0 0.101552 0 0.123598)
(0.123094 0.000329715 0 0.100963 0 0.123351)
(0.132917 -4.9688e-05 0 0.131946 0 0.132928)
(0.132457 -9.02718e-05 0 0.130509 0 0.132494)
(0.131996 -0.000112761 0 0.129133 0 0.132068)
(0.131544 -0.00012059 0 0.12781 0 0.131654)
(0.131103 -0.000118182 0 0.126533 0 0.131252)
(0.130676 -0.000107918 0 0.125298 0 0.130861)
(0.130261 -9.16108e-05 0 0.124103 0 0.130482)
(0.129859 -7.11354e-05 0 0.122943 0 0.130113)
(0.12947 -4.79856e-05 0 0.121818 0 0.129755)
(0.129093 -2.3174e-05 0 0.120726 0 0.129405)
(0.128728 2.56096e-06 0 0.119666 0 0.129065)
(0.128373 2.86462e-05 0 0.118636 0 0.128732)
(0.128027 5.46566e-05 0 0.117636 0 0.128406)
(0.127691 8.02925e-05 0 0.116666 0 0.128087)
(0.127364 0.000105345 0 0.115723 0 0.127774)
(0.127044 0.000129674 0 0.114808 0 0.127467)
(0.126731 0.00015319 0 0.11392 0 0.127165)
(0.126425 0.000175848 0 0.113058 0 0.126868)
(0.126125 0.00019763 0 0.112221 0 0.126577)
(0.125832 0.000218548 0 0.111409 0 0.12629)
(0.125544 0.000238627 0 0.11062 0 0.126008)
(0.125262 0.000257911 0 0.109855 0 0.12573)
(0.124984 0.000276454 0 0.109113 0 0.125456)
(0.124712 0.000294317 0 0.108392 0 0.125187)
(0.124445 0.000311573 0 0.107693 0 0.124922)
(0.124182 0.000328298 0 0.107015 0 0.124661)
(0.123924 0.000344575 0 0.106357 0 0.124404)
(0.12367 0.000360495 0 0.105718 0 0.124151)
(0.12342 0.000376152 0 0.105098 0 0.123903)
(0.123175 0.000391649 0 0.104496 0 0.123658)
(0.122934 0.000407098 0 0.103912 0 0.123417)
(0.122696 0.000422643 0 0.103343 0 0.123179)
(0.122458 0.000438651 0 0.102782 0 0.122941)
(0.132888 -4.27617e-05 0 0.132006 0 0.132898)
(0.1324 -7.93079e-05 0 0.130628 0 0.132432)
(0.131913 -0.000101674 0 0.12931 0 0.131975)
(0.131433 -0.000111502 0 0.128045 0 0.131531)
(0.130964 -0.000111882 0 0.126825 0 0.131099)
(0.130508 -0.000104768 0 0.125649 0 0.13068)
(0.130065 -9.16431e-05 0 0.124511 0 0.130272)
(0.129634 -7.40358e-05 0 0.123409 0 0.129876)
(0.129216 -5.32507e-05 0 0.122342 0 0.129492)
(0.128811 -3.02413e-05 0 0.121308 0 0.129118)
(0.128418 -5.7317e-06 0 0.120304 0 0.128754)
(0.128037 1.96975e-05 0 0.119331 0 0.1284)
(0.127667 4.55936e-05 0 0.118386 0 0.128055)
(0.127307 7.16163e-05 0 0.117469 0 0.127718)
(0.126957 9.75125e-05 0 0.116579 0 0.12739)
(0.126616 0.000123096 0 0.115715 0 0.127069)
(0.126284 0.000148235 0 0.114877 0 0.126755)
(0.125961 0.00017284 0 0.114062 0 0.126448)
(0.125645 0.000196858 0 0.113272 0 0.126147)
(0.125337 0.00022026 0 0.112504 0 0.125853)
(0.125036 0.000243043 0 0.111758 0 0.125564)
(0.124742 0.00026522 0 0.111035 0 0.125282)
(0.124454 0.000286817 0 0.110332 0 0.125005)
(0.124172 0.000307872 0 0.109649 0 0.124733)
(0.123897 0.000328435 0 0.108987 0 0.124466)
(0.123627 0.000348562 0 0.108343 0 0.124205)
(0.123363 0.000368316 0 0.107718 0 0.123948)
(0.123104 0.000387765 0 0.107111 0 0.123697)
(0.122851 0.000406984 0 0.106522 0 0.12345)
(0.122602 0.000426053 0 0.105949 0 0.123207)
(0.122359 0.000445059 0 0.105392 0 0.12297)
(0.122119 0.000464124 0 0.10485 0 0.122735)
(0.121881 0.000483624 0 0.104314 0 0.122501)
(0.132863 -3.6997e-05 0 0.132057 0 0.132872)
(0.132351 -6.97343e-05 0 0.13073 0 0.132378)
(0.131841 -9.13416e-05 0 0.129461 0 0.131896)
(0.131339 -0.00010241 0 0.128243 0 0.131427)
(0.130848 -0.000105042 0 0.127071 0 0.13097)
(0.130369 -0.000100791 0 0.125942 0 0.130527)
(0.129903 -9.08631e-05 0 0.124851 0 0.130095)
(0.12945 -7.6491e-05 0 0.123796 0 0.129677)
(0.129009 -5.87776e-05 0 0.122775 0 0.12927)
(0.128581 -3.85748e-05 0 0.121787 0 0.128874)
(0.128166 -1.65467e-05 0 0.120829 0 0.12849)
(0.127763 6.7649e-06 0 0.119901 0 0.128117)
(0.127372 3.09241e-05 0 0.119 0 0.127753)
(0.126991 5.55906e-05 0 0.118127 0 0.127399)
(0.126622 8.05006e-05 0 0.117279 0 0.127055)
(0.126263 0.000105451 0 0.116456 0 0.126719)
(0.125913 0.000130289 0 0.115658 0 0.126392)
(0.125573 0.000154903 0 0.114883 0 0.126073)
(0.125242 0.000179213 0 0.11413 0 0.125761)
(0.124919 0.000203168 0 0.1134 0 0.125457)
(0.124605 0.000226739 0 0.11269 0 0.12516)
(0.124298 0.000249916 0 0.112001 0 0.124869)
(0.123999 0.000272703 0 0.111332 0 0.124586)
(0.123708 0.000295117 0 0.110682 0 0.124308)
(0.123423 0.000317185 0 0.11005 0 0.124037)
(0.123144 0.000338943 0 0.109437 0 0.123772)
(0.122873 0.000360434 0 0.108841 0 0.123512)
(0.122607 0.000381705 0 0.108261 0 0.123258)
(0.122348 0.000402809 0 0.107699 0 0.123009)
(0.122094 0.000423801 0 0.107152 0 0.122765)
(0.121846 0.000444748 0 0.10662 0 0.122527)
(0.121603 0.00046575 0 0.106101 0 0.122293)
(0.121361 0.000487195 0 0.105589 0 0.122059)
(0.132842 -3.21111e-05 0 0.132101 0 0.132849)
(0.132309 -6.12877e-05 0 0.130818 0 0.132333)
(0.13178 -8.16824e-05 0 0.129591 0 0.131828)
(0.131259 -9.33004e-05 0 0.128413 0 0.131337)
(0.130749 -9.75277e-05 0 0.127281 0 0.13086)
(0.130252 -9.5574e-05 0 0.126191 0 0.130396)
(0.129767 -8.84164e-05 0 0.125139 0 0.129944)
(0.129295 -7.70436e-05 0 0.124123 0 0.129506)
(0.128836 -6.23721e-05 0 0.12314 0 0.12908)
(0.12839 -4.51414e-05 0 0.122189 0 0.128667)
(0.127957 -2.59409e-05 0 0.121269 0 0.128265)
(0.127536 -5.25764e-06 0 0.120377 0 0.127874)
(0.127127 1.6508e-05 0 0.119513 0 0.127494)
(0.12673 3.9035e-05 0 0.118675 0 0.127125)
(0.126344 6.2068e-05 0 0.117862 0 0.126766)
(0.125968 8.54048e-05 0 0.117074 0 0.126416)
(0.125604 0.000108887 0 0.116309 0 0.126076)
(0.125249 0.000132394 0 0.115567 0 0.125744)
(0.124904 0.000155833 0 0.114847 0 0.125421)
(0.124568 0.000179141 0 0.114147 0 0.125106)
(0.124241 0.000202272 0 0.113468 0 0.1248)
(0.123923 0.0002252 0 0.112808 0 0.1245)
(0.123613 0.000247912 0 0.112168 0 0.124208)
(0.123311 0.00027041 0 0.111546 0 0.123924)
(0.123017 0.000292701 0 0.110941 0 0.123646)
(0.122729 0.000314806 0 0.110354 0 0.123374)
(0.122449 0.000336748 0 0.109783 0 0.123109)
(0.122176 0.000358557 0 0.109228 0 0.12285)
(0.12191 0.000380267 0 0.108689 0 0.122598)
(0.12165 0.000401913 0 0.108164 0 0.122351)
(0.121396 0.000423538 0 0.107654 0 0.122109)
(0.121148 0.000445224 0 0.107157 0 0.121872)
(0.120901 0.000467335 0 0.106664 0 0.121637)
(0.132823 -2.7905e-05 0 0.13214 0 0.132829)
(0.132272 -5.37786e-05 0 0.130895 0 0.132293)
(0.131726 -7.26767e-05 0 0.129704 0 0.131769)
(0.131189 -8.42996e-05 0 0.128561 0 0.13126)
(0.130664 -8.95282e-05 0 0.127464 0 0.130764)
(0.130151 -8.92823e-05 0 0.126406 0 0.130282)
(0.12965 -8.43498e-05 0 0.125387 0 0.129814)
(0.129163 -7.55267e-05 0 0.124403 0 0.129359)
(0.128689 -6.35704e-05 0 0.123452 0 0.128917)
(0.128228 -4.91161e-05 0 0.122533 0 0.128488)
(0.127779 -3.26803e-05 0 0.121643 0 0.12807)
(0.127344 -1.46939e-05 0 0.120782 0 0.127665)
(0.12692 4.48476e-06 0 0.119947 0 0.127271)
(0.126509 2.45633e-05 0 0.119139 0 0.126888)
(0.126109 4.53057e-05 0 0.118355 0 0.126515)
(0.12572 6.65219e-05 0 0.117595 0 0.126153)
(0.125343 8.806e-05 0 0.116858 0 0.1258)
(0.124975 0.000109801 0 0.116143 0 0.125457)
(0.124618 0.000131651 0 0.115448 0 0.125123)
(0.124271 0.000153542 0 0.114775 0 0.124798)
(0.123933 0.000175422 0 0.11412 0 0.124482)
(0.123604 0.000197256 0 0.113485 0 0.124173)
(0.123284 0.000219022 0 0.112868 0 0.123873)
(0.122972 0.00024071 0 0.112269 0 0.12358)
(0.122668 0.000262318 0 0.111687 0 0.123295)
(0.122373 0.000283851 0 0.111121 0 0.123016)
(0.122085 0.00030532 0 0.110572 0 0.122745)
(0.121804 0.000326741 0 0.110037 0 0.12248)
(0.12153 0.000348131 0 0.109518 0 0.122222)
(0.121264 0.00036951 0 0.109013 0 0.12197)
(0.121004 0.000390906 0 0.108521 0 0.121724)
(0.12075 0.000412383 0 0.108041 0 0.121483)
(0.120498 0.000434295 0 0.107567 0 0.121244)
(0.132807 -2.42325e-05 0 0.132174 0 0.132812)
(0.132239 -4.70542e-05 0 0.130962 0 0.132258)
(0.131678 -6.42989e-05 0 0.129803 0 0.131717)
(0.131128 -7.55285e-05 0 0.128692 0 0.131191)
(0.130589 -8.12751e-05 0 0.127623 0 0.13068)
(0.130062 -8.22212e-05 0 0.126595 0 0.130183)
(0.129549 -7.89959e-05 0 0.125604 0 0.1297)
(0.129048 -7.22408e-05 0 0.124647 0 0.129231)
(0.128561 -6.25792e-05 0 0.123723 0 0.128775)
(0.128087 -5.05511e-05 0 0.122831 0 0.128332)
(0.127627 -3.66049e-05 0 0.121967 0 0.127902)
(0.127179 -2.11177e-05 0 0.121131 0 0.127483)
(0.126743 -4.40582e-06 0 0.120322 0 0.127077)
(0.12632 1.32693e-05 0 0.119538 0 0.126681)
(0.125909 3.16941e-05 0 0.118778 0 0.126297)
(0.125509 5.06947e-05 0 0.118042 0 0.125924)
(0.12512 7.01301e-05 0 0.117327 0 0.12556)
(0.124742 8.98876e-05 0 0.116635 0 0.125207)
(0.124374 0.000109878 0 0.115963 0 0.124863)
(0.124017 0.000130032 0 0.115311 0 0.124529)
(0.123669 0.000150297 0 0.114678 0 0.124203)
(0.123331 0.000170634 0 0.114063 0 0.123886)
(0.123002 0.000191016 0 0.113466 0 0.123577)
(0.122681 0.000211426 0 0.112886 0 0.123277)
(0.12237 0.000231853 0 0.112323 0 0.122984)
(0.122066 0.000252294 0 0.111776 0 0.122699)
(0.121771 0.00027275 0 0.111244 0 0.122421)
(0.121483 0.000293225 0 0.110727 0 0.12215)
(0.121203 0.000313725 0 0.110225 0 0.121886)
(0.12093 0.000334258 0 0.109736 0 0.121628)
(0.120664 0.000354837 0 0.10926 0 0.121377)
(0.120404 0.000375513 0 0.108796 0 0.121132)
(0.120147 0.000396609 0 0.108337 0 0.120888)
(0.132792 -2.09835e-05 0 0.132204 0 0.132797)
(0.13221 -4.09861e-05 0 0.131023 0 0.132227)
(0.131636 -5.65063e-05 0 0.129892 0 0.131671)
(0.131073 -6.70637e-05 0 0.128807 0 0.131131)
(0.130522 -7.29549e-05 0 0.127764 0 0.130606)
(0.129984 -7.46726e-05 0 0.126761 0 0.130096)
(0.129459 -7.27121e-05 0 0.125795 0 0.1296)
(0.128947 -6.75886e-05 0 0.124862 0 0.129118)
(0.128449 -5.98125e-05 0 0.123961 0 0.12865)
(0.127965 -4.98391e-05 0 0.123091 0 0.128195)
(0.127493 -3.80551e-05 0 0.12225 0 0.127753)
(0.127035 -2.47884e-05 0 0.121436 0 0.127324)
(0.126589 -1.03169e-05 0 0.120648 0 0.126906)
(0.126156 5.12757e-06 0 0.119885 0 0.126501)
(0.125735 2.13539e-05 0 0.119146 0 0.126106)
(0.125325 3.82049e-05 0 0.118429 0 0.125723)
(0.124927 5.55525e-05 0 0.117734 0 0.12535)
(0.12454 7.32929e-05 0 0.117061 0 0.124988)
(0.124164 9.13428e-05 0 0.116407 0 0.124635)
(0.123798 0.000109636 0 0.115773 0 0.124292)
(0.123442 0.000128122 0 0.115158 0 0.123958)
(0.123095 0.000146761 0 0.11456 0 0.123633)
(0.122758 0.000165523 0 0.11398 0 0.123317)
(0.122431 0.000184388 0 0.113417 0 0.123009)
(0.122112 0.000203342 0 0.112869 0 0.122709)
(0.121801 0.000222374 0 0.112337 0 0.122417)
(0.121499 0.00024148 0 0.11182 0 0.122133)
(0.121205 0.000260655 0 0.111318 0 0.121856)
(0.120919 0.000279899 0 0.110829 0 0.121586)
(0.12064 0.000299209 0 0.110354 0 0.121324)
(0.120369 0.000318591 0 0.109892 0 0.121067)
(0.120104 0.000338086 0 0.109441 0 0.120817)
(0.119841 0.000357997 0 0.108994 0 0.120568)
(0.132779 -1.80732e-05 0 0.13223 0 0.132783)
(0.132184 -3.54656e-05 0 0.131076 0 0.132199)
(0.131598 -4.92443e-05 0 0.129971 0 0.13163)
(0.131024 -5.89401e-05 0 0.12891 0 0.131077)
(0.130462 -6.46947e-05 0 0.12789 0 0.13054)
(0.129914 -6.68529e-05 0 0.126909 0 0.130018)
(0.129379 -6.57972e-05 0 0.125964 0 0.129511)
(0.128858 -6.19375e-05 0 0.125052 0 0.129018)
(0.12835 -5.56885e-05 0 0.124172 0 0.128539)
(0.127856 -4.74301e-05 0 0.123322 0 0.128074)
(0.127376 -3.74917e-05 0 0.1225 0 0.127622)
(0.126908 -2.61563e-05 0 0.121705 0 0.127183)
(0.126454 -1.36656e-05 0 0.120935 0 0.126756)
(0.126012 -2.22909e-07 0 0.12019 0 0.126341)
(0.125582 1.40022e-05 0 0.119469 0 0.125938)
(0.125165 2.88696e-05 0 0.118769 0 0.125546)
(0.124759 4.42639e-05 0 0.118091 0 0.125165)
(0.124364 6.00908e-05 0 0.117434 0 0.124794)
(0.12398 7.6274e-05 0 0.116796 0 0.124434)
(0.123607 9.27519e-05 0 0.116177 0 0.124083)
(0.123243 0.000109476 0 0.115577 0 0.123742)
(0.12289 0.000126407 0 0.114994 0 0.12341)
(0.122547 0.000143516 0 0.114428 0 0.123087)
(0.122212 0.00016078 0 0.113878 0 0.122773)
(0.121887 0.000178181 0 0.113344 0 0.122467)
(0.121571 0.000195706 0 0.112825 0 0.122169)
(0.121263 0.000213345 0 0.112321 0 0.121879)
(0.120963 0.00023109 0 0.111831 0 0.121596)
(0.120672 0.000248931 0 0.111355 0 0.121321)
(0.120388 0.000266863 0 0.110891 0 0.121053)
(0.120112 0.000284882 0 0.11044 0 0.120792)
(0.119842 0.000303021 0 0.11 0 0.120537)
(0.119575 0.000321555 0 0.109564 0 0.120284)
(0.132767 -1.54349e-05 0 0.132254 0 0.132771)
(0.13216 -3.03998e-05 0 0.131125 0 0.132174)
(0.131564 -4.2452e-05 0 0.130042 0 0.131594)
(0.13098 -5.11613e-05 0 0.129002 0 0.131029)
(0.130409 -5.65712e-05 0 0.128003 0 0.130481)
(0.129851 -5.89134e-05 0 0.127042 0 0.129948)
(0.129307 -5.84761e-05 0 0.126116 0 0.129431)
(0.128778 -5.55807e-05 0 0.125223 0 0.128928)
(0.128262 -5.05597e-05 0 0.124361 0 0.12844)
(0.127759 -4.37256e-05 0 0.123528 0 0.127966)
(0.127271 -3.53552e-05 0 0.122723 0 0.127505)
(0.126796 -2.56894e-05 0 0.121944 0 0.127057)
(0.126334 -1.49361e-05 0 0.121191 0 0.126622)
(0.125884 -3.27211e-06 0 0.120461 0 0.126199)
(0.125448 9.1538e-06 0 0.119755 0 0.125788)
(0.125023 2.22176e-05 0 0.11907 0 0.125389)
(0.12461 3.58162e-05 0 0.118406 0 0.125)
(0.124208 4.98648e-05 0 0.117763 0 0.124623)
(0.123818 6.42936e-05 0 0.117139 0 0.124255)
(0.123438 7.90461e-05 0 0.116533 0 0.123898)
(0.123069 9.40762e-05 0 0.115945 0 0.123551)
(0.12271 0.000109347 0 0.115375 0 0.123213)
(0.122361 0.000124829 0 0.114821 0 0.122884)
(0.122021 0.000140499 0 0.114283 0 0.122564)
(0.121691 0.000156337 0 0.11376 0 0.122252)
(0.121369 0.000172327 0 0.113252 0 0.121949)
(0.121057 0.000188457 0 0.112759 0 0.121654)
(0.120752 0.000204714 0 0.112279 0 0.121366)
(0.120456 0.000221086 0 0.111812 0 0.121086)
(0.120168 0.000237562 0 0.111359 0 0.120814)
(0.119887 0.000254136 0 0.110917 0 0.120548)
(0.119614 0.000270835 0 0.110486 0 0.120289)
(0.119342 0.00028791 0 0.11006 0 0.120031)
(0.132756 -1.30152e-05 0 0.132276 0 0.13276)
(0.132139 -2.57092e-05 0 0.131168 0 0.132152)
(0.131533 -3.60672e-05 0 0.130106 0 0.13156)
(0.13094 -4.37107e-05 0 0.129086 0 0.130986)
(0.13036 -4.86236e-05 0 0.128106 0 0.130428)
(0.129794 -5.09531e-05 0 0.127162 0 0.129886)
(0.129243 -5.09088e-05 0 0.126253 0 0.129359)
(0.128705 -4.87373e-05 0 0.125376 0 0.128848)
(0.128182 -4.47004e-05 0 0.12453 0 0.128351)
(0.127672 -3.90498e-05 0 0.123713 0 0.127869)
(0.127177 -3.20136e-05 0 0.122923 0 0.1274)
(0.126695 -2.37933e-05 0 0.122159 0 0.126945)
(0.126226 -1.45647e-05 0 0.121419 0 0.126502)
(0.125771 -4.4792e-06 0 0.120703 0 0.126072)
(0.125328 6.33472e-06 0 0.12001 0 0.125655)
(0.124897 1.77687e-05 0 0.119338 0 0.125249)
(0.124478 2.97321e-05 0 0.118686 0 0.124854)
(0.124071 4.21492e-05 0 0.118055 0 0.12447)
(0.123675 5.49573e-05 0 0.117442 0 0.124097)
(0.12329 6.81047e-05 0 0.116848 0 0.123734)
(0.122916 8.15488e-05 0 0.116271 0 0.123381)
(0.122552 9.52546e-05 0 0.115711 0 0.123038)
(0.122198 0.000109193 0 0.115167 0 0.122703)
(0.121853 0.000123341 0 0.114639 0 0.122378)
(0.121518 0.000137677 0 0.114126 0 0.122062)
(0.121193 0.000152185 0 0.113628 0 0.121754)
(0.120876 0.000166849 0 0.113143 0 0.121455)
(0.120567 0.000181654 0 0.112672 0 0.121163)
(0.120267 0.000196585 0 0.112214 0 0.120879)
(0.119975 0.00021163 0 0.111768 0 0.120602)
(0.119691 0.000226779 0 0.111334 0 0.120333)
(0.119414 0.000242051 0 0.110911 0 0.120069)
(0.119139 0.000257675 0 0.110492 0 0.119808)
(0.132747 -1.07701e-05 0 0.132296 0 0.13275)
(0.13212 -2.13251e-05 0 0.131208 0 0.132132)
(0.131505 -3.00283e-05 0 0.130164 0 0.131531)
(0.130903 -3.6558e-05 0 0.129162 0 0.130947)
(0.130316 -4.08643e-05 0 0.128198 0 0.13038)
(0.129743 -4.30313e-05 0 0.12727 0 0.129829)
(0.129184 -4.32043e-05 0 0.126377 0 0.129295)
(0.12864 -4.1566e-05 0 0.125515 0 0.128775)
(0.12811 -3.83164e-05 0 0.124683 0 0.128271)
(0.127594 -3.36527e-05 0 0.123879 0 0.127782)
(0.127093 -2.77579e-05 0 0.123102 0 0.127306)
(0.126605 -2.07962e-05 0 0.12235 0 0.126844)
(0.12613 -1.2913e-05 0 0.121623 0 0.126396)
(0.125669 -4.23515e-06 0 0.120919 0 0.12596)
(0.125221 5.1285e-06 0 0.120236 0 0.125536)
(0.124785 1.5085e-05 0 0.119575 0 0.125124)
(0.124361 2.55554e-05 0 0.118935 0 0.124724)
(0.123949 3.64735e-05 0 0.118313 0 0.124335)
(0.123549 4.77831e-05 0 0.11771 0 0.123957)
(0.123159 5.94376e-05 0 0.117125 0 0.123589)
(0.122781 7.13977e-05 0 0.116558 0 0.123231)
(0.122413 8.36305e-05 0 0.116006 0 0.122883)
(0.122055 9.61081e-05 0 0.115471 0 0.122545)
(0.121706 0.000108807 0 0.114951 0 0.122216)
(0.121368 0.000121706 0 0.114446 0 0.121895)
(0.121038 0.000134787 0 0.113955 0 0.121583)
(0.120718 0.000148033 0 0.113478 0 0.12128)
(0.120406 0.000161428 0 0.113014 0 0.120985)
(0.120103 0.000174955 0 0.112563 0 0.120697)
(0.119808 0.0001886 0 0.112124 0 0.120417)
(0.119521 0.000202352 0 0.111697 0 0.120144)
(0.119241 0.000216227 0 0.11128 0 0.119878)
(0.118964 0.000230432 0 0.110867 0 0.119614)
(0.132738 -8.66223e-06 0 0.132313 0 0.132741)
(0.132102 -1.71863e-05 0 0.131244 0 0.132113)
(0.131479 -2.42748e-05 0 0.130217 0 0.131503)
(0.13087 -2.96624e-05 0 0.12923 0 0.130911)
(0.130276 -3.32826e-05 0 0.128282 0 0.130336)
(0.129696 -3.51732e-05 0 0.127368 0 0.129778)
(0.129131 -3.54262e-05 0 0.126488 0 0.129237)
(0.128581 -3.41694e-05 0 0.125638 0 0.128711)
(0.128045 -3.15485e-05 0 0.124818 0 0.1282)
(0.127524 -2.77119e-05 0 0.124026 0 0.127705)
(0.127018 -2.28003e-05 0 0.12326 0 0.127223)
(0.126525 -1.69429e-05 0 0.122519 0 0.126756)
(0.126046 -1.02562e-05 0 0.121802 0 0.126302)
(0.12558 -2.84292e-06 0 0.121107 0 0.125861)
(0.125127 5.20702e-06 0 0.120435 0 0.125432)
(0.124687 1.38159e-05 0 0.119783 0 0.125016)
(0.12426 2.29168e-05 0 0.11915 0 0.124611)
(0.123844 3.24526e-05 0 0.118537 0 0.124218)
(0.12344 4.23744e-05 0 0.117942 0 0.123835)
(0.123047 5.26404e-05 0 0.117365 0 0.123463)
(0.122665 6.32153e-05 0 0.116804 0 0.123102)
(0.122293 7.40684e-05 0 0.11626 0 0.12275)
(0.121932 8.51733e-05 0 0.115732 0 0.122408)
(0.121581 9.65068e-05 0 0.115218 0 0.122076)
(0.121239 0.000108048 0 0.114719 0 0.121752)
(0.120907 0.000119779 0 0.114234 0 0.121437)
(0.120584 0.000131681 0 0.113763 0 0.121131)
(0.12027 0.000143737 0 0.113305 0 0.120832)
(0.119964 0.000155931 0 0.112859 0 0.120542)
(0.119667 0.000168245 0 0.112425 0 0.120259)
(0.119378 0.000180668 0 0.112003 0 0.119984)
(0.119095 0.000193211 0 0.111591 0 0.119715)
(0.118816 0.00020606 0 0.111183 0 0.119448)
(0.13273 -6.65829e-06 0 0.13233 0 0.132733)
(0.132086 -1.32367e-05 0 0.131276 0 0.132097)
(0.131456 -1.87464e-05 0 0.130264 0 0.131479)
(0.130841 -2.29757e-05 0 0.129291 0 0.13088)
(0.13024 -2.58522e-05 0 0.128355 0 0.130298)
(0.129655 -2.73792e-05 0 0.127454 0 0.129734)
(0.129085 -2.76049e-05 0 0.126584 0 0.129187)
(0.12853 -2.66089e-05 0 0.125745 0 0.128655)
(0.12799 -2.44894e-05 0 0.124935 0 0.12814)
(0.127465 -2.13499e-05 0 0.124152 0 0.127639)
(0.126954 -1.72924e-05 0 0.123394 0 0.127153)
(0.126458 -1.24128e-05 0 0.122661 0 0.126681)
(0.125975 -6.79975e-06 0 0.121952 0 0.126223)
(0.125506 -5.33145e-07 0 0.121265 0 0.125778)
(0.12505 6.31571e-06 0 0.120599 0 0.125346)
(0.124607 1.3684e-05 0 0.119953 0 0.124926)
(0.124176 2.15165e-05 0 0.119328 0 0.124518)
(0.123758 2.97653e-05 0 0.118721 0 0.124121)
(0.123351 3.83886e-05 0 0.118131 0 0.123736)
(0.122955 4.73499e-05 0 0.11756 0 0.123361)
(0.122571 5.66175e-05 0 0.117005 0 0.122997)
(0.122197 6.61635e-05 0 0.116465 0 0.122642)
(0.121834 7.59633e-05 0 0.115942 0 0.122298)
(0.121481 8.59947e-05 0 0.115433 0 0.121962)
(0.121137 9.62373e-05 0 0.114939 0 0.121636)
(0.120803 0.000106672 0 0.114458 0 0.121319)
(0.120478 0.000117282 0 0.113991 0 0.12101)
(0.120162 0.000128048 0 0.113536 0 0.12071)
(0.119855 0.000138954 0 0.113094 0 0.120418)
(0.119556 0.000149982 0 0.112664 0 0.120133)
(0.119265 0.000161121 0 0.112245 0 0.119856)
(0.118981 0.000172382 0 0.111837 0 0.119585)
(0.1187 0.000183933 0 0.111432 0 0.119316)
(0.132723 -4.7268e-06 0 0.132343 0 0.132726)
(0.132073 -9.41872e-06 0 0.131303 0 0.132083)
(0.131437 -1.33729e-05 0 0.130303 0 0.13146)
(0.130817 -1.64292e-05 0 0.12934 0 0.130855)
(0.130212 -1.85167e-05 0 0.128413 0 0.130268)
(0.129623 -1.96124e-05 0 0.12752 0 0.1297)
(0.12905 -1.97271e-05 0 0.126657 0 0.129148)
(0.128492 -1.88981e-05 0 0.125825 0 0.128613)
(0.127949 -1.71803e-05 0 0.125021 0 0.128094)
(0.127422 -1.46363e-05 0 0.124243 0 0.127591)
(0.126909 -1.13311e-05 0 0.123491 0 0.127102)
(0.12641 -7.32909e-06 0 0.122764 0 0.126627)
(0.125925 -2.69193e-06 0 0.122059 0 0.126166)
(0.125454 2.52281e-06 0 0.121376 0 0.125719)
(0.124996 8.26223e-06 0 0.120714 0 0.125284)
(0.124551 1.44783e-05 0 0.120073 0 0.124862)
(0.124119 2.11279e-05 0 0.119451 0 0.124452)
(0.123699 2.81723e-05 0 0.118847 0 0.124053)
(0.123291 3.55768e-05 0 0.118261 0 0.123666)
(0.122894 4.33106e-05 0 0.117693 0 0.12329)
(0.122508 5.1346e-05 0 0.11714 0 0.122924)
(0.122133 5.96581e-05 0 0.116604 0 0.122568)
(0.121769 6.8224e-05 0 0.116083 0 0.122222)
(0.121414 7.70231e-05 0 0.115577 0 0.121885)
(0.12107 8.60355e-05 0 0.115085 0 0.121557)
(0.120735 9.52428e-05 0 0.114607 0 0.121239)
(0.120409 0.000104627 0 0.114141 0 0.120929)
(0.120092 0.000114171 0 0.113689 0 0.120627)
(0.119784 0.000123858 0 0.113249 0 0.120333)
(0.119484 0.000133672 0 0.112821 0 0.120048)
(0.119193 0.000143599 0 0.112404 0 0.119769)
(0.118908 0.000153648 0 0.111997 0 0.119497)
(0.118627 0.000163964 0 0.111594 0 0.119228)
(0.132719 -2.84683e-06 0 0.132351 0 0.132723)
(0.132066 -5.68967e-06 0 0.131316 0 0.132076)
(0.131429 -8.09947e-06 0 0.13032 0 0.131451)
(0.130807 -9.96855e-06 0 0.129361 0 0.130844)
(0.130201 -1.12323e-05 0 0.128437 0 0.130256)
(0.129612 -1.18472e-05 0 0.127545 0 0.129686)
(0.129038 -1.17906e-05 0 0.126685 0 0.129134)
(0.128479 -1.10613e-05 0 0.125854 0 0.128597)
(0.127936 -9.67364e-06 0 0.125051 0 0.128077)
(0.127408 -7.65168e-06 0 0.124275 0 0.127573)
(0.126894 -5.02551e-06 0 0.123524 0 0.127083)
(0.126395 -1.8291e-06 0 0.122797 0 0.126608)
(0.12591 1.90175e-06 0 0.122093 0 0.126147)
(0.125439 6.13106e-06 0 0.121411 0 0.125698)
(0.124981 1.08238e-05 0 0.12075 0 0.125263)
(0.124536 1.59466e-05 0 0.120109 0 0.124841)
(0.124104 2.1468e-05 0 0.119488 0 0.12443)
(0.123684 2.73587e-05 0 0.118885 0 0.124031)
(0.123275 3.35914e-05 0 0.1183 0 0.123643)
(0.122878 4.01411e-05 0 0.117731 0 0.123266)
(0.122493 4.69844e-05 0 0.11718 0 0.1229)
(0.122118 5.40997e-05 0 0.116644 0 0.122543)
(0.121753 6.14667e-05 0 0.116123 0 0.122197)
(0.121399 6.90664e-05 0 0.115617 0 0.12186)
(0.121055 7.68808e-05 0 0.115126 0 0.121532)
(0.12072 8.48924e-05 0 0.114647 0 0.121213)
(0.120394 9.30841e-05 0 0.114182 0 0.120903)
(0.120077 0.000101439 0 0.11373 0 0.120601)
(0.119769 0.000109941 0 0.11329 0 0.120307)
(0.11947 0.000118574 0 0.112862 0 0.120021)
(0.119178 0.000127326 0 0.112445 0 0.119743)
(0.118894 0.000136204 0 0.112039 0 0.119471)
(0.118612 0.000145341 0 0.111635 0 0.119201)
(0.132725 -9.86914e-07 0 0.132339 0 0.132728)
(0.132077 -1.99426e-06 0 0.131295 0 0.132087)
(0.131444 -2.86674e-06 0 0.130291 0 0.131465)
(0.130825 -3.5497e-06 0 0.129324 0 0.130862)
(0.130223 -3.98519e-06 0 0.128394 0 0.130277)
(0.129636 -4.10877e-06 0 0.127497 0 0.12971)
(0.129065 -3.86475e-06 0 0.126632 0 0.129159)
(0.128509 -3.21393e-06 0 0.125796 0 0.128625)
(0.127968 -2.13113e-06 0 0.124989 0 0.128107)
(0.127442 -6.01967e-07 0 0.124209 0 0.127604)
(0.12693 1.37829e-06 0 0.123455 0 0.127116)
(0.126433 3.80593e-06 0 0.122724 0 0.126643)
(0.12595 6.67089e-06 0 0.122017 0 0.126183)
(0.125481 9.95873e-06 0 0.121332 0 0.125736)
(0.125024 1.36521e-05 0 0.120668 0 0.125302)
(0.124581 1.77319e-05 0 0.120024 0 0.12488)
(0.12415 2.2178e-05 0 0.1194 0 0.124471)
(0.123731 2.69703e-05 0 0.118794 0 0.124073)
(0.123324 3.20886e-05 0 0.118206 0 0.123686)
(0.122929 3.75133e-05 0 0.117636 0 0.12331)
(0.122544 4.32256e-05 0 0.117082 0 0.122945)
(0.122171 4.92071e-05 0 0.116543 0 0.122589)
(0.121807 5.54398e-05 0 0.11602 0 0.122244)
(0.121454 6.19067e-05 0 0.115512 0 0.121908)
(0.121111 6.85908e-05 0 0.115018 0 0.121581)
(0.120777 7.54757e-05 0 0.114538 0 0.121262)
(0.120453 8.25449e-05 0 0.114071 0 0.120953)
(0.120137 8.97825e-05 0 0.113617 0 0.120652)
(0.11983 9.71723e-05 0 0.113175 0 0.120358)
(0.119531 0.000104698 0 0.112745 0 0.120073)
(0.119241 0.000112348 0 0.112327 0 0.119795)
(0.118957 0.000120125 0 0.111918 0 0.119524)
(0.118677 0.000128142 0 0.111513 0 0.119255)
(0.132733 9.41501e-07 0 0.132323 0 0.132737)
(0.132094 1.81841e-06 0 0.131261 0 0.132104)
(0.131468 2.50019e-06 0 0.130242 0 0.131489)
(0.130857 2.99083e-06 0 0.129262 0 0.130893)
(0.130261 3.35005e-06 0 0.128319 0 0.130315)
(0.12968 3.67153e-06 0 0.12741 0 0.129753)
(0.129114 4.04958e-06 0 0.126534 0 0.129208)
(0.128563 4.56474e-06 0 0.125688 0 0.128679)
(0.128027 5.28384e-06 0 0.124871 0 0.128166)
(0.127506 6.26058e-06 0 0.124082 0 0.127667)
(0.126999 7.53469e-06 0 0.123319 0 0.127183)
(0.126506 9.13272e-06 0 0.12258 0 0.126714)
(0.126027 1.10703e-05 0 0.121865 0 0.126257)
(0.125561 1.33548e-05 0 0.121173 0 0.125814)
(0.125108 1.59869e-05 0 0.120502 0 0.125383)
(0.124669 1.89622e-05 0 0.119852 0 0.124965)
(0.124241 2.2273e-05 0 0.119221 0 0.124558)
(0.123825 2.59086e-05 0 0.118609 0 0.124163)
(0.123422 2.98567e-05 0 0.118016 0 0.123779)
(0.123029 3.4104e-05 0 0.117439 0 0.123406)
(0.122647 3.86362e-05 0 0.11688 0 0.123043)
(0.122276 4.34386e-05 0 0.116337 0 0.12269)
(0.121916 4.84963e-05 0 0.115809 0 0.122346)
(0.121565 5.37943e-05 0 0.115296 0 0.122012)
(0.121224 5.93173e-05 0 0.114798 0 0.121688)
(0.120893 6.50501e-05 0 0.114313 0 0.121372)
(0.120571 7.09776e-05 0 0.113842 0 0.121064)
(0.120257 7.70844e-05 0 0.113384 0 0.120765)
(0.119952 8.33555e-05 0 0.112938 0 0.120473)
(0.119656 8.97763e-05 0 0.112504 0 0.12019)
(0.119367 9.63358e-05 0 0.112082 0 0.119913)
(0.119086 0.000103037 0 0.111669 0 0.119644)
(0.118807 0.000109984 0 0.111261 0 0.119376)
(0.132743 2.99245e-06 0 0.132302 0 0.132747)
(0.132114 5.85592e-06 0 0.131221 0 0.132124)
(0.131498 8.1423e-06 0 0.130182 0 0.13152)
(0.130896 9.80268e-06 0 0.129183 0 0.130933)
(0.130308 1.09103e-05 0 0.128222 0 0.130363)
(0.129736 1.16017e-05 0 0.127297 0 0.12981)
(0.129178 1.202e-05 0 0.126405 0 0.129273)
(0.128634 1.22958e-05 0 0.125544 0 0.128751)
(0.128106 1.25453e-05 0 0.124713 0 0.128245)
(0.127591 1.28683e-05 0 0.123911 0 0.127753)
(0.127091 1.33438e-05 0 0.123134 0 0.127275)
(0.126604 1.40308e-05 0 0.122383 0 0.126811)
(0.126131 1.49717e-05 0 0.121656 0 0.126361)
(0.125671 1.61952e-05 0 0.120952 0 0.125923)
(0.125224 1.77197e-05 0 0.12027 0 0.125498)
(0.124789 1.95546e-05 0 0.119609 0 0.125084)
(0.124366 2.17032e-05 0 0.118969 0 0.124682)
(0.123956 2.41638e-05 0 0.118347 0 0.124292)
(0.123557 2.69311e-05 0 0.117744 0 0.123912)
(0.123168 2.99973e-05 0 0.117159 0 0.123543)
(0.122791 3.33525e-05 0 0.11659 0 0.123184)
(0.122425 3.69855e-05 0 0.116039 0 0.122835)
(0.122068 4.08841e-05 0 0.115503 0 0.122495)
(0.121721 4.50352e-05 0 0.114982 0 0.122165)
(0.121384 4.94254e-05 0 0.114476 0 0.121843)
(0.121056 5.40406e-05 0 0.113984 0 0.12153)
(0.120738 5.88666e-05 0 0.113505 0 0.121226)
(0.120428 6.38888e-05 0 0.11304 0 0.12093)
(0.120126 6.90925e-05 0 0.112588 0 0.120641)
(0.119833 7.44629e-05 0 0.112147 0 0.120361)
(0.119548 7.99873e-05 0 0.111719 0 0.120087)
(0.119269 8.5665e-05 0 0.1113 0 0.11982)
(0.118994 9.15789e-05 0 0.110886 0 0.119555)
(0.132755 5.23437e-06 0 0.132279 0 0.132759)
(0.132138 1.02424e-05 0 0.131172 0 0.132149)
(0.131534 1.42087e-05 0 0.13011 0 0.131556)
(0.130942 1.70301e-05 0 0.129088 0 0.130981)
(0.130365 1.88146e-05 0 0.128106 0 0.130422)
(0.129803 1.9762e-05 0 0.12716 0 0.129879)
(0.129255 2.00754e-05 0 0.126248 0 0.129352)
(0.128721 1.99411e-05 0 0.125369 0 0.12884)
(0.128201 1.95311e-05 0 0.124519 0 0.128343)
(0.127695 1.89965e-05 0 0.123699 0 0.12786)
(0.127204 1.84614e-05 0 0.122906 0 0.12739)
(0.126725 1.80228e-05 0 0.122138 0 0.126935)
(0.12626 1.77549e-05 0 0.121396 0 0.126492)
(0.125808 1.77131e-05 0 0.120677 0 0.126062)
(0.125368 1.7937e-05 0 0.11998 0 0.125643)
(0.124941 1.84535e-05 0 0.119305 0 0.125237)
(0.124525 1.92794e-05 0 0.118651 0 0.124842)
(0.124121 2.04235e-05 0 0.118016 0 0.124458)
(0.123729 2.1889e-05 0 0.117401 0 0.124084)
(0.123347 2.36742e-05 0 0.116803 0 0.123721)
(0.122976 2.5774e-05 0 0.116223 0 0.123368)
(0.122615 2.81807e-05 0 0.11566 0 0.123024)
(0.122264 3.08847e-05 0 0.115113 0 0.12269)
(0.121923 3.38746e-05 0 0.114582 0 0.122364)
(0.121592 3.71382e-05 0 0.114065 0 0.122048)
(0.121269 4.06622e-05 0 0.113563 0 0.12174)
(0.120956 4.4433e-05 0 0.113075 0 0.12144)
(0.120651 4.84362e-05 0 0.1126 0 0.121148)
(0.120354 5.26577e-05 0 0.112138 0 0.120864)
(0.120065 5.70836e-05 0 0.111689 0 0.120588)
(0.119784 6.17027e-05 0 0.111252 0 0.120318)
(0.11951 6.65152e-05 0 0.110825 0 0.120055)
(0.119239 7.15994e-05 0 0.110402 0 0.119794)
(0.13277 7.75897e-06 0 0.13225 0 0.132773)
(0.132167 1.51322e-05 0 0.131113 0 0.132179)
(0.131576 2.0862e-05 0 0.130022 0 0.131601)
(0.130998 2.47979e-05 0 0.128974 0 0.131039)
(0.130434 2.71273e-05 0 0.127966 0 0.130493)
(0.129884 2.81563e-05 0 0.126994 0 0.129963)
(0.129348 2.81778e-05 0 0.126058 0 0.129448)
(0.128825 2.74571e-05 0 0.125155 0 0.128948)
(0.128317 2.62373e-05 0 0.124282 0 0.128463)
(0.127822 2.47293e-05 0 0.123439 0 0.127991)
(0.127341 2.3103e-05 0 0.122624 0 0.127532)
(0.126873 2.14913e-05 0 0.121836 0 0.127086)
(0.126418 1.99979e-05 0 0.121073 0 0.126653)
(0.125975 1.87024e-05 0 0.120334 0 0.126233)
(0.125545 1.76642e-05 0 0.119618 0 0.125824)
(0.125127 1.69262e-05 0 0.118924 0 0.125426)
(0.12472 1.65181e-05 0 0.118251 0 0.125039)
(0.124325 1.64592e-05 0 0.117599 0 0.124663)
(0.123941 1.67607e-05 0 0.116966 0 0.124298)
(0.123567 1.74273e-05 0 0.116352 0 0.123942)
(0.123204 1.84585e-05 0 0.115756 0 0.123596)
(0.122851 1.985e-05 0 0.115177 0 0.12326)
(0.122508 2.1594e-05 0 0.114615 0 0.122933)
(0.122174 2.36805e-05 0 0.114068 0 0.122614)
(0.12185 2.60975e-05 0 0.113537 0 0.122304)
(0.121534 2.88315e-05 0 0.113021 0 0.122002)
(0.121227 3.18679e-05 0 0.11252 0 0.121708)
(0.120929 3.51911e-05 0 0.112032 0 0.121422)
(0.120639 3.87848e-05 0 0.111557 0 0.121144)
(0.120356 4.26325e-05 0 0.111096 0 0.120872)
(0.120082 4.67189e-05 0 0.110646 0 0.120608)
(0.119814 5.10389e-05 0 0.110207 0 0.12035)
(0.119548 5.56575e-05 0 0.109773 0 0.120094)
(0.132787 1.07032e-05 0 0.132214 0 0.132791)
(0.132203 2.07476e-05 0 0.131041 0 0.132215)
(0.131629 2.83233e-05 0 0.129915 0 0.131655)
(0.131067 3.32626e-05 0 0.128833 0 0.131111)
(0.130518 3.59009e-05 0 0.127793 0 0.130582)
(0.129983 3.66897e-05 0 0.12679 0 0.130068)
(0.129462 3.60302e-05 0 0.125824 0 0.129568)
(0.128954 3.4294e-05 0 0.124891 0 0.129083)
(0.12846 3.18334e-05 0 0.123991 0 0.128612)
(0.127979 2.89535e-05 0 0.12312 0 0.128154)
(0.127512 2.58965e-05 0 0.122279 0 0.127709)
(0.127057 2.28506e-05 0 0.121464 0 0.127277)
(0.126615 1.99616e-05 0 0.120676 0 0.126857)
(0.126185 1.73407e-05 0 0.119912 0 0.126448)
(0.125768 1.50698e-05 0 0.119172 0 0.126051)
(0.125362 1.32068e-05 0 0.118455 0 0.125665)
(0.124967 1.17916e-05 0 0.11776 0 0.125289)
(0.124583 1.08493e-05 0 0.117085 0 0.124924)
(0.124211 1.03938e-05 0 0.116431 0 0.124569)
(0.123848 1.04301e-05 0 0.115796 0 0.124223)
(0.123496 1.09561e-05 0 0.115179 0 0.123887)
(0.123153 1.19645e-05 0 0.11458 0 0.12356)
(0.12282 1.34437e-05 0 0.113998 0 0.123241)
(0.122496 1.5379e-05 0 0.113433 0 0.122931)
(0.122182 1.77531e-05 0 0.112883 0 0.122629)
(0.121876 2.0547e-05 0 0.112349 0 0.122335)
(0.121578 2.37405e-05 0 0.111829 0 0.122049)
(0.121288 2.73124e-05 0 0.111324 0 0.12177)
(0.121007 3.12414e-05 0 0.110833 0 0.121499)
(0.120733 3.55065e-05 0 0.110355 0 0.121234)
(0.120466 4.00896e-05 0 0.109889 0 0.120976)
(0.120206 4.49857e-05 0 0.109435 0 0.120724)
(0.119948 5.02743e-05 0 0.108984 0 0.120474)
(0.13281 1.4286e-05 0 0.132169 0 0.132814)
(0.132248 2.74177e-05 0 0.130949 0 0.132262)
(0.131695 3.68772e-05 0 0.129779 0 0.131725)
(0.131153 4.26197e-05 0 0.128655 0 0.131202)
(0.130625 4.53447e-05 0 0.127573 0 0.130694)
(0.130109 4.57758e-05 0 0.12653 0 0.130201)
(0.129606 4.4464e-05 0 0.125524 0 0.129721)
(0.129117 4.18969e-05 0 0.124553 0 0.129255)
(0.128641 3.85354e-05 0 0.123614 0 0.128802)
(0.128178 3.47716e-05 0 0.122706 0 0.128362)
(0.127728 3.09132e-05 0 0.121828 0 0.127934)
(0.127291 2.71991e-05 0 0.120977 0 0.127518)
(0.126866 2.38151e-05 0 0.120154 0 0.127114)
(0.126454 2.09015e-05 0 0.119356 0 0.126721)
(0.126052 1.8559e-05 0 0.118583 0 0.126339)
(0.125663 1.68565e-05 0 0.117834 0 0.125967)
(0.125284 1.58373e-05 0 0.117107 0 0.125606)
(0.124916 1.55248e-05 0 0.116402 0 0.125254)
(0.124559 1.59263e-05 0 0.115717 0 0.124912)
(0.124211 1.70369e-05 0 0.115053 0 0.124578)
(0.123873 1.88422e-05 0 0.114408 0 0.124254)
(0.123545 2.13208e-05 0 0.113781 0 0.123938)
(0.123226 2.44459e-05 0 0.113172 0 0.12363)
(0.122916 2.81873e-05 0 0.11258 0 0.123331)
(0.122614 3.2512e-05 0 0.112005 0 0.123039)
(0.122321 3.73856e-05 0 0.111446 0 0.122754)
(0.122036 4.27729e-05 0 0.110903 0 0.122477)
(0.121758 4.86382e-05 0 0.110374 0 0.122207)
(0.121489 5.49462e-05 0 0.10986 0 0.121943)
(0.121226 6.16624e-05 0 0.109359 0 0.121686)
(0.120971 6.87564e-05 0 0.108872 0 0.121436)
(0.120722 7.62177e-05 0 0.108396 0 0.121191)
(0.120475 8.41531e-05 0 0.107925 0 0.120948)
(0.132839 1.88991e-05 0 0.132109 0 0.132844)
(0.132306 3.57631e-05 0 0.13083 0 0.132323)
(0.131781 4.71238e-05 0 0.129602 0 0.131816)
(0.131266 5.32702e-05 0 0.128423 0 0.131322)
(0.130764 5.5539e-05 0 0.127287 0 0.130842)
(0.130275 5.51271e-05 0 0.126192 0 0.130376)
(0.129799 5.29277e-05 0 0.125136 0 0.129923)
(0.129336 4.97243e-05 0 0.124114 0 0.129483)
(0.128887 4.61959e-05 0 0.123127 0 0.129055)
(0.12845 4.28548e-05 0 0.122171 0 0.128639)
(0.128026 4.00595e-05 0 0.121245 0 0.128234)
(0.127614 3.80621e-05 0 0.120348 0 0.127841)
(0.127214 3.70364e-05 0 0.119479 0 0.127458)
(0.126826 3.70916e-05 0 0.118636 0 0.127086)
(0.126449 3.82854e-05 0 0.117818 0 0.126723)
(0.126083 4.06371e-05 0 0.117025 0 0.12637)
(0.125728 4.41379e-05 0 0.116255 0 0.126026)
(0.125382 4.87584e-05 0 0.115508 0 0.125691)
(0.125047 5.44541e-05 0 0.114782 0 0.125365)
(0.124721 6.11705e-05 0 0.114078 0 0.125046)
(0.124404 6.88461e-05 0 0.113393 0 0.124736)
(0.124097 7.74157e-05 0 0.112728 0 0.124433)
(0.123797 8.68119e-05 0 0.112082 0 0.124138)
(0.123506 9.69672e-05 0 0.111454 0 0.12385)
(0.123223 0.000107815 0 0.110844 0 0.123569)
(0.122948 0.00011929 0 0.11025 0 0.123295)
(0.12268 0.000131329 0 0.109673 0 0.123027)
(0.12242 0.000143874 0 0.109111 0 0.122766)
(0.122166 0.000156867 0 0.108565 0 0.122511)
(0.121919 0.000170257 0 0.108034 0 0.122262)
(0.121679 0.000183999 0 0.107517 0 0.122018)
(0.121444 0.000198088 0 0.107012 0 0.12178)
(0.121212 0.000212717 0 0.106512 0 0.121543)
(0.132879 2.53122e-05 0 0.132029 0 0.132885)
(0.132386 4.71666e-05 0 0.130667 0 0.132407)
(0.131899 6.14426e-05 0 0.12936 0 0.13194)
(0.131421 6.98614e-05 0 0.128101 0 0.131486)
(0.130957 7.48833e-05 0 0.126885 0 0.131044)
(0.130506 7.80118e-05 0 0.12571 0 0.130615)
(0.130069 8.02548e-05 0 0.124575 0 0.130198)
(0.129646 8.25984e-05 0 0.123476 0 0.129792)
(0.129236 8.58795e-05 0 0.122412 0 0.129397)
(0.128839 9.06415e-05 0 0.121381 0 0.129013)
(0.128454 9.71884e-05 0 0.120382 0 0.128639)
(0.128082 0.000105678 0 0.119413 0 0.128275)
(0.127721 0.000116164 0 0.118474 0 0.127919)
(0.127371 0.00012862 0 0.117563 0 0.127572)
(0.127032 0.000142957 0 0.116679 0 0.127234)
(0.126703 0.000159052 0 0.115821 0 0.126903)
(0.126383 0.000176759 0 0.114988 0 0.12658)
(0.126073 0.000195923 0 0.114179 0 0.126264)
(0.125771 0.000216385 0 0.113394 0 0.125955)
(0.125478 0.00023799 0 0.112632 0 0.125653)
(0.125192 0.000260588 0 0.111892 0 0.125357)
(0.124915 0.000284037 0 0.111173 0 0.125068)
(0.124645 0.000308208 0 0.110474 0 0.124786)
(0.124382 0.000332979 0 0.109795 0 0.124509)
(0.124126 0.000358239 0 0.109136 0 0.124238)
(0.123877 0.000383888 0 0.108495 0 0.123973)
(0.123634 0.000409836 0 0.107872 0 0.123713)
(0.123397 0.000436001 0 0.107266 0 0.123459)
(0.123167 0.000462312 0 0.106677 0 0.12321)
(0.122942 0.000488705 0 0.106105 0 0.122967)
(0.122723 0.000515137 0 0.105548 0 0.122728)
(0.122508 0.000541627 0 0.105004 0 0.122494)
(0.122296 0.000568536 0 0.104467 0 0.122261)
(0.132936 3.61115e-05 0 0.131913 0 0.132944)
(0.132503 6.70917e-05 0 0.130434 0 0.132528)
(0.132077 8.83687e-05 0 0.129013 0 0.132122)
(0.131663 0.000105492 0 0.127642 0 0.131727)
(0.131266 0.000123604 0 0.126315 0 0.131343)
(0.130884 0.000144687 0 0.125029 0 0.13097)
(0.130516 0.000169342 0 0.12378 0 0.130605)
(0.130163 0.000197991 0 0.122567 0 0.130248)
(0.129823 0.0002308 0 0.12139 0 0.129899)
(0.129497 0.000267573 0 0.120246 0 0.129558)
(0.129182 0.000307906 0 0.119135 0 0.129223)
(0.128878 0.000351341 0 0.118057 0 0.128894)
(0.128583 0.000397411 0 0.117011 0 0.128571)
(0.128298 0.000445659 0 0.115995 0 0.128253)
(0.128022 0.00049565 0 0.11501 0 0.127941)
(0.127753 0.000546987 0 0.114054 0 0.127633)
(0.127492 0.000599314 0 0.113126 0 0.127331)
(0.127237 0.000652319 0 0.112226 0 0.127033)
(0.126989 0.000705728 0 0.111353 0 0.12674)
(0.126747 0.000759305 0 0.110506 0 0.126452)
(0.126511 0.000812851 0 0.109684 0 0.126168)
(0.12628 0.000866194 0 0.108887 0 0.125888)
(0.126054 0.000919192 0 0.108113 0 0.125614)
(0.125834 0.000971725 0 0.107362 0 0.125343)
(0.125618 0.00102369 0 0.106634 0 0.125078)
(0.125407 0.00107502 0 0.105926 0 0.124816)
(0.1252 0.00112564 0 0.10524 0 0.124559)
(0.124998 0.00117549 0 0.104574 0 0.124307)
(0.124801 0.00122454 0 0.103927 0 0.124059)
(0.124607 0.00127276 0 0.103298 0 0.123815)
(0.124417 0.00132015 0 0.102688 0 0.123576)
(0.124231 0.00136678 0 0.102094 0 0.12334)
(0.124046 0.0014133 0 0.101506 0 0.123104)
(0.13303 6.56697e-05 0 0.131731 0 0.133038)
(0.132702 0.000139744 0 0.130049 0 0.132719)
(0.132389 0.000215332 0 0.128415 0 0.132406)
(0.132103 0.00029859 0 0.126827 0 0.132101)
(0.131843 0.00039226 0 0.125285 0 0.131802)
(0.131603 0.000495193 0 0.123787 0 0.131508)
(0.131381 0.000605632 0 0.122332 0 0.131216)
(0.131173 0.000722059 0 0.120917 0 0.130926)
(0.130978 0.000842855 0 0.119544 0 0.130637)
(0.130793 0.000966349 0 0.118211 0 0.130347)
(0.130615 0.00109106 0 0.116919 0 0.130058)
(0.130443 0.0012158 0 0.115666 0 0.129769)
(0.130275 0.00133961 0 0.114453 0 0.12948)
(0.130112 0.00146173 0 0.113277 0 0.129192)
(0.129951 0.0015816 0 0.11214 0 0.128904)
(0.129793 0.0016988 0 0.111039 0 0.128616)
(0.129637 0.00181304 0 0.109974 0 0.12833)
(0.129482 0.00192413 0 0.108944 0 0.128045)
(0.129328 0.00203196 0 0.107947 0 0.127762)
(0.129176 0.00213649 0 0.106983 0 0.127481)
(0.129024 0.00223772 0 0.10605 0 0.127202)
(0.128874 0.00233567 0 0.105148 0 0.126925)
(0.128724 0.00243043 0 0.104275 0 0.126651)
(0.128576 0.00252205 0 0.103431 0 0.126379)
(0.128429 0.00261065 0 0.102615 0 0.126111)
(0.128283 0.00269632 0 0.101824 0 0.125846)
(0.128138 0.00277917 0 0.101059 0 0.125584)
(0.127994 0.0028593 0 0.100319 0 0.125326)
(0.127852 0.00293683 0 0.0996019 0 0.125071)
(0.127711 0.00301188 0 0.0989077 0 0.12482)
(0.127572 0.00308459 0 0.0982351 0 0.124572)
(0.127434 0.00315522 0 0.097582 0 0.124328)
(0.127295 0.00322483 0 0.096939 0 0.124083)
(0.133253 0.000219926 0 0.131421 0 0.133214)
(0.133216 0.000514503 0 0.12941 0 0.133078)
(0.133236 0.000849257 0 0.127418 0 0.132936)
(0.133311 0.00121672 0 0.125448 0 0.132789)
(0.133427 0.00159771 0 0.123513 0 0.132633)
(0.133567 0.00197544 0 0.121622 0 0.132465)
(0.133721 0.00234142 0 0.119782 0 0.132285)
(0.133882 0.00269178 0 0.117996 0 0.132093)
(0.134044 0.00302421 0 0.116269 0 0.131888)
(0.134202 0.00333743 0 0.114602 0 0.131673)
(0.134352 0.00363121 0 0.112995 0 0.131447)
(0.134494 0.00390604 0 0.111448 0 0.131213)
(0.134625 0.00416279 0 0.109961 0 0.13097)
(0.134744 0.00440253 0 0.10853 0 0.13072)
(0.134853 0.00462639 0 0.107156 0 0.130465)
(0.134949 0.00483557 0 0.105836 0 0.130205)
(0.135034 0.00503122 0 0.104568 0 0.129941)
(0.135108 0.00521447 0 0.103349 0 0.129674)
(0.135172 0.00538636 0 0.102179 0 0.129405)
(0.135225 0.00554788 0 0.101055 0 0.129135)
(0.135269 0.00569991 0 0.0999745 0 0.128864)
(0.135305 0.0058433 0 0.0989362 0 0.128593)
(0.135332 0.00597879 0 0.0979381 0 0.128323)
(0.135352 0.00610707 0 0.0969784 0 0.128054)
(0.135364 0.00622875 0 0.0960555 0 0.127786)
(0.135371 0.0063444 0 0.0951677 0 0.12752)
(0.135371 0.00645451 0 0.0943134 0 0.127257)
(0.135367 0.00655954 0 0.0934911 0 0.126996)
(0.135357 0.00665987 0 0.0926994 0 0.126737)
(0.135343 0.00675584 0 0.0919369 0 0.126482)
(0.135325 0.00684775 0 0.0912023 0 0.12623)
(0.135304 0.00693599 0 0.0904933 0 0.125981)
(0.13528 0.00702179 0 0.0898008 0 0.125732)
(0.134245 0.00198965 0 0.130543 0 0.133667)
(0.135642 0.00441956 0 0.127472 0 0.134029)
(0.137282 0.00677636 0 0.12443 0 0.134383)
(0.139045 0.00898983 0 0.121465 0 0.134716)
(0.140844 0.0110298 0 0.118608 0 0.135013)
(0.142635 0.0128871 0 0.115875 0 0.135273)
(0.144394 0.0145716 0 0.113275 0 0.135498)
(0.146108 0.0161008 0 0.110812 0 0.135691)
(0.147766 0.017492 0 0.108485 0 0.135853)
(0.149364 0.0187613 0 0.106289 0 0.135988)
(0.150899 0.0199231 0 0.104222 0 0.136099)
(0.152371 0.0209905 0 0.102276 0 0.136188)
(0.153781 0.0219747 0 0.100447 0 0.136258)
(0.15513 0.0228856 0 0.0987272 0 0.136312)
(0.156422 0.0237318 0 0.097111 0 0.136351)
(0.157657 0.0245203 0 0.0955921 0 0.136377)
(0.15884 0.0252577 0 0.0941645 0 0.136393)
(0.159973 0.0259491 0 0.0928226 0 0.136399)
(0.161057 0.0265993 0 0.0915609 0 0.136398)
(0.162097 0.0272122 0 0.0903744 0 0.13639)
(0.163093 0.0277914 0 0.0892581 0 0.136376)
(0.16405 0.0283399 0 0.0882076 0 0.136358)
(0.164967 0.0288603 0 0.0872187 0 0.136336)
(0.165849 0.0293549 0 0.0862874 0 0.136311)
(0.166696 0.0298259 0 0.08541 0 0.136284)
(0.167512 0.0302749 0 0.0845831 0 0.136254)
(0.168296 0.0307037 0 0.0838036 0 0.136223)
(0.169052 0.0311137 0 0.0830683 0 0.136191)
(0.16978 0.0315061 0 0.0823745 0 0.136159)
(0.170483 0.0318823 0 0.0817197 0 0.136126)
(0.17116 0.0322433 0 0.0811015 0 0.136094)
(0.171816 0.0325902 0 0.0805175 0 0.136061)
(0.172457 0.0329267 0 0.0799625 0 0.136031)
(0.153287 0.0371801 0 0.126079 0 0.139664)
(0.1751 0.0584548 0 0.118906 0 0.146688)
(0.195336 0.0714444 0 0.112966 0 0.153314)
(0.214186 0.0800748 0 0.108075 0 0.159598)
(0.231802 0.0860709 0 0.104077 0 0.165587)
(0.24831 0.0903587 0 0.10084 0 0.171316)
(0.26381 0.093495 0 0.0982535 0 0.176811)
(0.278387 0.0958404 0 0.0962213 0 0.182095)
(0.292113 0.0976384 0 0.0946618 0 0.187182)
(0.305051 0.0990577 0 0.093504 0 0.192086)
(0.317259 0.100216 0 0.0926868 0 0.196819)
(0.328786 0.101197 0 0.0921573 0 0.201388)
(0.339679 0.102059 0 0.0918701 0 0.205801)
(0.349978 0.102843 0 0.0917857 0 0.210063)
(0.359719 0.103578 0 0.0918704 0 0.21418)
(0.368939 0.104282 0 0.0920951 0 0.218157)
(0.377667 0.104967 0 0.0924347 0 0.221997)
(0.385933 0.105643 0 0.092868 0 0.225703)
(0.393764 0.106312 0 0.0933764 0 0.22928)
(0.401184 0.106977 0 0.0939444 0 0.23273)
(0.408218 0.107639 0 0.0945586 0 0.236056)
(0.414885 0.108297 0 0.0952076 0 0.239262)
(0.421207 0.10895 0 0.0958819 0 0.24235)
(0.427202 0.109596 0 0.0965732 0 0.245324)
(0.432889 0.110234 0 0.0972747 0 0.248186)
(0.438283 0.110862 0 0.0979808 0 0.25094)
(0.443401 0.111478 0 0.0986865 0 0.253588)
(0.448257 0.112083 0 0.0993879 0 0.256133)
(0.452866 0.112673 0 0.100082 0 0.25858)
(0.45724 0.113248 0 0.100765 0 0.26093)
(0.461391 0.113807 0 0.101436 0 0.263186)
(0.465334 0.11435 0 0.102094 0 0.265354)
(0.469105 0.114881 0 0.102741 0 0.26745)
(0.703992 -0.183392 0 0.188204 0 0.396319)
(0.85652 -0.260166 0 0.306258 0 0.447384)
(1.03463 -0.341051 0 0.419576 0 0.514754)
(1.22247 -0.419904 0 0.526269 0 0.591181)
(1.39097 -0.48729 0 0.617794 0 0.664155)
(1.52746 -0.540322 0 0.691832 0 0.727009)
(1.63108 -0.580086 0 0.749515 0 0.777754)
(1.70637 -0.60912 0 0.793441 0 0.817034)
(1.75998 -0.630255 0 0.826806 0 0.846874)
(1.79825 -0.645901 0 0.852523 0 0.86958)
(1.8259 -0.657735 0 0.872739 0 0.88705)
(1.84586 -0.666734 0 0.88883 0 0.900563)
(1.86028 -0.6736 0 0.901768 0 0.911106)
(1.87056 -0.678772 0 0.912162 0 0.919357)
(1.87757 -0.682424 0 0.920221 0 0.925747)
(1.88215 -0.684435 0 0.925445 0 0.930624)
(1.88525 -0.684362 0 0.92608 0 0.934404)
(1.88989 -0.682144 0 0.9181 0 0.938988)
(1.88902 -0.678713 0 0.911484 0 0.940978)
(1.88367 -0.674448 0 0.905239 0 0.940863)
(1.8748 -0.669527 0 0.89885 0 0.939037)
(1.86326 -0.664065 0 0.892058 0 0.935843)
(1.84989 -0.658203 0 0.884787 0 0.931607)
(1.83545 -0.652115 0 0.877119 0 0.926649)
(1.8206 -0.645981 0 0.869227 0 0.921266)
(1.80584 -0.639949 0 0.861294 0 0.915715)
(1.79158 -0.634132 0 0.853466 0 0.910207)
(1.77816 -0.628627 0 0.845852 0 0.904918)
(1.76589 -0.623519 0 0.838543 0 0.899991)
(1.75498 -0.618877 0 0.83163 0 0.895542)
(1.74555 -0.614748 0 0.825189 0 0.891654)
(1.73769 -0.611159 0 0.819274 0 0.888386)
(1.73143 -0.608122 0 0.813913 0 0.885772)
(1.72676 -0.605639 0 0.809115 0 0.883828)
(1.72365 -0.603702 0 0.804877 0 0.882546)
(1.72199 -0.602289 0 0.801184 0 0.881898)
(1.72164 -0.601357 0 0.798002 0 0.881835)
(1.72242 -0.600851 0 0.795277 0 0.882289)
(1.72415 -0.600707 0 0.792944 0 0.883179)
(1.7266 -0.600852 0 0.790927 0 0.884417)
(1.72956 -0.601212 0 0.789144 0 0.885903)
(1.73279 -0.601708 0 0.78751 0 0.887534)
(1.73606 -0.602258 0 0.785937 0 0.889206)
(1.73914 -0.602781 0 0.784335 0 0.890809)
(1.7418 -0.603195 0 0.782616 0 0.89224)
(1.74383 -0.603422 0 0.780692 0 0.893395)
(1.74501 -0.603384 0 0.778479 0 0.894176)
(1.74516 -0.603008 0 0.775896 0 0.894489)
(1.7441 -0.602227 0 0.772869 0 0.89425)
(1.74169 -0.600979 0 0.76933 0 0.893381)
(1.73778 -0.599212 0 0.765219 0 0.891814)
(1.73228 -0.596879 0 0.760487 0 0.889489)
(1.72508 -0.593943 0 0.755091 0 0.88636)
(1.71612 -0.590377 0 0.749 0 0.882387)
(1.70536 -0.58616 0 0.742194 0 0.877546)
(1.69278 -0.581282 0 0.734659 0 0.871819)
(1.67838 -0.575742 0 0.726395 0 0.865203)
(1.66218 -0.569545 0 0.717409 0 0.857704)
(1.64423 -0.562708 0 0.707718 0 0.84934)
(1.6246 -0.555253 0 0.697348 0 0.84014)
(1.60338 -0.547212 0 0.686336 0 0.830142)
(1.58068 -0.538624 0 0.674724 0 0.819396)
(1.55662 -0.529534 0 0.662565 0 0.807959)
(1.53134 -0.519993 0 0.649918 0 0.7959)
(1.505 -0.510058 0 0.636848 0 0.783293)
(1.47777 -0.499791 0 0.623425 0 0.770217)
(1.44982 -0.489256 0 0.609723 0 0.75676)
(1.42133 -0.478521 0 0.595821 0 0.743012)
(1.39251 -0.467655 0 0.581795 0 0.729064)
(1.36352 -0.456728 0 0.567727 0 0.715013)
(1.33458 -0.445811 0 0.553697 0 0.700951)
(1.30585 -0.434976 0 0.539783 0 0.686973)
(1.27753 -0.42429 0 0.526064 0 0.673171)
(1.24978 -0.413819 0 0.512611 0 0.65963)
(1.22276 -0.403625 0 0.499496 0 0.646433)
(1.19661 -0.393764 0 0.48678 0 0.633653)
(1.17146 -0.384283 0 0.474518 0 0.621356)
(1.14739 -0.375219 0 0.462756 0 0.609593)
(1.12447 -0.366595 0 0.451522 0 0.598405)
(1.10275 -0.358421 0 0.440834 0 0.587817)
(1.08225 -0.350699 0 0.430695 0 0.577844)
(1.06297 -0.34342 0 0.4211 0 0.568491)
(1.04491 -0.336575 0 0.412038 0 0.559755)
(1.02804 -0.330148 0 0.403496 0 0.551623)
(1.01231 -0.32412 0 0.395453 0 0.544076)
(0.997659 -0.318465 0 0.387883 0 0.537085)
(0.98402 -0.313154 0 0.380757 0 0.530616)
(0.971305 -0.30815 0 0.37404 0 0.524627)
(0.959421 -0.303418 0 0.367692 0 0.519074)
(0.948265 -0.298916 0 0.361674 0 0.513906)
(0.937735 -0.294603 0 0.35594 0 0.509068)
(0.927723 -0.290436 0 0.350444 0 0.504507)
(0.918136 -0.286373 0 0.345142 0 0.50017)
(0.908881 -0.282379 0 0.339987 0 0.496006)
(0.899949 -0.278433 0 0.33495 0 0.491996)
(0.891311 -0.274542 0 0.330013 0 0.488123)
(0.883318 -0.270807 0 0.325243 0 0.484518)
(0.876088 -0.267403 0 0.320763 0 0.481283)
(0.871168 -0.265014 0 0.317205 0 0.479083)
(0.868451 -0.263568 0 0.314748 0 0.478044)
(0.296652 -0.0773868 0 0.0988084 0 0.180222)
(0.313054 -0.0854737 0 0.114532 0 0.187454)
(0.346271 -0.0995775 0 0.13672 0 0.20133)
(0.400268 -0.121155 0 0.167718 0 0.224233)
(0.473854 -0.149586 0 0.207274 0 0.256171)
(0.562973 -0.183223 0 0.253705 0 0.295764)
(0.661297 -0.219705 0 0.304223 0 0.340439)
(0.762178 -0.25667 0 0.355795 0 0.387269)
(0.860195 -0.292274 0 0.405883 0 0.433692)
(0.951612 -0.325312 0 0.452709 0 0.477792)
(1.03437 -0.355177 0 0.495272 0 0.518372)
(1.10773 -0.381718 0 0.533215 0 0.554867)
(1.172 -0.405112 0 0.566681 0 0.587228)
(1.22805 -0.425697 0 0.596095 0 0.615733)
(1.27692 -0.44382 0 0.621921 0 0.640799)
(1.31968 -0.459702 0 0.644389 0 0.662858)
(1.35738 -0.473317 0 0.663013 0 0.68235)
(1.39339 -0.484389 0 0.673874 0 0.700609)
(1.4239 -0.493654 0 0.683518 0 0.716435)
(1.4493 -0.501409 0 0.691977 0 0.729973)
(1.47001 -0.507832 0 0.699233 0 0.741367)
(1.4865 -0.513047 0 0.705234 0 0.750784)
(1.49928 -0.517175 0 0.709971 0 0.758409)
(1.50889 -0.520348 0 0.713503 0 0.76445)
(1.51583 -0.522703 0 0.715949 0 0.769123)
(1.52059 -0.524369 0 0.717448 0 0.772648)
(1.52363 -0.525472 0 0.718141 0 0.775238)
(1.52539 -0.526136 0 0.718163 0 0.777092)
(1.52626 -0.526479 0 0.717648 0 0.778396)
(1.52658 -0.526606 0 0.716727 0 0.779312)
(1.52662 -0.526608 0 0.715522 0 0.779979)
(1.52661 -0.526559 0 0.714138 0 0.78052)
(1.52675 -0.526523 0 0.712661 0 0.781036)
(1.5272 -0.526552 0 0.711162 0 0.781609)
(1.52803 -0.526687 0 0.709696 0 0.782298)
(1.52932 -0.52695 0 0.708302 0 0.783141)
(1.53106 -0.527348 0 0.707001 0 0.784152)
(1.53321 -0.527871 0 0.705795 0 0.785327)
(1.5357 -0.528498 0 0.704669 0 0.786643)
(1.53843 -0.529195 0 0.703594 0 0.788062)
(1.54127 -0.529922 0 0.702531 0 0.789534)
(1.54408 -0.530632 0 0.701433 0 0.790998)
(1.5467 -0.531271 0 0.700245 0 0.792387)
(1.54898 -0.531784 0 0.698911 0 0.793627)
(1.55073 -0.532113 0 0.697369 0 0.794642)
(1.5518 -0.532199 0 0.695557 0 0.795357)
(1.55203 -0.531986 0 0.693415 0 0.795696)
(1.55127 -0.531419 0 0.690883 0 0.795587)
(1.54937 -0.530448 0 0.687905 0 0.794963)
(1.54623 -0.529027 0 0.684433 0 0.793763)
(1.54174 -0.527117 0 0.680421 0 0.791933)
(1.5358 -0.524686 0 0.675834 0 0.789428)
(1.52837 -0.521709 0 0.670643 0 0.78621)
(1.51938 -0.518166 0 0.664826 0 0.782251)
(1.50881 -0.514048 0 0.658373 0 0.777534)
(1.49666 -0.509351 0 0.651277 0 0.772048)
(1.48294 -0.504077 0 0.643545 0 0.765796)
(1.46767 -0.498239 0 0.635187 0 0.758787)
(1.45092 -0.491854 0 0.626224 0 0.751041)
(1.43276 -0.484947 0 0.616685 0 0.742589)
(1.41326 -0.477549 0 0.606606 0 0.733468)
(1.39253 -0.469698 0 0.596031 0 0.723727)
(1.37071 -0.461438 0 0.585009 0 0.713422)
(1.34791 -0.452819 0 0.573599 0 0.702615)
(1.32429 -0.443894 0 0.561862 0 0.691377)
(1.29999 -0.434721 0 0.549863 0 0.679782)
(1.27519 -0.425362 0 0.537673 0 0.667909)
(1.25006 -0.415877 0 0.525361 0 0.655841)
(1.22475 -0.40633 0 0.513 0 0.64366)
(1.19943 -0.396785 0 0.50066 0 0.63145)
(1.17429 -0.387304 0 0.488412 0 0.619295)
(1.14947 -0.377948 0 0.476324 0 0.607274)
(1.12514 -0.368776 0 0.464462 0 0.595468)
(1.10143 -0.359844 0 0.452888 0 0.583948)
(1.07847 -0.351202 0 0.441659 0 0.572785)
(1.0564 -0.342897 0 0.430825 0 0.562039)
(1.03529 -0.334966 0 0.420432 0 0.551763)
(1.01524 -0.327438 0 0.410513 0 0.542001)
(0.996279 -0.320331 0 0.401092 0 0.532783)
(0.978453 -0.31365 0 0.392179 0 0.524129)
(0.961771 -0.307394 0 0.383773 0 0.516048)
(0.946229 -0.301552 0 0.375868 0 0.508541)
(0.931809 -0.296111 0 0.368449 0 0.501602)
(0.918479 -0.291055 0 0.361502 0 0.495215)
(0.906191 -0.286362 0 0.355003 0 0.48936)
(0.894886 -0.282006 0 0.348927 0 0.484009)
(0.884492 -0.277958 0 0.343245 0 0.479129)
(0.874927 -0.274182 0 0.337922 0 0.474679)
(0.866103 -0.270645 0 0.332923 0 0.470617)
(0.857922 -0.267305 0 0.328207 0 0.466896)
(0.850287 -0.264124 0 0.323733 0 0.463465)
(0.843097 -0.261062 0 0.319459 0 0.460272)
(0.836263 -0.25808 0 0.315343 0 0.45727)
(0.829696 -0.255144 0 0.311343 0 0.45441)
(0.823386 -0.252238 0 0.307433 0 0.451673)
(0.817299 -0.249368 0 0.303599 0 0.449043)
(0.811743 -0.246626 0 0.299905 0 0.446636)
(0.806808 -0.244173 0 0.296468 0 0.444536)
(0.803802 -0.242591 0 0.293832 0 0.443307)
(0.802485 -0.241751 0 0.292111 0 0.44298)
(0.158933 -0.0246931 0 0.0688535 0 0.123979)
(0.159046 -0.0261788 0 0.071336 0 0.124375)
(0.161564 -0.0284241 0 0.0744944 0 0.125368)
(0.167583 -0.0319204 0 0.0790156 0 0.127606)
(0.178243 -0.0371037 0 0.0855565 0 0.131724)
(0.194509 -0.044303 0 0.0946605 0 0.138263)
(0.21766 -0.053942 0 0.106988 0 0.147913)
(0.248505 -0.0662535 0 0.122968 0 0.161169)
(0.287087 -0.0811931 0 0.142651 0 0.178175)
(0.332673 -0.0984489 0 0.165707 0 0.198701)
(0.384149 -0.117608 0 0.191597 0 0.22229)
(0.440116 -0.138186 0 0.219634 0 0.24831)
(0.499059 -0.159683 0 0.249077 0 0.276036)
(0.559514 -0.181625 0 0.27921 0 0.304742)
(0.620181 -0.203595 0 0.309383 0 0.333759)
(0.679974 -0.225214 0 0.338988 0 0.36251)
(0.73806 -0.246097 0 0.367314 0 0.39053)
(0.793872 -0.265786 0 0.39322 0 0.417458)
(0.848281 -0.284167 0 0.415298 0 0.443451)
(0.898999 -0.301266 0 0.436019 0 0.467879)
(0.945846 -0.317091 0 0.455339 0 0.490627)
(0.988739 -0.331647 0 0.473192 0 0.511618)
(1.02768 -0.344947 0 0.489528 0 0.530818)
(1.06276 -0.357016 0 0.504325 0 0.54823)
(1.09411 -0.367893 0 0.517603 0 0.563895)
(1.12193 -0.377629 0 0.529407 0 0.577886)
(1.14647 -0.386289 0 0.539803 0 0.590305)
(1.16802 -0.393955 0 0.548875 0 0.601275)
(1.1869 -0.400717 0 0.556724 0 0.610934)
(1.20343 -0.406674 0 0.563465 0 0.619426)
(1.21793 -0.411919 0 0.569219 0 0.626893)
(1.23067 -0.416543 0 0.574104 0 0.633474)
(1.24193 -0.420632 0 0.578231 0 0.6393)
(1.25199 -0.424269 0 0.581706 0 0.644493)
(1.26104 -0.42753 0 0.584626 0 0.649163)
(1.26929 -0.430476 0 0.587074 0 0.653402)
(1.27685 -0.433157 0 0.589121 0 0.657284)
(1.28385 -0.435609 0 0.59082 0 0.660863)
(1.29034 -0.437854 0 0.592208 0 0.664179)
(1.29635 -0.439903 0 0.593309 0 0.667252)
(1.30188 -0.441757 0 0.594133 0 0.670088)
(1.3069 -0.443408 0 0.594679 0 0.672679)
(1.31135 -0.44484 0 0.594936 0 0.675006)
(1.31518 -0.446031 0 0.594886 0 0.677041)
(1.31829 -0.446953 0 0.594505 0 0.678749)
(1.3206 -0.447575 0 0.593763 0 0.680088)
(1.32201 -0.447866 0 0.592628 0 0.681015)
(1.32242 -0.447791 0 0.591067 0 0.681485)
(1.32175 -0.447318 0 0.589045 0 0.681454)
(1.31992 -0.446417 0 0.586532 0 0.680879)
(1.31684 -0.445062 0 0.583499 0 0.679724)
(1.31246 -0.443229 0 0.579922 0 0.677955)
(1.30673 -0.440901 0 0.575784 0 0.675546)
(1.29962 -0.438065 0 0.571071 0 0.672478)
(1.29111 -0.434716 0 0.565779 0 0.668737)
(1.2812 -0.430852 0 0.559907 0 0.66432)
(1.26992 -0.42648 0 0.553464 0 0.659231)
(1.25729 -0.421612 0 0.546465 0 0.653483)
(1.24337 -0.416266 0 0.538932 0 0.647096)
(1.22822 -0.410467 0 0.530895 0 0.640101)
(1.21194 -0.404247 0 0.52239 0 0.632535)
(1.19462 -0.397642 0 0.51346 0 0.624443)
(1.17637 -0.390694 0 0.504154 0 0.615878)
(1.15733 -0.383452 0 0.494525 0 0.606899)
(1.13761 -0.375964 0 0.484631 0 0.597569)
(1.11738 -0.368285 0 0.474532 0 0.587957)
(1.09676 -0.36047 0 0.464293 0 0.578133)
(1.07592 -0.352574 0 0.453975 0 0.56817)
(1.05499 -0.344655 0 0.443643 0 0.558141)
(1.03413 -0.336767 0 0.433357 0 0.548119)
(1.01349 -0.328964 0 0.423179 0 0.538175)
(0.993186 -0.321299 0 0.413167 0 0.528378)
(0.973365 -0.31382 0 0.403376 0 0.518794)
(0.954143 -0.306576 0 0.393857 0 0.509486)
(0.935631 -0.299606 0 0.384657 0 0.500509)
(0.917924 -0.29295 0 0.375818 0 0.491916)
(0.901102 -0.286637 0 0.367375 0 0.48375)
(0.885228 -0.280691 0 0.359356 0 0.476047)
(0.870344 -0.275124 0 0.351778 0 0.468831)
(0.856474 -0.269942 0 0.344649 0 0.462119)
(0.843624 -0.26514 0 0.337968 0 0.455917)
(0.831788 -0.260709 0 0.331727 0 0.450223)
(0.820947 -0.256635 0 0.325912 0 0.445031)
(0.811068 -0.252901 0 0.320507 0 0.440327)
(0.802108 -0.249486 0 0.315491 0 0.436091)
(0.79401 -0.246366 0 0.310842 0 0.432297)
(0.786709 -0.243512 0 0.30653 0 0.428914)
(0.780131 -0.240894 0 0.302525 0 0.425908)
(0.774194 -0.238478 0 0.298794 0 0.423239)
(0.76881 -0.236227 0 0.2953 0 0.420864)
(0.76389 -0.234105 0 0.292007 0 0.418737)
(0.75934 -0.232075 0 0.288875 0 0.416811)
(0.755079 -0.230102 0 0.285867 0 0.415042)
(0.751024 -0.228156 0 0.282946 0 0.413386)
(0.747163 -0.22622 0 0.28009 0 0.411827)
(0.743462 -0.224304 0 0.277287 0 0.410346)
(0.740184 -0.222488 0 0.274598 0 0.409046)
(0.737389 -0.220918 0 0.272127 0 0.407992)
(0.736165 -0.220079 0 0.270345 0 0.407653)
(0.73613 -0.219786 0 0.269284 0 0.407965)
(0.135764 -0.0116607 0 0.0722201 0 0.120359)
(0.134278 -0.0121751 0 0.0728061 0 0.119892)
(0.133302 -0.0127922 0 0.0733736 0 0.119401)
(0.132993 -0.013611 0 0.0740713 0 0.119015)
(0.133562 -0.014741 0 0.0750602 0 0.118879)
(0.135266 -0.0162951 0 0.0765038 0 0.119148)
(0.138453 -0.0184124 0 0.0785971 0 0.120003)
(0.143517 -0.0212403 0 0.0815484 0 0.121645)
(0.150841 -0.0249166 0 0.0855566 0 0.124269)
(0.160966 -0.0296332 0 0.0908829 0 0.128144)
(0.174311 -0.0355215 0 0.0977377 0 0.133495)
(0.191203 -0.0426762 0 0.106287 0 0.14051)
(0.211895 -0.0511675 0 0.116658 0 0.149342)
(0.236528 -0.0610251 0 0.12892 0 0.160091)
(0.265098 -0.0722297 0 0.143069 0 0.172785)
(0.297436 -0.0847012 0 0.159004 0 0.187364)
(0.333183 -0.0982807 0 0.176485 0 0.203667)
(0.371822 -0.112714 0 0.195042 0 0.221439)
(0.413296 -0.127681 0 0.213434 0 0.240466)
(0.456216 -0.142976 0 0.232274 0 0.260326)
(0.499877 -0.158384 0 0.251315 0 0.28069)
(0.543589 -0.173696 0 0.270299 0 0.301224)
(0.586709 -0.188724 0 0.288973 0 0.321611)
(0.628667 -0.203298 0 0.307107 0 0.341564)
(0.668988 -0.217281 0 0.32451 0 0.360838)
(0.707298 -0.230562 0 0.341027 0 0.379241)
(0.743339 -0.243064 0 0.356546 0 0.39663)
(0.776957 -0.254741 0 0.370992 0 0.412917)
(0.808092 -0.265576 0 0.384327 0 0.428055)
(0.836758 -0.275573 0 0.396547 0 0.442038)
(0.863022 -0.284754 0 0.407675 0 0.454886)
(0.886996 -0.293153 0 0.417751 0 0.466644)
(0.908828 -0.300814 0 0.426829 0 0.477376)
(0.928686 -0.307791 0 0.434974 0 0.487155)
(0.946748 -0.314142 0 0.442258 0 0.496062)
(0.96319 -0.319922 0 0.448753 0 0.50418)
(0.978173 -0.325187 0 0.454531 0 0.511585)
(0.991843 -0.329981 0 0.459655 0 0.518348)
(1.00432 -0.334346 0 0.46418 0 0.52453)
(1.01571 -0.338314 0 0.468154 0 0.53018)
(1.02609 -0.34191 0 0.471613 0 0.535337)
(1.03549 -0.345148 0 0.474585 0 0.540028)
(1.04396 -0.348039 0 0.477088 0 0.544268)
(1.05149 -0.350583 0 0.479133 0 0.548064)
(1.05807 -0.352776 0 0.480722 0 0.551413)
(1.06368 -0.354609 0 0.481851 0 0.554304)
(1.06827 -0.356067 0 0.482512 0 0.55672)
(1.07181 -0.357135 0 0.482692 0 0.558641)
(1.07423 -0.357794 0 0.482377 0 0.560046)
(1.07551 -0.358028 0 0.481552 0 0.560909)
(1.07559 -0.35782 0 0.480202 0 0.56121)
(1.07443 -0.357156 0 0.478317 0 0.560928)
(1.07201 -0.356025 0 0.475887 0 0.560048)
(1.06831 -0.354422 0 0.472909 0 0.558559)
(1.06333 -0.352345 0 0.469383 0 0.556456)
(1.05708 -0.349796 0 0.465316 0 0.55374)
(1.04958 -0.346785 0 0.46072 0 0.550419)
(1.04087 -0.343325 0 0.455612 0 0.546507)
(1.03099 -0.339438 0 0.450017 0 0.542028)
(1.02003 -0.335146 0 0.443965 0 0.537009)
(1.00807 -0.330482 0 0.437492 0 0.531487)
(0.995179 -0.325481 0 0.430637 0 0.525505)
(0.981481 -0.320181 0 0.423446 0 0.51911)
(0.967084 -0.314626 0 0.41597 0 0.512355)
(0.952107 -0.308861 0 0.408259 0 0.505296)
(0.936677 -0.302935 0 0.400368 0 0.497995)
(0.920921 -0.296897 0 0.392353 0 0.490512)
(0.904969 -0.290794 0 0.384269 0 0.482911)
(0.888949 -0.284676 0 0.37617 0 0.475253)
(0.872986 -0.278591 0 0.368109 0 0.467602)
(0.857203 -0.272584 0 0.360139 0 0.460017)
(0.841716 -0.2667 0 0.352307 0 0.452557)
(0.826634 -0.260979 0 0.344661 0 0.445278)
(0.81206 -0.255462 0 0.337243 0 0.438231)
(0.798084 -0.250182 0 0.330092 0 0.431464)
(0.784789 -0.245172 0 0.323243 0 0.425021)
(0.772243 -0.240455 0 0.316724 0 0.418937)
(0.760497 -0.236053 0 0.31056 0 0.413243)
(0.749589 -0.231975 0 0.304765 0 0.407962)
(0.739541 -0.228226 0 0.299346 0 0.403106)
(0.730358 -0.224803 0 0.294302 0 0.398683)
(0.722036 -0.221697 0 0.289626 0 0.394691)
(0.714559 -0.218896 0 0.285308 0 0.391125)
(0.7079 -0.216386 0 0.281334 0 0.387974)
(0.702021 -0.214147 0 0.277686 0 0.385221)
(0.696875 -0.212157 0 0.274344 0 0.382844)
(0.692405 -0.210393 0 0.271282 0 0.380818)
(0.688548 -0.208825 0 0.268475 0 0.379112)
(0.685231 -0.207423 0 0.265894 0 0.377691)
(0.682377 -0.206157 0 0.263506 0 0.376518)
(0.679908 -0.204991 0 0.261279 0 0.375554)
(0.677739 -0.203894 0 0.259178 0 0.374756)
(0.675797 -0.202833 0 0.257171 0 0.374086)
(0.674009 -0.201782 0 0.255226 0 0.373503)
(0.672359 -0.200726 0 0.253323 0 0.372992)
(0.670814 -0.199676 0 0.251454 0 0.372538)
(0.669597 -0.1987 0 0.249675 0 0.372226)
(0.668738 -0.197926 0 0.248076 0 0.372105)
(0.669117 -0.197753 0 0.247057 0 0.372553)
(0.670217 -0.197941 0 0.246574 0 0.373418)
(0.129732 -0.00641288 0 0.0783888 0 0.121473)
(0.129091 -0.00665822 0 0.0778151 0 0.120845)
(0.127668 -0.00691661 0 0.078022 0 0.120305)
(0.126489 -0.00721501 0 0.0782063 0 0.119728)
(0.125579 -0.00758543 0 0.0784103 0 0.119157)
(0.124986 -0.00805941 0 0.0786767 0 0.118636)
(0.12479 -0.00867738 0 0.0790596 0 0.118218)
(0.125095 -0.0094866 0 0.0796222 0 0.117965)
(0.12602 -0.010537 0 0.0804318 0 0.117939)
(0.127712 -0.0118897 0 0.0815671 0 0.118217)
(0.130355 -0.0136172 0 0.0831189 0 0.118888)
(0.13414 -0.0157923 0 0.0851871 0 0.120048)
(0.139265 -0.0184868 0 0.0878716 0 0.121798)
(0.145935 -0.0217733 0 0.0912763 0 0.124242)
(0.154362 -0.0257242 0 0.0955062 0 0.127489)
(0.164755 -0.0304073 0 0.100662 0 0.131648)
(0.177301 -0.0358767 0 0.106822 0 0.136817)
(0.192158 -0.0421591 0 0.114003 0 0.143074)
(0.209652 -0.0492288 0 0.121854 0 0.150469)
(0.229524 -0.0570786 0 0.130679 0 0.159022)
(0.251718 -0.0656683 0 0.140456 0 0.168724)
(0.276089 -0.0749322 0 0.151129 0 0.179522)
(0.302406 -0.0847788 0 0.162601 0 0.191321)
(0.330358 -0.0950943 0 0.174742 0 0.203982)
(0.359564 -0.105747 0 0.18739 0 0.217332)
(0.389603 -0.116597 0 0.200368 0 0.231173)
(0.420046 -0.127502 0 0.213489 0 0.245298)
(0.450477 -0.13833 0 0.226574 0 0.259504)
(0.480517 -0.148963 0 0.239454 0 0.273604)
(0.509842 -0.159298 0 0.251988 0 0.287432)
(0.538181 -0.169255 0 0.264058 0 0.300851)
(0.565332 -0.178772 0 0.275573 0 0.313753)
(0.591153 -0.187807 0 0.286468 0 0.326062)
(0.615559 -0.196336 0 0.296703 0 0.337728)
(0.638517 -0.204351 0 0.306261 0 0.348728)
(0.660028 -0.211855 0 0.315137 0 0.359056)
(0.680121 -0.218858 0 0.323344 0 0.36872)
(0.698842 -0.225377 0 0.3309 0 0.37774)
(0.716247 -0.23143 0 0.337826 0 0.386138)
(0.732395 -0.237035 0 0.344149 0 0.393942)
(0.747342 -0.24221 0 0.349892 0 0.401177)
(0.761134 -0.24697 0 0.355077 0 0.407865)
(0.77381 -0.251326 0 0.359723 0 0.414026)
(0.785397 -0.255286 0 0.363845 0 0.419673)
(0.795908 -0.258854 0 0.367453 0 0.424813)
(0.805349 -0.26203 0 0.370555 0 0.429451)
(0.813712 -0.264811 0 0.373151 0 0.433583)
(0.820985 -0.267191 0 0.375242 0 0.437204)
(0.827148 -0.269163 0 0.376823 0 0.440306)
(0.832182 -0.270717 0 0.377892 0 0.442879)
(0.836066 -0.271847 0 0.378443 0 0.444911)
(0.838782 -0.272546 0 0.378474 0 0.446395)
(0.84032 -0.272808 0 0.377982 0 0.447321)
(0.840675 -0.272633 0 0.37697 0 0.447686)
(0.839852 -0.272023 0 0.375442 0 0.44749)
(0.837865 -0.270983 0 0.373409 0 0.446738)
(0.834742 -0.269523 0 0.370884 0 0.445438)
(0.830521 -0.267658 0 0.367884 0 0.443608)
(0.82525 -0.265407 0 0.364435 0 0.441266)
(0.81899 -0.262792 0 0.360563 0 0.43844)
(0.811814 -0.259843 0 0.3563 0 0.435161)
(0.803803 -0.256588 0 0.351684 0 0.431468)
(0.795047 -0.253065 0 0.346753 0 0.4274)
(0.785643 -0.249309 0 0.341552 0 0.423003)
(0.775694 -0.245361 0 0.336124 0 0.418326)
(0.765308 -0.241261 0 0.330518 0 0.413419)
(0.754592 -0.237051 0 0.324779 0 0.408335)
(0.743657 -0.232773 0 0.318956 0 0.403127)
(0.732611 -0.228468 0 0.313094 0 0.397847)
(0.721559 -0.224176 0 0.307239 0 0.392547)
(0.710604 -0.219937 0 0.301435 0 0.387279)
(0.699845 -0.215787 0 0.295722 0 0.38209)
(0.689375 -0.211762 0 0.290139 0 0.377029)
(0.679279 -0.207895 0 0.284724 0 0.372139)
(0.669636 -0.204214 0 0.279508 0 0.367459)
(0.660516 -0.200747 0 0.274522 0 0.363028)
(0.651978 -0.197516 0 0.269792 0 0.358877)
(0.644071 -0.194537 0 0.265336 0 0.355033)
(0.636829 -0.191821 0 0.261171 0 0.351516)
(0.630274 -0.189373 0 0.257302 0 0.34834)
(0.624416 -0.187191 0 0.253732 0 0.345512)
(0.619257 -0.18527 0 0.250458 0 0.343035)
(0.614784 -0.1836 0 0.24747 0 0.340905)
(0.610981 -0.182169 0 0.24476 0 0.339116)
(0.607818 -0.180963 0 0.242313 0 0.337654)
(0.605259 -0.179962 0 0.240113 0 0.336503)
(0.603257 -0.179145 0 0.238141 0 0.335644)
(0.601762 -0.17849 0 0.236374 0 0.33505)
(0.600712 -0.177969 0 0.234788 0 0.334695)
(0.600043 -0.177554 0 0.233357 0 0.334546)
(0.599687 -0.177218 0 0.232053 0 0.334569)
(0.59957 -0.17693 0 0.230845 0 0.334729)
(0.599631 -0.176662 0 0.229706 0 0.334991)
(0.599801 -0.176391 0 0.228608 0 0.335321)
(0.600067 -0.176105 0 0.227535 0 0.335705)
(0.600395 -0.175813 0 0.226482 0 0.336127)
(0.600968 -0.175574 0 0.225498 0 0.336661)
(0.601792 -0.175494 0 0.224657 0 0.337336)
(0.603553 -0.175896 0 0.224295 0 0.33845)
(0.605616 -0.176493 0 0.2243 0 0.33977)
(0.127318 -0.00352657 0 0.0838848 0 0.122574)
(0.126819 -0.00366231 0 0.0831242 0 0.122009)
(0.126129 -0.00379979 0 0.0825785 0 0.121426)
(0.124783 -0.00394871 0 0.0826553 0 0.120908)
(0.1236 -0.00411915 0 0.0826765 0 0.120349)
(0.12257 -0.00431921 0 0.0826708 0 0.119767)
(0.121703 -0.00456111 0 0.0826657 0 0.119186)
(0.121021 -0.00486165 0 0.0826897 0 0.11863)
(0.120561 -0.00524018 0 0.0827721 0 0.118125)
(0.120367 -0.00571955 0 0.082944 0 0.117699)
(0.120498 -0.00632723 0 0.0832394 0 0.117386)
(0.121027 -0.00709669 0 0.0836978 0 0.117223)
(0.12203 -0.0080606 0 0.0843609 0 0.117249)
(0.123593 -0.00925371 0 0.0852727 0 0.117509)
(0.125808 -0.0107125 0 0.0864804 0 0.118047)
(0.128773 -0.0124748 0 0.088033 0 0.118915)
(0.132595 -0.0145785 0 0.0899794 0 0.120164)
(0.137382 -0.0170582 0 0.0923574 0 0.121845)
(0.143267 -0.0199378 0 0.0951523 0 0.124008)
(0.150509 -0.023243 0 0.0982382 0 0.126697)
(0.158984 -0.0269972 0 0.101857 0 0.129969)
(0.168778 -0.0312182 0 0.106037 0 0.133869)
(0.179956 -0.035916 0 0.1108 0 0.138435)
(0.192553 -0.0410906 0 0.116159 0 0.143688)
(0.206567 -0.0467292 0 0.12211 0 0.149637)
(0.221955 -0.0528052 0 0.128634 0 0.156269)
(0.238626 -0.0592775 0 0.135691 0 0.163549)
(0.25645 -0.0660927 0 0.143224 0 0.171421)
(0.275256 -0.0731866 0 0.151158 0 0.179811)
(0.294843 -0.0804869 0 0.159406 0 0.188625)
(0.314992 -0.0879171 0 0.16787 0 0.19776)
(0.335473 -0.0954003 0 0.176453 0 0.207109)
(0.356067 -0.102863 0 0.185056 0 0.216565)
(0.376565 -0.110239 0 0.193588 0 0.226026)
(0.396787 -0.117471 0 0.20197 0 0.235401)
(0.416576 -0.124511 0 0.210131 0 0.244613)
(0.435806 -0.131318 0 0.218015 0 0.253595)
(0.454375 -0.137865 0 0.225578 0 0.262296)
(0.472211 -0.144127 0 0.232786 0 0.270676)
(0.489258 -0.150089 0 0.239613 0 0.278706)
(0.505479 -0.15574 0 0.246043 0 0.286365)
(0.520849 -0.161072 0 0.252063 0 0.293637)
(0.535349 -0.16608 0 0.257666 0 0.300513)
(0.548965 -0.170759 0 0.262845 0 0.306983)
(0.561685 -0.175105 0 0.267597 0 0.313041)
(0.573495 -0.179112 0 0.271916 0 0.318679)
(0.58438 -0.182777 0 0.275799 0 0.323891)
(0.594324 -0.186091 0 0.279241 0 0.328666)
(0.603309 -0.189049 0 0.282237 0 0.332997)
(0.611317 -0.191644 0 0.284781 0 0.336873)
(0.618331 -0.19387 0 0.28687 0 0.340286)
(0.624335 -0.195722 0 0.288499 0 0.343228)
(0.62932 -0.197195 0 0.289667 0 0.345691)
(0.63328 -0.198289 0 0.290376 0 0.347671)
(0.636218 -0.199004 0 0.290628 0 0.349168)
(0.638143 -0.199346 0 0.290431 0 0.350184)
(0.639075 -0.199322 0 0.289795 0 0.350727)
(0.639042 -0.198944 0 0.288735 0 0.350806)
(0.638081 -0.198225 0 0.287269 0 0.350439)
(0.636239 -0.197186 0 0.285419 0 0.349645)
(0.633574 -0.195849 0 0.283212 0 0.348448)
(0.630148 -0.194237 0 0.280677 0 0.346879)
(0.626033 -0.192379 0 0.277845 0 0.344969)
(0.621308 -0.190307 0 0.274752 0 0.342754)
(0.616055 -0.188051 0 0.271435 0 0.340274)
(0.61036 -0.185646 0 0.267931 0 0.337569)
(0.604313 -0.183125 0 0.26428 0 0.334681)
(0.598001 -0.180524 0 0.26052 0 0.331653)
(0.591515 -0.177875 0 0.25669 0 0.328528)
(0.584942 -0.175214 0 0.252827 0 0.32535)
(0.578366 -0.172572 0 0.248967 0 0.322159)
(0.571871 -0.16998 0 0.245146 0 0.318996)
(0.565534 -0.167468 0 0.241396 0 0.315902)
(0.559429 -0.165065 0 0.237748 0 0.312911)
(0.553623 -0.162794 0 0.234231 0 0.310061)
(0.548177 -0.16068 0 0.230871 0 0.307381)
(0.543147 -0.158742 0 0.227691 0 0.304901)
(0.538575 -0.156995 0 0.224709 0 0.302646)
(0.534496 -0.15545 0 0.22194 0 0.300634)
(0.530937 -0.154114 0 0.219393 0 0.29888)
(0.527911 -0.152986 0 0.217072 0 0.297394)
(0.525425 -0.152065 0 0.214976 0 0.296181)
(0.523478 -0.151344 0 0.213103 0 0.295241)
(0.522059 -0.150814 0 0.211446 0 0.294572)
(0.52115 -0.150465 0 0.209995 0 0.294166)
(0.520726 -0.150282 0 0.208739 0 0.294012)
(0.520753 -0.150248 0 0.207663 0 0.294094)
(0.52119 -0.150343 0 0.206751 0 0.294395)
(0.52199 -0.150546 0 0.205982 0 0.294893)
(0.5231 -0.150834 0 0.205335 0 0.29556)
(0.524464 -0.15118 0 0.204787 0 0.296371)
(0.52602 -0.15156 0 0.204313 0 0.297295)
(0.527714 -0.15195 0 0.203889 0 0.298302)
(0.529489 -0.152329 0 0.203492 0 0.299364)
(0.531329 -0.152687 0 0.203109 0 0.300468)
(0.533202 -0.153032 0 0.202736 0 0.301599)
(0.535256 -0.153412 0 0.202416 0 0.302817)
(0.537471 -0.153914 0 0.202207 0 0.304136)
(0.540363 -0.15479 0 0.202384 0 0.305779)
(0.543193 -0.155717 0 0.202781 0 0.307448)
(0.125974 -0.00186268 0 0.0884526 0 0.123243)
(0.125537 -0.00193765 0 0.0876523 0 0.122749)
(0.124997 -0.00201199 0 0.0869739 0 0.122229)
(0.123858 -0.0020904 0 0.0868444 0 0.121758)
(0.122771 -0.00217661 0 0.0867143 0 0.121252)
(0.121746 -0.00227339 0 0.0865767 0 0.120717)
(0.120793 -0.00238489 0 0.0864323 0 0.120161)
(0.119921 -0.00251763 0 0.0862872 0 0.119594)
(0.119142 -0.00267956 0 0.0861506 0 0.119028)
(0.118472 -0.0028802 0 0.086034 0 0.118475)
(0.117932 -0.00313113 0 0.0859515 0 0.117949)
(0.11755 -0.00344697 0 0.0859201 0 0.117467)
(0.117359 -0.00384323 0 0.0859591 0 0.117046)
(0.117394 -0.00433656 0 0.0860901 0 0.116706)
(0.117696 -0.00494476 0 0.0863361 0 0.11647)
(0.118311 -0.00568654 0 0.0867216 0 0.116362)
(0.119287 -0.00658108 0 0.0872714 0 0.116404)
(0.120675 -0.00764716 0 0.0880076 0 0.116625)
(0.122541 -0.00890125 0 0.0889358 0 0.117046)
(0.125079 -0.0103568 0 0.0899331 0 0.117683)
(0.128185 -0.0120305 0 0.0911625 0 0.118574)
(0.131906 -0.0139367 0 0.0926472 0 0.119747)
(0.136289 -0.0160892 0 0.0944083 0 0.121227)
(0.141383 -0.0185002 0 0.0964644 0 0.123038)
(0.14723 -0.0211798 0 0.0988322 0 0.125205)
(0.153867 -0.0241348 0 0.101525 0 0.127747)
(0.161319 -0.0273684 0 0.104552 0 0.13068)
(0.169601 -0.0308788 0 0.107918 0 0.134015)
(0.17871 -0.0346588 0 0.111618 0 0.137753)
(0.188625 -0.0386952 0 0.115645 0 0.14189)
(0.199307 -0.0429682 0 0.119979 0 0.14641)
(0.210696 -0.0474522 0 0.124596 0 0.15129)
(0.222716 -0.0521164 0 0.129462 0 0.156497)
(0.235278 -0.0569262 0 0.134536 0 0.16199)
(0.248278 -0.0618443 0 0.139777 0 0.167723)
(0.26161 -0.0668325 0 0.145136 0 0.173647)
(0.275163 -0.0718525 0 0.150565 0 0.179708)
(0.288827 -0.0768674 0 0.156018 0 0.185856)
(0.3025 -0.0818424 0 0.161448 0 0.19204)
(0.316084 -0.0867457 0 0.166813 0 0.198213)
(0.329491 -0.0915485 0 0.172074 0 0.204331)
(0.342642 -0.0962252 0 0.177196 0 0.210356)
(0.355467 -0.100753 0 0.182148 0 0.21625)
(0.367903 -0.105112 0 0.186902 0 0.221984)
(0.379894 -0.109285 0 0.191433 0 0.227529)
(0.391389 -0.113254 0 0.19572 0 0.232858)
(0.402341 -0.117005 0 0.199742 0 0.237949)
(0.412708 -0.120524 0 0.203481 0 0.242779)
(0.422451 -0.123797 0 0.206922 0 0.247328)
(0.431532 -0.126814 0 0.21005 0 0.251578)
(0.439919 -0.129563 0 0.212852 0 0.255512)
(0.447582 -0.132034 0 0.215316 0 0.259113)
(0.454496 -0.134221 0 0.217433 0 0.262369)
(0.460643 -0.136117 0 0.219198 0 0.265269)
(0.466008 -0.137719 0 0.220607 0 0.267805)
(0.470588 -0.139027 0 0.22166 0 0.269972)
(0.474383 -0.140044 0 0.222359 0 0.271769)
(0.477403 -0.140773 0 0.222711 0 0.2732)
(0.479667 -0.141225 0 0.222725 0 0.274271)
(0.481201 -0.14141 0 0.222415 0 0.274992)
(0.48204 -0.141343 0 0.221797 0 0.275379)
(0.482226 -0.141042 0 0.220892 0 0.275451)
(0.481807 -0.140526 0 0.219722 0 0.275228)
(0.480838 -0.139819 0 0.218311 0 0.274736)
(0.47938 -0.138943 0 0.216688 0 0.274002)
(0.477495 -0.137924 0 0.21488 0 0.273057)
(0.475251 -0.13679 0 0.212918 0 0.271932)
(0.472716 -0.135566 0 0.210831 0 0.27066)
(0.469959 -0.13428 0 0.208649 0 0.269273)
(0.467048 -0.132958 0 0.206403 0 0.267805)
(0.464053 -0.131626 0 0.204122 0 0.26629)
(0.46104 -0.130312 0 0.201834 0 0.264759)
(0.458073 -0.129037 0 0.199567 0 0.263246)
(0.455214 -0.127828 0 0.197346 0 0.261781)
(0.45252 -0.126704 0 0.195198 0 0.260393)
(0.450045 -0.125686 0 0.193143 0 0.25911)
(0.447838 -0.124791 0 0.191204 0 0.257956)
(0.44594 -0.124035 0 0.189397 0 0.256956)
(0.444386 -0.123427 0 0.187737 0 0.256126)
(0.443204 -0.122975 0 0.186235 0 0.255484)
(0.442411 -0.122681 0 0.184896 0 0.255039)
(0.442022 -0.122547 0 0.183724 0 0.254799)
(0.442042 -0.122569 0 0.182719 0 0.254769)
(0.442468 -0.122742 0 0.181878 0 0.25495)
(0.443294 -0.123058 0 0.181197 0 0.255339)
(0.444502 -0.123507 0 0.180667 0 0.255929)
(0.446072 -0.124076 0 0.180279 0 0.25671)
(0.447972 -0.124748 0 0.180021 0 0.257671)
(0.450169 -0.125508 0 0.179876 0 0.258794)
(0.452621 -0.126335 0 0.179829 0 0.26006)
(0.455281 -0.127209 0 0.17986 0 0.261446)
(0.458101 -0.128107 0 0.17995 0 0.262929)
(0.461034 -0.129009 0 0.180078 0 0.264484)
(0.464031 -0.129899 0 0.180226 0 0.266086)
(0.467078 -0.130766 0 0.180382 0 0.267724)
(0.470142 -0.131617 0 0.180543 0 0.269385)
(0.473342 -0.132491 0 0.180747 0 0.271115)
(0.476632 -0.133457 0 0.181035 0 0.272916)
(0.480384 -0.134701 0 0.181627 0 0.274944)
(0.483774 -0.135878 0 0.182316 0 0.276851)
(0.125009 -0.000861436 0 0.0922265 0 0.123532)
(0.124616 -0.00089866 0 0.0914298 0 0.123096)
(0.124171 -0.000935136 0 0.0907008 0 0.122635)
(0.123561 -0.00097336 0 0.0901364 0 0.122163)
(0.12245 -0.00101558 0 0.0900335 0 0.121729)
(0.121423 -0.00106306 0 0.0898823 0 0.121258)
(0.120463 -0.0011171 0 0.0896985 0 0.120759)
(0.119562 -0.00118017 0 0.0894935 0 0.120238)
(0.118717 -0.00125562 0 0.0892765 0 0.119701)
(0.11793 -0.00134756 0 0.0890556 0 0.119155)
(0.117205 -0.00146113 0 0.0888387 0 0.118608)
(0.116553 -0.0016031 0 0.0886343 0 0.118068)
(0.115985 -0.0017809 0 0.0884522 0 0.117542)
(0.115515 -0.00200277 0 0.0883031 0 0.117041)
(0.115164 -0.00227774 0 0.0881993 0 0.116577)
(0.114951 -0.00261549 0 0.0881537 0 0.11616)
(0.114901 -0.0030262 0 0.0881799 0 0.115805)
(0.115041 -0.00352026 0 0.0882916 0 0.115525)
(0.115402 -0.00410753 0 0.088497 0 0.115333)
(0.116045 -0.00479637 0 0.0887758 0 0.115241)
(0.117118 -0.00559552 0 0.0890288 0 0.115255)
(0.118477 -0.0065133 0 0.0894214 0 0.115404)
(0.120156 -0.00755772 0 0.08996 0 0.115701)
(0.122183 -0.00873634 0 0.090652 0 0.11616)
(0.124587 -0.0100562 0 0.0915047 0 0.116794)
(0.127394 -0.0115236 0 0.0925253 0 0.117616)
(0.130628 -0.013144 0 0.0937202 0 0.118638)
(0.134309 -0.014922 0 0.0950955 0 0.119871)
(0.138456 -0.0168607 0 0.0966558 0 0.121325)
(0.143081 -0.0189615 0 0.0984046 0 0.123006)
(0.148192 -0.0212238 0 0.100343 0 0.12492)
(0.15379 -0.0236447 0 0.102471 0 0.127071)
(0.159869 -0.0262187 0 0.104785 0 0.129457)
(0.166417 -0.028938 0 0.107277 0 0.132074)
(0.173412 -0.0317922 0 0.10994 0 0.134916)
(0.180827 -0.0347687 0 0.112761 0 0.13797)
(0.188626 -0.0378524 0 0.115724 0 0.141222)
(0.196768 -0.0410266 0 0.118812 0 0.144654)
(0.205205 -0.0442729 0 0.122004 0 0.148246)
(0.213886 -0.0475722 0 0.125279 0 0.151973)
(0.222758 -0.0509044 0 0.128612 0 0.155812)
(0.231764 -0.0542496 0 0.13198 0 0.159735)
(0.240849 -0.0575877 0 0.135358 0 0.163718)
(0.249956 -0.0608991 0 0.138721 0 0.167732)
(0.259029 -0.0641646 0 0.142045 0 0.171751)
(0.268014 -0.0673655 0 0.145306 0 0.175748)
(0.276857 -0.0704839 0 0.148481 0 0.179697)
(0.285506 -0.0735024 0 0.151547 0 0.183574)
(0.293912 -0.0764045 0 0.154483 0 0.187352)
(0.302027 -0.0791745 0 0.157268 0 0.191009)
(0.309805 -0.0817976 0 0.159883 0 0.194522)
(0.317204 -0.0842604 0 0.162311 0 0.197869)
(0.324187 -0.0865509 0 0.164536 0 0.201031)
(0.330719 -0.0886587 0 0.166544 0 0.203991)
(0.336771 -0.0905754 0 0.168324 0 0.206733)
(0.342319 -0.0922947 0 0.169868 0 0.209245)
(0.347348 -0.0938129 0 0.171169 0 0.211517)
(0.351847 -0.0951286 0 0.172225 0 0.213543)
(0.355813 -0.0962431 0 0.173036 0 0.215319)
(0.359249 -0.0971603 0 0.173606 0 0.216847)
(0.362167 -0.0978871 0 0.173941 0 0.21813)
(0.364586 -0.0984324 0 0.174049 0 0.219175)
(0.366529 -0.0988081 0 0.173945 0 0.219993)
(0.368027 -0.0990277 0 0.173641 0 0.220597)
(0.369117 -0.0991069 0 0.173156 0 0.221004)
(0.369837 -0.0990629 0 0.172507 0 0.221232)
(0.370233 -0.0989142 0 0.171715 0 0.221302)
(0.370351 -0.0986799 0 0.170801 0 0.221235)
(0.370241 -0.0983798 0 0.169786 0 0.221055)
(0.369951 -0.0980342 0 0.168693 0 0.220786)
(0.369533 -0.0976632 0 0.167544 0 0.220452)
(0.369039 -0.0972868 0 0.166361 0 0.220079)
(0.368518 -0.0969246 0 0.165167 0 0.219692)
(0.36802 -0.0965955 0 0.163982 0 0.219315)
(0.367592 -0.0963177 0 0.162826 0 0.218971)
(0.36728 -0.0961081 0 0.16172 0 0.218684)
(0.367126 -0.0959818 0 0.160681 0 0.218476)
(0.367168 -0.095952 0 0.159726 0 0.218367)
(0.367438 -0.0960292 0 0.158867 0 0.218373)
(0.367964 -0.0962212 0 0.158117 0 0.218511)
(0.368769 -0.0965326 0 0.157483 0 0.218792)
(0.36987 -0.0969656 0 0.156971 0 0.219226)
(0.371276 -0.0975198 0 0.156583 0 0.219819)
(0.372994 -0.0981929 0 0.156319 0 0.220576)
(0.375022 -0.0989801 0 0.156179 0 0.221497)
(0.377355 -0.0998744 0 0.156158 0 0.22258)
(0.379977 -0.100866 0 0.156249 0 0.22382)
(0.382872 -0.101944 0 0.156445 0 0.225208)
(0.386012 -0.103094 0 0.156734 0 0.226733)
(0.389366 -0.1043 0 0.157103 0 0.228381)
(0.392901 -0.105545 0 0.157538 0 0.230134)
(0.396575 -0.106812 0 0.158023 0 0.231974)
(0.40035 -0.108082 0 0.158541 0 0.23388)
(0.404186 -0.109342 0 0.159076 0 0.235832)
(0.408069 -0.110582 0 0.159619 0 0.237821)
(0.411967 -0.111807 0 0.160168 0 0.239833)
(0.41597 -0.113049 0 0.160754 0 0.241904)
(0.420015 -0.114356 0 0.161404 0 0.244024)
(0.424349 -0.115864 0 0.162288 0 0.246294)
(0.428092 -0.11721 0 0.163172 0 0.248328)
(0.124199 -0.000249266 0 0.0953844 0 0.123541)
(0.123838 -0.000261978 0 0.0946044 0 0.12315)
(0.123443 -0.000273999 0 0.0938681 0 0.122737)
(0.122965 -0.000286633 0 0.0932221 0 0.122307)
(0.122027 -0.000301617 0 0.0929947 0 0.121907)
(0.121113 -0.000319514 0 0.0927642 0 0.121481)
(0.120225 -0.000340902 0 0.0925262 0 0.12103)
(0.119368 -0.000366966 0 0.0922791 0 0.120558)
(0.118542 -0.000399373 0 0.0920234 0 0.120067)
(0.117749 -0.000440124 0 0.0917606 0 0.119562)
(0.116989 -0.000491674 0 0.0914934 0 0.119045)
(0.116266 -0.000557292 0 0.091225 0 0.118521)
(0.115585 -0.000640504 0 0.0909599 0 0.117994)
(0.11495 -0.000745269 0 0.0907035 0 0.117469)
(0.114369 -0.000875975 0 0.090462 0 0.116952)
(0.113853 -0.00103742 0 0.0902426 0 0.116449)
(0.113411 -0.00123479 0 0.090053 0 0.115968)
(0.113057 -0.00147357 0 0.0899013 0 0.115515)
(0.11281 -0.00175936 0 0.0897939 0 0.115099)
(0.1127 -0.00209745 0 0.0897235 0 0.114728)
(0.112886 -0.00249261 0 0.0895684 0 0.114397)
(0.113218 -0.00295006 0 0.0894865 0 0.114132)
(0.113716 -0.00347494 0 0.0894832 0 0.113943)
(0.114398 -0.00407216 0 0.0895636 0 0.113836)
(0.115281 -0.00474638 0 0.0897329 0 0.113822)
(0.116384 -0.00550193 0 0.0899955 0 0.113907)
(0.11772 -0.00634278 0 0.0903552 0 0.1141)
(0.119306 -0.0072725 0 0.0908156 0 0.114407)
(0.121153 -0.00829413 0 0.0913795 0 0.114836)
(0.123272 -0.00941008 0 0.0920494 0 0.115391)
(0.125674 -0.0106221 0 0.0928271 0 0.116078)
(0.128364 -0.011931 0 0.0937139 0 0.116902)
(0.131349 -0.0133371 0 0.0947105 0 0.117865)
(0.134632 -0.0148395 0 0.0958166 0 0.11897)
(0.138212 -0.0164368 0 0.0970316 0 0.120219)
(0.142087 -0.0181262 0 0.0983535 0 0.121612)
(0.146252 -0.0199039 0 0.0997795 0 0.123146)
(0.150698 -0.021765 0 0.101306 0 0.124821)
(0.155413 -0.0237035 0 0.102926 0 0.12663)
(0.160382 -0.0257124 0 0.104635 0 0.128569)
(0.165587 -0.0277835 0 0.106424 0 0.13063)
(0.171008 -0.0299079 0 0.108284 0 0.132804)
(0.17662 -0.0320758 0 0.110205 0 0.13508)
(0.182396 -0.0342767 0 0.112174 0 0.137448)
(0.188309 -0.0364994 0 0.11418 0 0.139893)
(0.194326 -0.0387321 0 0.116209 0 0.142402)
(0.200416 -0.0409628 0 0.118246 0 0.144959)
(0.206543 -0.0431789 0 0.120276 0 0.147548)
(0.212672 -0.0453678 0 0.122284 0 0.150151)
(0.218765 -0.0475165 0 0.124253 0 0.152752)
(0.224787 -0.0496125 0 0.126168 0 0.155332)
(0.230699 -0.0516434 0 0.128013 0 0.157872)
(0.236467 -0.0535974 0 0.129773 0 0.160356)
(0.242054 -0.0554634 0 0.131433 0 0.162766)
(0.24743 -0.0572314 0 0.13298 0 0.165086)
(0.252563 -0.0588928 0 0.134401 0 0.167301)
(0.257429 -0.0604403 0 0.135688 0 0.169397)
(0.262007 -0.0618684 0 0.136831 0 0.171364)
(0.266278 -0.0631736 0 0.137825 0 0.173191)
(0.270232 -0.0643541 0 0.138665 0 0.174874)
(0.273862 -0.0654105 0 0.139352 0 0.176406)
(0.277168 -0.0663453 0 0.139885 0 0.177788)
(0.280155 -0.0671631 0 0.140269 0 0.179021)
(0.282832 -0.0678704 0 0.140509 0 0.180108)
(0.285214 -0.0684755 0 0.140613 0 0.181057)
(0.287322 -0.0689882 0 0.140592 0 0.181874)
(0.289179 -0.0694196 0 0.140456 0 0.182573)
(0.290812 -0.0697822 0 0.140218 0 0.183164)
(0.292251 -0.0700892 0 0.139892 0 0.183663)
(0.293528 -0.0703544 0 0.139494 0 0.184084)
(0.294678 -0.0705921 0 0.139039 0 0.184445)
(0.295737 -0.0708171 0 0.138542 0 0.184762)
(0.296741 -0.0710441 0 0.13802 0 0.185053)
(0.297727 -0.0712877 0 0.137489 0 0.185337)
(0.298732 -0.0715623 0 0.136966 0 0.185633)
(0.299792 -0.0718814 0 0.136465 0 0.185958)
(0.300942 -0.0722578 0 0.136003 0 0.186329)
(0.302213 -0.0727028 0 0.135592 0 0.186765)
(0.303636 -0.0732261 0 0.135246 0 0.18728)
(0.305236 -0.0738351 0 0.134976 0 0.187889)
(0.307037 -0.0745353 0 0.134788 0 0.188603)
(0.309056 -0.07533 0 0.134691 0 0.189432)
(0.311307 -0.0762207 0 0.134688 0 0.190385)
(0.3138 -0.0772068 0 0.134782 0 0.191466)
(0.31654 -0.078286 0 0.134974 0 0.192681)
(0.319526 -0.0794539 0 0.135262 0 0.194028)
(0.322752 -0.0807039 0 0.135642 0 0.195507)
(0.326206 -0.0820274 0 0.13611 0 0.197112)
(0.329872 -0.0834138 0 0.136658 0 0.198837)
(0.333727 -0.0848506 0 0.137276 0 0.200671)
(0.337744 -0.0863239 0 0.137953 0 0.202601)
(0.341892 -0.087819 0 0.138676 0 0.204613)
(0.346142 -0.0893212 0 0.139433 0 0.20669)
(0.350457 -0.0908181 0 0.140209 0 0.208817)
(0.354825 -0.092302 0 0.140998 0 0.210985)
(0.359217 -0.0937761 0 0.141796 0 0.21318)
(0.363696 -0.0952632 0 0.14263 0 0.215431)
(0.368188 -0.0967965 0 0.143513 0 0.217716)
(0.372842 -0.0984673 0 0.144574 0 0.220094)
(0.376741 -0.0999089 0 0.145563 0 0.222157)
(0.123466 0.000124729 0 0.098014 0 0.123353)
(0.123127 0.000128462 0 0.0972592 0 0.122995)
(0.122765 0.000132879 0 0.0965339 0 0.122618)
(0.122364 0.00013717 0 0.0958555 0 0.122224)
(0.121833 0.000140125 0 0.0953018 0 0.121822)
(0.120946 0.000141199 0 0.095078 0 0.121439)
(0.120082 0.000139966 0 0.0948443 0 0.121033)
(0.119245 0.0001357 0 0.0945973 0 0.120606)
(0.118436 0.000127461 0 0.0943367 0 0.12016)
(0.117654 0.000114184 0 0.0940637 0 0.119697)
(0.116896 9.46226e-05 0 0.0937804 0 0.119219)
(0.116164 6.71656e-05 0 0.0934891 0 0.11873)
(0.115456 3.01116e-05 0 0.0931927 0 0.11823)
(0.114774 -1.84148e-05 0 0.0928946 0 0.117724)
(0.11412 -8.04596e-05 0 0.0925986 0 0.117215)
(0.113497 -0.000158246 0 0.0923088 0 0.116705)
(0.11291 -0.000254188 0 0.0920297 0 0.116198)
(0.112364 -0.000370917 0 0.091766 0 0.1157)
(0.111868 -0.000511223 0 0.0915216 0 0.115213)
(0.111444 -0.000677944 0 0.0912912 0 0.114743)
(0.111223 -0.000873644 0 0.0909663 0 0.114284)
(0.111087 -0.00110136 0 0.0906691 0 0.113855)
(0.111041 -0.00136425 0 0.0904095 0 0.113461)
(0.111094 -0.00166557 0 0.0901938 0 0.11311)
(0.111258 -0.00200862 0 0.0900271 0 0.112806)
(0.111544 -0.00239664 0 0.0899132 0 0.112556)
(0.111964 -0.00283278 0 0.0898553 0 0.112365)
(0.112528 -0.00331997 0 0.0898562 0 0.112239)
(0.113246 -0.00386088 0 0.0899182 0 0.112182)
(0.114127 -0.00445777 0 0.0900431 0 0.112198)
(0.115179 -0.00511252 0 0.0902323 0 0.112292)
(0.116408 -0.00582662 0 0.0904869 0 0.112468)
(0.117819 -0.00660114 0 0.0908076 0 0.112727)
(0.119417 -0.00743676 0 0.0911948 0 0.113073)
(0.121205 -0.00833374 0 0.0916487 0 0.113508)
(0.123185 -0.00929183 0 0.092169 0 0.114033)
(0.125358 -0.0103103 0 0.0927553 0 0.11465)
(0.127723 -0.0113881 0 0.0934068 0 0.115359)
(0.130278 -0.0125234 0 0.094122 0 0.116161)
(0.133021 -0.013714 0 0.0948993 0 0.117054)
(0.135948 -0.0149572 0 0.0957365 0 0.118037)
(0.139053 -0.0162497 0 0.0966307 0 0.119109)
(0.142327 -0.0175877 0 0.0975784 0 0.120267)
(0.145763 -0.0189669 0 0.0985756 0 0.121508)
(0.14935 -0.0203824 0 0.0996173 0 0.122826)
(0.153076 -0.0218286 0 0.100698 0 0.124218)
(0.156925 -0.0232996 0 0.101811 0 0.125676)
(0.160883 -0.0247889 0 0.10295 0 0.127193)
(0.16493 -0.0262894 0 0.104106 0 0.128762)
(0.169049 -0.0277937 0 0.10527 0 0.130372)
(0.173216 -0.029294 0 0.106434 0 0.132015)
(0.177411 -0.0307822 0 0.107587 0 0.13368)
(0.181609 -0.0322501 0 0.10872 0 0.135355)
(0.185786 -0.0336898 0 0.109822 0 0.137029)
(0.189918 -0.0350933 0 0.110883 0 0.138689)
(0.193981 -0.0364533 0 0.111893 0 0.140325)
(0.197953 -0.037763 0 0.112843 0 0.141925)
(0.201812 -0.0390163 0 0.113724 0 0.143478)
(0.205539 -0.0402085 0 0.114529 0 0.144975)
(0.209119 -0.0413358 0 0.115253 0 0.146407)
(0.212537 -0.0423956 0 0.115891 0 0.147768)
(0.215785 -0.043387 0 0.116439 0 0.149053)
(0.218856 -0.0443103 0 0.116898 0 0.150257)
(0.221748 -0.0451675 0 0.117266 0 0.15138)
(0.224463 -0.0459618 0 0.117546 0 0.152422)
(0.227006 -0.0466977 0 0.117742 0 0.153384)
(0.229386 -0.0473813 0 0.11786 0 0.154271)
(0.231615 -0.0480193 0 0.117905 0 0.155088)
(0.23371 -0.0486198 0 0.117886 0 0.155843)
(0.235687 -0.0491915 0 0.117812 0 0.156544)
(0.237568 -0.0497439 0 0.117692 0 0.157201)
(0.239374 -0.0502869 0 0.117537 0 0.157824)
(0.241131 -0.0508311 0 0.117359 0 0.158427)
(0.242864 -0.0513869 0 0.117168 0 0.159021)
(0.244599 -0.0519653 0 0.116977 0 0.15962)
(0.246364 -0.0525766 0 0.116798 0 0.160237)
(0.248185 -0.0532309 0 0.116643 0 0.160885)
(0.250087 -0.0539375 0 0.116523 0 0.16158)
(0.252097 -0.0547045 0 0.11645 0 0.162332)
(0.254236 -0.0555389 0 0.116431 0 0.163155)
(0.256526 -0.0564459 0 0.116476 0 0.164059)
(0.258984 -0.0574293 0 0.116591 0 0.165054)
(0.261626 -0.0584914 0 0.116782 0 0.166148)
(0.264462 -0.0596332 0 0.117051 0 0.167348)
(0.267501 -0.0608537 0 0.117401 0 0.168659)
(0.270747 -0.0621504 0 0.117832 0 0.170082)
(0.274198 -0.0635191 0 0.118344 0 0.171619)
(0.277848 -0.0649535 0 0.118932 0 0.173268)
(0.281688 -0.0664456 0 0.119592 0 0.175024)
(0.285701 -0.0679858 0 0.120317 0 0.176881)
(0.289869 -0.0695631 0 0.121099 0 0.17883)
(0.294166 -0.0711653 0 0.121927 0 0.180858)
(0.29857 -0.0727803 0 0.122792 0 0.182955)
(0.303051 -0.0743976 0 0.123681 0 0.185106)
(0.307599 -0.0760104 0 0.124591 0 0.187305)
(0.312183 -0.0776202 0 0.125516 0 0.189539)
(0.316849 -0.0792431 0 0.126478 0 0.191827)
(0.321513 -0.0808986 0 0.127481 0 0.194143)
(0.32625 -0.0826434 0 0.128616 0 0.196512)
(0.330137 -0.0841144 0 0.129633 0 0.198518)
(0.122787 0.000343306 0 0.100234 0 0.123035)
(0.122462 0.000357997 0 0.0995066 0 0.1227)
(0.12212 0.000373427 0 0.0987994 0 0.122351)
(0.121757 0.000389014 0 0.0981201 0 0.121984)
(0.121347 0.000403922 0 0.0974907 0 0.121605)
(0.120817 0.000417544 0 0.0969764 0 0.121219)
(0.119939 0.000429617 0 0.0967842 0 0.120852)
(0.119108 0.000439575 0 0.0965566 0 0.120462)
(0.118314 0.000446792 0 0.0963037 0 0.120054)
(0.117549 0.000450578 0 0.096032 0 0.119628)
(0.116807 0.000450158 0 0.0957457 0 0.119187)
(0.116087 0.000444637 0 0.0954478 0 0.118733)
(0.115385 0.000433128 0 0.0951412 0 0.118267)
(0.1147 0.000414728 0 0.0948285 0 0.11779)
(0.114031 0.000388538 0 0.0945123 0 0.117306)
(0.11338 0.000353646 0 0.0941951 0 0.116816)
(0.112746 0.000309112 0 0.0938797 0 0.116321)
(0.112132 0.000253918 0 0.093569 0 0.115824)
(0.111542 0.000186958 0 0.0932653 0 0.115329)
(0.110984 0.000107049 0 0.0929677 0 0.114836)
(0.110497 1.30592e-05 0 0.0926494 0 0.114347)
(0.110186 -9.63646e-05 0 0.0922216 0 0.113857)
(0.109908 -0.000222836 0 0.0918233 0 0.113384)
(0.109675 -0.000368271 0 0.091453 0 0.112932)
(0.109497 -0.000534788 0 0.0911113 0 0.112503)
(0.109386 -0.000724669 0 0.0907997 0 0.112101)
(0.109348 -0.000940294 0 0.0905203 0 0.111731)
(0.109394 -0.00118406 0 0.0902748 0 0.111397)
(0.109531 -0.00145828 0 0.0900652 0 0.111101)
(0.109766 -0.00176513 0 0.0898931 0 0.110848)
(0.110106 -0.00210654 0 0.0897597 0 0.110642)
(0.110557 -0.00248424 0 0.0896663 0 0.110484)
(0.111125 -0.00289968 0 0.0896137 0 0.110377)
(0.111813 -0.00335405 0 0.0896024 0 0.110325)
(0.112626 -0.00384823 0 0.0896329 0 0.110329)
(0.113566 -0.00438279 0 0.0897054 0 0.110391)
(0.114635 -0.00495799 0 0.0898199 0 0.110512)
(0.115835 -0.00557381 0 0.0899762 0 0.110693)
(0.117166 -0.00622992 0 0.0901739 0 0.110936)
(0.118629 -0.00692574 0 0.0904126 0 0.111241)
(0.120223 -0.00766039 0 0.0906913 0 0.111608)
(0.121948 -0.00843273 0 0.0910093 0 0.112037)
(0.1238 -0.00924136 0 0.0913653 0 0.112528)
(0.125779 -0.0100846 0 0.0917577 0 0.113081)
(0.12788 -0.0109604 0 0.0921849 0 0.113694)
(0.1301 -0.0118664 0 0.0926446 0 0.114367)
(0.132433 -0.0128001 0 0.0931343 0 0.115096)
(0.134873 -0.0137585 0 0.0936508 0 0.11588)
(0.137413 -0.0147382 0 0.0941908 0 0.116716)
(0.140044 -0.0157355 0 0.0947501 0 0.117599)
(0.142757 -0.0167466 0 0.0953242 0 0.118526)
(0.14554 -0.017767 0 0.095908 0 0.119491)
(0.148382 -0.0187924 0 0.0964961 0 0.120489)
(0.151268 -0.0198179 0 0.0970827 0 0.121513)
(0.154185 -0.0208388 0 0.0976616 0 0.122557)
(0.157117 -0.0218503 0 0.0982267 0 0.123614)
(0.160051 -0.0228478 0 0.0987717 0 0.124676)
(0.16297 -0.023827 0 0.0992906 0 0.125737)
(0.165861 -0.0247838 0 0.0997779 0 0.126788)
(0.16871 -0.0257149 0 0.100228 0 0.127825)
(0.171504 -0.0266175 0 0.100637 0 0.128839)
(0.174232 -0.0274897 0 0.101002 0 0.129827)
(0.176887 -0.0283303 0 0.101318 0 0.130783)
(0.179461 -0.0291391 0 0.101586 0 0.131705)
(0.18195 -0.0299171 0 0.101804 0 0.132589)
(0.184352 -0.0306657 0 0.101973 0 0.133435)
(0.186669 -0.0313879 0 0.102095 0 0.134244)
(0.188904 -0.0320871 0 0.102173 0 0.135017)
(0.191064 -0.0327677 0 0.102211 0 0.135757)
(0.193156 -0.0334349 0 0.102213 0 0.136467)
(0.195192 -0.0340946 0 0.102185 0 0.137154)
(0.197184 -0.0347534 0 0.102135 0 0.137823)
(0.199148 -0.0354182 0 0.10207 0 0.138482)
(0.2011 -0.0360965 0 0.101997 0 0.139139)
(0.203057 -0.0367958 0 0.101925 0 0.139803)
(0.20504 -0.0375241 0 0.101863 0 0.140484)
(0.207067 -0.0382888 0 0.10182 0 0.141192)
(0.209159 -0.0390974 0 0.101806 0 0.141937)
(0.211335 -0.0399563 0 0.101828 0 0.14273)
(0.213614 -0.0408714 0 0.101895 0 0.14358)
(0.216015 -0.0418475 0 0.102013 0 0.144496)
(0.218552 -0.0428883 0 0.10219 0 0.145489)
(0.221242 -0.0439966 0 0.102431 0 0.146565)
(0.224097 -0.0451738 0 0.102738 0 0.147731)
(0.227124 -0.0464201 0 0.103117 0 0.148992)
(0.230331 -0.0477344 0 0.103567 0 0.150352)
(0.23372 -0.0491139 0 0.104089 0 0.151814)
(0.237289 -0.0505544 0 0.104681 0 0.153376)
(0.241032 -0.05205 0 0.105341 0 0.155038)
(0.24494 -0.0535934 0 0.106064 0 0.156795)
(0.248999 -0.0551758 0 0.106844 0 0.158641)
(0.25319 -0.0567875 0 0.107672 0 0.160567)
(0.257496 -0.0584187 0 0.108541 0 0.162565)
(0.261893 -0.0600605 0 0.109442 0 0.164623)
(0.266371 -0.0617068 0 0.110371 0 0.166736)
(0.270902 -0.0633578 0 0.111323 0 0.168892)
(0.275516 -0.0650236 0 0.112314 0 0.171104)
(0.280124 -0.0667135 0 0.113341 0 0.173341)
(0.284751 -0.0684575 0 0.114469 0 0.175606)
(0.288489 -0.0699051 0 0.115452 0 0.17749)
(0.122156 0.000459433 0 0.102086 0 0.122637)
(0.121838 0.000481481 0 0.101386 0 0.122318)
(0.121509 0.000504288 0 0.100702 0 0.121987)
(0.121164 0.000527419 0 0.100036 0 0.121641)
(0.120796 0.000550258 0 0.0993981 0 0.121282)
(0.120366 0.000572319 0 0.0988224 0 0.120913)
(0.119608 0.000593284 0 0.0985494 0 0.12056)
(0.118856 0.000612719 0 0.0982764 0 0.120192)
(0.118116 0.000630107 0 0.0979975 0 0.119808)
(0.117392 0.00064493 0 0.0977105 0 0.11941)
(0.116681 0.000656624 0 0.0974145 0 0.118997)
(0.115985 0.000664657 0 0.0971098 0 0.118572)
(0.115301 0.000668532 0 0.0967973 0 0.118136)
(0.11463 0.000667815 0 0.0964783 0 0.117688)
(0.113968 0.000662151 0 0.0961543 0 0.117232)
(0.113317 0.000651263 0 0.0958268 0 0.116766)
(0.112676 0.000634931 0 0.0954975 0 0.116294)
(0.112045 0.000612961 0 0.0951682 0 0.115816)
(0.111425 0.000585144 0 0.0948403 0 0.115333)
(0.110821 0.000551252 0 0.094514 0 0.114848)
(0.110249 0.000511023 0 0.0941774 0 0.11436)
(0.109827 0.000464147 0 0.0937276 0 0.113863)
(0.109434 0.000410092 0 0.0932791 0 0.113371)
(0.109068 0.000347992 0 0.0928388 0 0.112886)
(0.108733 0.000276722 0 0.0924109 0 0.112411)
(0.108432 0.000194907 0 0.0919979 0 0.111948)
(0.108172 0.000100963 0 0.0916016 0 0.111501)
(0.107958 -6.84502e-06 0 0.0912239 0 0.111072)
(0.107796 -0.000130331 0 0.0908659 0 0.110664)
(0.107693 -0.000271322 0 0.0905291 0 0.11028)
(0.107652 -0.000431603 0 0.0902145 0 0.109921)
(0.107681 -0.000612874 0 0.0899233 0 0.109592)
(0.107783 -0.000816713 0 0.0896562 0 0.109293)
(0.107963 -0.00104454 0 0.0894141 0 0.109027)
(0.108225 -0.00129758 0 0.0891975 0 0.108796)
(0.108572 -0.00157685 0 0.089007 0 0.108603)
(0.109006 -0.00188311 0 0.0888428 0 0.108447)
(0.10953 -0.00221691 0 0.088705 0 0.108331)
(0.110145 -0.00257856 0 0.0885937 0 0.108256)
(0.110853 -0.0029682 0 0.0885089 0 0.108222)
(0.111654 -0.00338573 0 0.0884502 0 0.10823)
(0.112548 -0.00383092 0 0.0884173 0 0.108282)
(0.113537 -0.00430332 0 0.0884098 0 0.108377)
(0.114618 -0.00480235 0 0.088427 0 0.108516)
(0.115793 -0.00532724 0 0.0884683 0 0.108698)
(0.11706 -0.00587705 0 0.0885327 0 0.108924)
(0.118416 -0.00645069 0 0.0886192 0 0.109194)
(0.119861 -0.00704686 0 0.0887263 0 0.109506)
(0.121392 -0.00766409 0 0.0888527 0 0.109859)
(0.123004 -0.00830072 0 0.0889965 0 0.110254)
(0.124695 -0.0089549 0 0.0891555 0 0.110687)
(0.12646 -0.0096246 0 0.0893273 0 0.111157)
(0.128292 -0.0103076 0 0.0895094 0 0.111662)
(0.130186 -0.0110015 0 0.0896986 0 0.112198)
(0.132134 -0.0117039 0 0.0898919 0 0.112763)
(0.134128 -0.0124121 0 0.0900857 0 0.113352)
(0.136161 -0.0131235 0 0.0902766 0 0.113962)
(0.138223 -0.0138357 0 0.0904609 0 0.114589)
(0.140305 -0.0145461 0 0.090635 0 0.115229)
(0.142398 -0.0152525 0 0.0907957 0 0.115876)
(0.144493 -0.0159529 0 0.0909398 0 0.116528)
(0.146582 -0.0166459 0 0.0910645 0 0.11718)
(0.148658 -0.0173302 0 0.0911675 0 0.117828)
(0.150715 -0.0180053 0 0.0912471 0 0.118469)
(0.152746 -0.0186711 0 0.0913023 0 0.119102)
(0.154748 -0.0193281 0 0.0913327 0 0.119723)
(0.15672 -0.0199776 0 0.0913387 0 0.120333)
(0.158661 -0.0206213 0 0.0913214 0 0.120931)
(0.160572 -0.0212618 0 0.0912829 0 0.121518)
(0.162457 -0.0219019 0 0.0912257 0 0.122095)
(0.16432 -0.0225454 0 0.0911533 0 0.122665)
(0.166169 -0.0231964 0 0.09107 0 0.123232)
(0.168013 -0.0238596 0 0.0909804 0 0.1238)
(0.16986 -0.0245399 0 0.0908901 0 0.124375)
(0.171724 -0.0252429 0 0.0908052 0 0.124961)
(0.173617 -0.0259741 0 0.090732 0 0.125567)
(0.175554 -0.0267391 0 0.0906774 0 0.126198)
(0.177549 -0.0275435 0 0.0906483 0 0.126864)
(0.179616 -0.0283924 0 0.0906517 0 0.127571)
(0.181773 -0.0292907 0 0.0906942 0 0.128329)
(0.184033 -0.0302424 0 0.090782 0 0.129144)
(0.186411 -0.0312509 0 0.0909208 0 0.130025)
(0.18892 -0.032319 0 0.0911155 0 0.130978)
(0.191572 -0.0334485 0 0.0913702 0 0.132011)
(0.194377 -0.0346402 0 0.0916882 0 0.133127)
(0.197341 -0.0358939 0 0.0920718 0 0.134333)
(0.200471 -0.0372082 0 0.092522 0 0.13563)
(0.203766 -0.0385802 0 0.0930387 0 0.13702)
(0.207226 -0.0400057 0 0.0936202 0 0.138502)
(0.210843 -0.0414793 0 0.0942637 0 0.140076)
(0.21461 -0.0429943 0 0.0949646 0 0.141736)
(0.218513 -0.0445432 0 0.0957173 0 0.143478)
(0.222538 -0.0461177 0 0.0965157 0 0.145293)
(0.226667 -0.0477108 0 0.0973527 0 0.147175)
(0.230891 -0.0493168 0 0.0982246 0 0.149117)
(0.235183 -0.0509349 0 0.0991266 0 0.151109)
(0.239563 -0.0525708 0 0.100071 0 0.153161)
(0.24394 -0.0542256 0 0.10105 0 0.155237)
(0.248311 -0.0559111 0 0.102107 0 0.157329)
(0.251804 -0.0572958 0 0.103012 0 0.159047)
(0.121578 0.000508774 0 0.103648 0 0.122204)
(0.121263 0.000535315 0 0.102977 0 0.121894)
(0.120939 0.00056266 0 0.102316 0 0.121573)
(0.120604 0.000590482 0 0.101668 0 0.121241)
(0.120254 0.000618311 0 0.101038 0 0.120897)
(0.119877 0.000645721 0 0.100437 0 0.120542)
(0.119407 0.00067238 0 0.099925 0 0.120182)
(0.118671 0.000697979 0 0.0996605 0 0.119833)
(0.117952 0.000722047 0 0.099385 0 0.119469)
(0.117248 0.00074414 0 0.0990996 0 0.119092)
(0.116557 0.000763838 0 0.0988048 0 0.118703)
(0.115879 0.000780779 0 0.0985012 0 0.118301)
(0.115212 0.00079465 0 0.0981899 0 0.117888)
(0.114554 0.000805225 0 0.0978719 0 0.117466)
(0.113905 0.000812387 0 0.0975481 0 0.117033)
(0.113263 0.000816134 0 0.0972197 0 0.116592)
(0.112628 0.000816568 0 0.0968878 0 0.116142)
(0.111998 0.000813871 0 0.0965536 0 0.115686)
(0.111375 0.000808269 0 0.0962181 0 0.115223)
(0.11076 0.00080002 0 0.0958816 0 0.114755)
(0.110159 0.000789362 0 0.0955401 0 0.114281)
(0.109605 0.000776492 0 0.0951648 0 0.113802)
(0.109199 0.000761567 0 0.0946651 0 0.113312)
(0.108796 0.000744454 0 0.0941773 0 0.112823)
(0.108403 0.000724734 0 0.0936995 0 0.112338)
(0.108024 0.000701743 0 0.093231 0 0.111858)
(0.107663 0.000674584 0 0.092772 0 0.111385)
(0.107327 0.000642163 0 0.0923228 0 0.110919)
(0.107019 0.000603234 0 0.0918839 0 0.110464)
(0.106743 0.00055644 0 0.0914559 0 0.110021)
(0.106505 0.00050036 0 0.0910397 0 0.109591)
(0.106308 0.000433543 0 0.0906358 0 0.109177)
(0.106157 0.000354555 0 0.090245 0 0.108781)
(0.106054 0.00026201 0 0.0898679 0 0.108404)
(0.106005 0.000154617 0 0.0895051 0 0.108048)
(0.106011 3.1206e-05 0 0.0891571 0 0.107715)
(0.106075 -0.00010924 0 0.0888243 0 0.107405)
(0.1062 -0.000267576 0 0.0885073 0 0.107121)
(0.106389 -0.000444494 0 0.0882061 0 0.106863)
(0.106642 -0.000640523 0 0.0879209 0 0.106632)
(0.10696 -0.000856041 0 0.0876519 0 0.10643)
(0.107346 -0.00109128 0 0.0873989 0 0.106257)
(0.1078 -0.00134633 0 0.087162 0 0.106113)
(0.108322 -0.00162116 0 0.0869407 0 0.106)
(0.108914 -0.00191563 0 0.0867349 0 0.105918)
(0.109574 -0.00222945 0 0.0865442 0 0.105867)
(0.110303 -0.00256227 0 0.0863681 0 0.105847)
(0.1111 -0.0029136 0 0.0862059 0 0.105858)
(0.111965 -0.00328288 0 0.0860571 0 0.105901)
(0.112896 -0.00366942 0 0.0859207 0 0.105975)
(0.113893 -0.00407246 0 0.0857958 0 0.10608)
(0.114954 -0.00449114 0 0.0856812 0 0.106215)
(0.116075 -0.0049245 0 0.0855756 0 0.106379)
(0.117256 -0.0053715 0 0.0854777 0 0.106571)
(0.118491 -0.00583102 0 0.0853857 0 0.10679)
(0.119778 -0.00630187 0 0.0852981 0 0.107034)
(0.121112 -0.00678281 0 0.0852129 0 0.107302)
(0.122489 -0.00727263 0 0.0851282 0 0.107591)
(0.123904 -0.00777009 0 0.0850422 0 0.107898)
(0.125351 -0.00827405 0 0.0849529 0 0.108223)
(0.126825 -0.00878348 0 0.0848584 0 0.108562)
(0.12832 -0.00929751 0 0.0847572 0 0.108913)
(0.129833 -0.00981549 0 0.0846477 0 0.109273)
(0.131357 -0.010337 0 0.0845289 0 0.109641)
(0.132889 -0.010862 0 0.0843998 0 0.110015)
(0.134426 -0.0113908 0 0.0842603 0 0.110393)
(0.135965 -0.011924 0 0.0841102 0 0.110773)
(0.137503 -0.0124626 0 0.0839503 0 0.111157)
(0.139042 -0.0130081 0 0.0837815 0 0.111542)
(0.140582 -0.0135623 0 0.0836055 0 0.111931)
(0.142124 -0.0141277 0 0.0834246 0 0.112325)
(0.143673 -0.0147069 0 0.0832413 0 0.112724)
(0.145234 -0.015303 0 0.0830591 0 0.113133)
(0.146812 -0.0159195 0 0.0828817 0 0.113554)
(0.148416 -0.0165602 0 0.0827136 0 0.113991)
(0.150053 -0.017229 0 0.0825593 0 0.11445)
(0.151735 -0.0179302 0 0.0824242 0 0.114934)
(0.153471 -0.0186679 0 0.0823135 0 0.115451)
(0.155275 -0.0194461 0 0.0822329 0 0.116005)
(0.157156 -0.0202685 0 0.0821878 0 0.116605)
(0.159129 -0.0211387 0 0.0821835 0 0.117255)
(0.161206 -0.0220597 0 0.082225 0 0.117963)
(0.163397 -0.023034 0 0.0823169 0 0.118735)
(0.165715 -0.0240636 0 0.0824633 0 0.119577)
(0.168169 -0.0251498 0 0.0826675 0 0.120494)
(0.170767 -0.0262929 0 0.0829324 0 0.121492)
(0.173516 -0.0274925 0 0.0832596 0 0.122572)
(0.176419 -0.0287469 0 0.08365 0 0.123739)
(0.179476 -0.0300535 0 0.0841031 0 0.124992)
(0.182685 -0.0314083 0 0.0846174 0 0.126332)
(0.186042 -0.0328064 0 0.08519 0 0.127757)
(0.189537 -0.034242 0 0.085817 0 0.129262)
(0.19316 -0.0357088 0 0.0864938 0 0.130843)
(0.196897 -0.0372008 0 0.0872148 0 0.132494)
(0.200739 -0.038713 0 0.087977 0 0.13421)
(0.204665 -0.0402439 0 0.0887759 0 0.135982)
(0.208684 -0.0417959 0 0.0896205 0 0.137816)
(0.212708 -0.0433646 0 0.0904991 0 0.139677)
(0.216723 -0.0449497 0 0.0914424 0 0.141552)
(0.21991 -0.0462453 0 0.0922401 0 0.143077)
(0.121056 0.000514796 0 0.10495 0 0.121764)
(0.120739 0.000543846 0 0.104305 0 0.121457)
(0.120415 0.000573729 0 0.103667 0 0.121141)
(0.120083 0.000604188 0 0.103039 0 0.120816)
(0.119742 0.000634865 0 0.102423 0 0.120481)
(0.119386 0.000665387 0 0.101823 0 0.120136)
(0.118999 0.000695435 0 0.101255 0 0.119782)
(0.118529 0.000724722 0 0.100766 0 0.119424)
(0.11782 0.000752948 0 0.1005 0 0.119075)
(0.117127 0.000779686 0 0.100223 0 0.118713)
(0.116447 0.000804586 0 0.099936 0 0.11834)
(0.11578 0.000827364 0 0.0996392 0 0.117956)
(0.115124 0.000847804 0 0.0993339 0 0.117562)
(0.114477 0.000865781 0 0.0990212 0 0.117158)
(0.113838 0.000881284 0 0.0987021 0 0.116745)
(0.113205 0.000894427 0 0.0983775 0 0.116323)
(0.112578 0.000905442 0 0.0980484 0 0.115894)
(0.111956 0.000914665 0 0.0977156 0 0.115457)
(0.111338 0.000922504 0 0.0973798 0 0.115013)
(0.110725 0.000929422 0 0.0970415 0 0.114563)
(0.11012 0.000935895 0 0.0966983 0 0.114107)
(0.109541 0.000942378 0 0.096334 0 0.113644)
(0.109117 0.000949319 0 0.0958312 0 0.113167)
(0.108696 0.000957055 0 0.0953307 0 0.11269)
(0.108279 0.000965595 0 0.0948336 0 0.112211)
(0.107869 0.000974746 0 0.0943401 0 0.111734)
(0.107467 0.000984109 0 0.0938506 0 0.111258)
(0.107078 0.000993091 0 0.0933654 0 0.110785)
(0.106703 0.00100093 0 0.0928846 0 0.110316)
(0.106346 0.00100673 0 0.0924086 0 0.109853)
(0.106009 0.00100947 0 0.0919376 0 0.109395)
(0.105698 0.00100804 0 0.0914719 0 0.108946)
(0.105413 0.00100129 0 0.091012 0 0.108506)
(0.105159 0.000988055 0 0.0905583 0 0.108076)
(0.104938 0.000967167 0 0.0901112 0 0.107658)
(0.104753 0.000937517 0 0.0896711 0 0.107252)
(0.104606 0.000898067 0 0.0892384 0 0.106861)
(0.1045 0.00084787 0 0.0888134 0 0.106486)
(0.104437 0.000786086 0 0.0883965 0 0.106126)
(0.104418 0.000711982 0 0.087988 0 0.105784)
(0.104445 0.000624943 0 0.087588 0 0.105461)
(0.104519 0.00052446 0 0.0871967 0 0.105156)
(0.104642 0.000410135 0 0.0868142 0 0.104871)
(0.104815 0.000281672 0 0.0864404 0 0.104606)
(0.105038 0.000138871 0 0.0860753 0 0.104362)
(0.105311 -1.83821e-05 0 0.0857187 0 0.10414)
(0.105637 -0.000190119 0 0.0853706 0 0.103939)
(0.106013 -0.0003763 0 0.0850305 0 0.103761)
(0.106442 -0.000576823 0 0.0846983 0 0.103605)
(0.106923 -0.000791529 0 0.0843735 0 0.103472)
(0.107454 -0.00102021 0 0.0840557 0 0.103362)
(0.108037 -0.00126261 0 0.0837443 0 0.103275)
(0.10867 -0.00151843 0 0.0834387 0 0.10321)
(0.109353 -0.00178734 0 0.0831383 0 0.103167)
(0.110083 -0.00206898 0 0.0828423 0 0.103146)
(0.11086 -0.00236293 0 0.0825499 0 0.103147)
(0.111682 -0.0026688 0 0.0822602 0 0.103168)
(0.112545 -0.00298615 0 0.0819723 0 0.103209)
(0.113449 -0.00331457 0 0.0816854 0 0.103269)
(0.114389 -0.00365366 0 0.0813984 0 0.103346)
(0.115364 -0.00400309 0 0.0811105 0 0.10344)
(0.11637 -0.00436259 0 0.080821 0 0.103549)
(0.117403 -0.00473199 0 0.0805291 0 0.103672)
(0.118462 -0.00511127 0 0.0802342 0 0.103807)
(0.119543 -0.00550055 0 0.0799362 0 0.103954)
(0.120644 -0.00590016 0 0.0796348 0 0.104112)
(0.121763 -0.00631062 0 0.0793303 0 0.104279)
(0.122898 -0.0067327 0 0.0790231 0 0.104456)
(0.124049 -0.00716743 0 0.0787141 0 0.104643)
(0.125215 -0.0076161 0 0.0784046 0 0.104838)
(0.126398 -0.00808031 0 0.078096 0 0.105045)
(0.127599 -0.00856192 0 0.0777904 0 0.105262)
(0.128821 -0.00906309 0 0.0774901 0 0.105493)
(0.130067 -0.00958626 0 0.0771981 0 0.105739)
(0.131344 -0.0101341 0 0.0769175 0 0.106003)
(0.132657 -0.0107095 0 0.076652 0 0.106288)
(0.134012 -0.0113154 0 0.0764055 0 0.106599)
(0.135418 -0.011955 0 0.0761823 0 0.106939)
(0.136885 -0.0126313 0 0.0759868 0 0.107313)
(0.13842 -0.0133474 0 0.0758236 0 0.107727)
(0.140035 -0.014106 0 0.0756972 0 0.108185)
(0.141741 -0.0149097 0 0.075612 0 0.108694)
(0.143546 -0.0157609 0 0.0755722 0 0.109258)
(0.145463 -0.0166616 0 0.0755818 0 0.109884)
(0.1475 -0.0176133 0 0.0756441 0 0.110577)
(0.149667 -0.018617 0 0.0757623 0 0.111341)
(0.151969 -0.0196728 0 0.0759386 0 0.112181)
(0.154413 -0.0207802 0 0.0761747 0 0.113099)
(0.157002 -0.0219376 0 0.076471 0 0.114097)
(0.159735 -0.0231426 0 0.0768273 0 0.115178)
(0.162612 -0.0243919 0 0.077242 0 0.116339)
(0.165627 -0.0256812 0 0.0777127 0 0.11758)
(0.168774 -0.0270057 0 0.0782361 0 0.118897)
(0.172042 -0.0283608 0 0.0788082 0 0.120286)
(0.175423 -0.0297422 0 0.0794267 0 0.121744)
(0.178899 -0.0311479 0 0.0800871 0 0.123262)
(0.182475 -0.0325778 0 0.0807963 0 0.124843)
(0.186067 -0.0340245 0 0.0815408 0 0.126457)
(0.189662 -0.0354809 0 0.0823428 0 0.128087)
(0.192511 -0.0366715 0 0.0830172 0 0.129409)
(0.120591 0.000495764 0 0.106051 0 0.121339)
(0.120271 0.000525673 0 0.105429 0 0.121032)
(0.119945 0.000556452 0 0.104813 0 0.120717)
(0.119612 0.000587888 0 0.104203 0 0.120395)
(0.119272 0.000619694 0 0.103603 0 0.120064)
(0.118923 0.000651551 0 0.103013 0 0.119725)
(0.118561 0.000683158 0 0.102438 0 0.119377)
(0.11817 0.000714263 0 0.101892 0 0.119021)
(0.117705 0.000744617 0 0.101416 0 0.118662)
(0.117021 0.000773963 0 0.101146 0 0.11831)
(0.11635 0.00080196 0 0.100865 0 0.117948)
(0.115691 0.000828357 0 0.100575 0 0.117576)
(0.115043 0.000852992 0 0.100277 0 0.117195)
(0.114404 0.000875793 0 0.0999709 0 0.116805)
(0.113772 0.000896789 0 0.0996579 0 0.116406)
(0.113147 0.000916133 0 0.0993389 0 0.116)
(0.112528 0.000934092 0 0.0990148 0 0.115586)
(0.111913 0.00095104 0 0.0986861 0 0.115165)
(0.111302 0.000967434 0 0.0983533 0 0.114737)
(0.110696 0.000983795 0 0.0980163 0 0.114303)
(0.110098 0.00100069 0 0.0976724 0 0.113862)
(0.109526 0.00101867 0 0.0973051 0 0.113415)
(0.109104 0.00103828 0 0.0967986 0 0.112953)
(0.108683 0.00106011 0 0.0962917 0 0.112488)
(0.108263 0.00108439 0 0.0957856 0 0.112022)
(0.107844 0.0011112 0 0.0952805 0 0.111555)
(0.107429 0.00114046 0 0.0947767 0 0.111088)
(0.10702 0.00117191 0 0.094274 0 0.11062)
(0.106617 0.00120515 0 0.0937725 0 0.110154)
(0.106224 0.00123963 0 0.093272 0 0.109688)
(0.105843 0.00127468 0 0.0927726 0 0.109226)
(0.105476 0.00130953 0 0.0922743 0 0.108766)
(0.105126 0.00134331 0 0.0917771 0 0.10831)
(0.104794 0.00137511 0 0.0912812 0 0.10786)
(0.104483 0.00140399 0 0.0907868 0 0.107416)
(0.104195 0.00142902 0 0.0902942 0 0.106978)
(0.103931 0.00144925 0 0.0898035 0 0.106548)
(0.103695 0.00146381 0 0.089315 0 0.106127)
(0.103488 0.00147187 0 0.0888291 0 0.105715)
(0.10331 0.00147265 0 0.0883459 0 0.105314)
(0.103165 0.00146546 0 0.0878656 0 0.104924)
(0.103053 0.00144968 0 0.0873884 0 0.104545)
(0.102975 0.00142475 0 0.0869146 0 0.104179)
(0.102932 0.00139021 0 0.0864441 0 0.103827)
(0.102926 0.00134565 0 0.085977 0 0.103488)
(0.102957 0.00129075 0 0.0855135 0 0.103163)
(0.103026 0.00122524 0 0.0850533 0 0.102853)
(0.103134 0.00114889 0 0.0845965 0 0.102558)
(0.103281 0.00106156 0 0.0841429 0 0.102279)
(0.103467 0.000963096 0 0.0836924 0 0.102015)
(0.103692 0.000853411 0 0.0832448 0 0.101768)
(0.103957 0.000732429 0 0.0827998 0 0.101537)
(0.104262 0.000600092 0 0.0823571 0 0.101323)
(0.104606 0.000456356 0 0.0819166 0 0.101125)
(0.104989 0.000301189 0 0.0814778 0 0.100943)
(0.10541 0.000134561 0 0.0810404 0 0.100779)
(0.105869 -4.35552e-05 0 0.0806041 0 0.10063)
(0.106364 -0.000233191 0 0.0801684 0 0.100498)
(0.106895 -0.000434388 0 0.0797331 0 0.100381)
(0.107461 -0.000647209 0 0.0792978 0 0.100279)
(0.108059 -0.000871742 0 0.0788623 0 0.100192)
(0.108688 -0.00110812 0 0.0784262 0 0.100119)
(0.109346 -0.00135652 0 0.0779895 0 0.10006)
(0.110032 -0.00161721 0 0.077552 0 0.100014)
(0.110744 -0.00189051 0 0.0771138 0 0.0999804)
(0.111481 -0.00217686 0 0.0766752 0 0.0999588)
(0.11224 -0.00247681 0 0.0762366 0 0.0999487)
(0.113021 -0.00279105 0 0.0757984 0 0.0999501)
(0.113824 -0.0031204 0 0.0753616 0 0.0999627)
(0.114647 -0.00346586 0 0.0749271 0 0.0999869)
(0.115492 -0.00382862 0 0.0744964 0 0.100023)
(0.116359 -0.00421001 0 0.0740709 0 0.100072)
(0.11725 -0.00461159 0 0.0736526 0 0.100135)
(0.118167 -0.0050351 0 0.0732438 0 0.100213)
(0.119114 -0.00548243 0 0.0728468 0 0.100309)
(0.120095 -0.00595563 0 0.0724647 0 0.100424)
(0.121114 -0.00645689 0 0.0721004 0 0.100562)
(0.122177 -0.00698847 0 0.0717574 0 0.100726)
(0.123292 -0.00755264 0 0.0714394 0 0.100919)
(0.124466 -0.00815169 0 0.07115 0 0.101145)
(0.125706 -0.00878787 0 0.0708931 0 0.101409)
(0.127023 -0.00946334 0 0.0706726 0 0.101716)
(0.128424 -0.0101802 0 0.0704922 0 0.102071)
(0.12992 -0.0109402 0 0.0703556 0 0.102478)
(0.131519 -0.0117451 0 0.0702664 0 0.102942)
(0.133231 -0.0125962 0 0.0702277 0 0.103468)
(0.135063 -0.0134942 0 0.0702422 0 0.104061)
(0.137022 -0.0144394 0 0.070312 0 0.104723)
(0.139113 -0.0154314 0 0.0704387 0 0.10546)
(0.141339 -0.016469 0 0.070623 0 0.106271)
(0.143702 -0.0175501 0 0.0708646 0 0.107159)
(0.146198 -0.0186723 0 0.0711623 0 0.108123)
(0.148827 -0.0198322 0 0.0715145 0 0.109162)
(0.15158 -0.0210264 0 0.0719182 0 0.110273)
(0.154452 -0.0222516 0 0.072372 0 0.111454)
(0.157427 -0.0235055 0 0.0728719 0 0.112699)
(0.160508 -0.0247869 0 0.0734233 0 0.114009)
(0.16362 -0.0260866 0 0.0740121 0 0.115356)
(0.166756 -0.0273952 0 0.0746566 0 0.116729)
(0.16925 -0.0284709 0 0.0751991 0 0.117844)
(0.120182 0.000462487 0 0.106975 0 0.120943)
(0.119856 0.000492151 0 0.106374 0 0.120632)
(0.119526 0.000522699 0 0.105777 0 0.120316)
(0.11919 0.000553958 0 0.105185 0 0.119993)
(0.118849 0.000585697 0 0.1046 0 0.119663)
(0.118501 0.00061765 0 0.104022 0 0.119325)
(0.118145 0.000649551 0 0.103454 0 0.11898)
(0.117776 0.000681152 0 0.102899 0 0.118628)
(0.117383 0.00071225 0 0.102369 0 0.118269)
(0.116923 0.000742647 0 0.101903 0 0.117907)
(0.116261 0.000772152 0 0.101627 0 0.117551)
(0.115609 0.000800516 0 0.101342 0 0.117186)
(0.114967 0.000827596 0 0.101049 0 0.116813)
(0.114334 0.000853341 0 0.100748 0 0.116432)
(0.113709 0.000877802 0 0.10044 0 0.116044)
(0.113091 0.000901136 0 0.100126 0 0.115648)
(0.112478 0.000923609 0 0.0998068 0 0.115245)
(0.11187 0.000945583 0 0.099482 0 0.114836)
(0.111267 0.000967508 0 0.0991519 0 0.11442)
(0.110671 0.000989899 0 0.098815 0 0.113998)
(0.110089 0.00101333 0 0.0984643 0 0.113569)
(0.109548 0.00103841 0 0.0980743 0 0.113133)
(0.109144 0.00106572 0 0.097555 0 0.112685)
(0.108732 0.00109584 0 0.0970407 0 0.112234)
(0.108317 0.00112912 0 0.0965292 0 0.111782)
(0.1079 0.00116579 0 0.0960192 0 0.111327)
(0.107482 0.00120592 0 0.0955097 0 0.110872)
(0.107067 0.00124948 0 0.0950001 0 0.110415)
(0.106655 0.00129631 0 0.09449 0 0.109957)
(0.106248 0.00134608 0 0.0939789 0 0.109499)
(0.105848 0.00139839 0 0.0934665 0 0.109041)
(0.105456 0.0014527 0 0.0929526 0 0.108584)
(0.105074 0.00150842 0 0.092437 0 0.108128)
(0.104704 0.00156486 0 0.0919198 0 0.107674)
(0.104348 0.00162129 0 0.0914007 0 0.107223)
(0.104007 0.00167696 0 0.0908799 0 0.106774)
(0.103682 0.0017311 0 0.0903575 0 0.10633)
(0.103376 0.00178294 0 0.0898335 0 0.10589)
(0.103089 0.00183176 0 0.0893082 0 0.105455)
(0.102823 0.00187683 0 0.0887816 0 0.105026)
(0.102579 0.00191747 0 0.0882539 0 0.104603)
(0.102358 0.00195306 0 0.0877253 0 0.104188)
(0.102162 0.001983 0 0.0871959 0 0.103779)
(0.101991 0.00200677 0 0.0866659 0 0.103379)
(0.101847 0.00202388 0 0.0861352 0 0.102988)
(0.10173 0.00203388 0 0.0856041 0 0.102605)
(0.101641 0.00203638 0 0.0850725 0 0.102232)
(0.101581 0.00203104 0 0.0845404 0 0.101869)
(0.10155 0.00201752 0 0.0840079 0 0.101516)
(0.101548 0.00199554 0 0.0834749 0 0.101174)
(0.101577 0.00196482 0 0.0829414 0 0.100843)
(0.101636 0.00192511 0 0.0824072 0 0.100523)
(0.101725 0.00187615 0 0.0818723 0 0.100215)
(0.101846 0.0018177 0 0.0813366 0 0.0999188)
(0.101997 0.0017495 0 0.0808 0 0.0996343)
(0.102178 0.00167131 0 0.0802624 0 0.0993617)
(0.10239 0.00158287 0 0.0797238 0 0.0991013)
(0.102632 0.0014839 0 0.0791839 0 0.0988528)
(0.102904 0.00137412 0 0.0786428 0 0.0986164)
(0.103204 0.00125322 0 0.0781006 0 0.0983919)
(0.103532 0.00112088 0 0.0775571 0 0.0981792)
(0.103887 0.000976751 0 0.0770125 0 0.0979781)
(0.104269 0.000820447 0 0.076467 0 0.0977883)
(0.104676 0.00065155 0 0.0759208 0 0.0976097)
(0.105107 0.000469596 0 0.0753742 0 0.0974421)
(0.105561 0.000274073 0 0.0748276 0 0.0972852)
(0.106038 6.44053e-05 0 0.0742816 0 0.0971389)
(0.106536 -0.000160049 0 0.0737368 0 0.0970032)
(0.107055 -0.000400011 0 0.0731942 0 0.0968781)
(0.107594 -0.000656292 0 0.0726546 0 0.0967637)
(0.108155 -0.000929801 0 0.0721193 0 0.0966605)
(0.108736 -0.00122155 0 0.0715897 0 0.0965689)
(0.109339 -0.00153267 0 0.0710672 0 0.0964898)
(0.109966 -0.00186439 0 0.0705538 0 0.0964242)
(0.110618 -0.00221805 0 0.0700515 0 0.0963734)
(0.111299 -0.00259507 0 0.0695625 0 0.0963392)
(0.112011 -0.00299698 0 0.0690894 0 0.0963234)
(0.112759 -0.00342535 0 0.0686348 0 0.0963286)
(0.113548 -0.00388177 0 0.0682018 0 0.0963575)
(0.114384 -0.0043679 0 0.0677933 0 0.0964132)
(0.115272 -0.00488537 0 0.0674127 0 0.0964993)
(0.116221 -0.00543586 0 0.0670631 0 0.0966195)
(0.117237 -0.00602104 0 0.066748 0 0.0967779)
(0.11833 -0.00664252 0 0.0664706 0 0.096979)
(0.119507 -0.00730186 0 0.0662343 0 0.0972273)
(0.120777 -0.00800045 0 0.0660423 0 0.0975271)
(0.122149 -0.00873946 0 0.0658974 0 0.097883)
(0.123629 -0.00951972 0 0.0658022 0 0.098299)
(0.125224 -0.0103417 0 0.065759 0 0.0987789)
(0.12694 -0.0112052 0 0.0657693 0 0.0993258)
(0.128781 -0.0121097 0 0.0658339 0 0.099942)
(0.130747 -0.0130539 0 0.065953 0 0.100629)
(0.13284 -0.0140361 0 0.0661262 0 0.101387)
(0.135056 -0.0150544 0 0.0663518 0 0.102215)
(0.137393 -0.0161062 0 0.0666296 0 0.103113)
(0.139837 -0.0171901 0 0.0669561 0 0.104075)
(0.142393 -0.0183039 0 0.0673363 0 0.105104)
(0.144992 -0.0194387 0 0.0677564 0 0.106173)
(0.147644 -0.0205853 0 0.0682336 0 0.107282)
(0.149771 -0.0215385 0 0.0686391 0 0.108188)
(0.119824 0.00042376 0 0.107763 0 0.120582)
(0.119493 0.000452353 0 0.107181 0 0.120266)
(0.119158 0.000481835 0 0.106601 0 0.119946)
(0.118818 0.000512063 0 0.106024 0 0.119621)
(0.118473 0.00054285 0 0.105453 0 0.119289)
(0.118124 0.000573975 0 0.104888 0 0.118951)
(0.117768 0.000605207 0 0.104329 0 0.118607)
(0.117405 0.000636328 0 0.103779 0 0.118255)
(0.117031 0.000667144 0 0.10324 0 0.117898)
(0.116636 0.000697495 0 0.102722 0 0.117534)
(0.116179 0.000727247 0 0.102263 0 0.117168)
(0.115535 0.000756285 0 0.10198 0 0.116807)
(0.1149 0.000784457 0 0.10169 0 0.116439)
(0.114272 0.000811718 0 0.101393 0 0.116063)
(0.113653 0.000838122 0 0.101088 0 0.115681)
(0.113041 0.000863825 0 0.100777 0 0.115292)
(0.112435 0.000889077 0 0.10046 0 0.114896)
(0.111835 0.000914215 0 0.100136 0 0.114495)
(0.111242 0.000939652 0 0.0998055 0 0.114087)
(0.110663 0.00096588 0 0.0994611 0 0.113674)
(0.110122 0.000993448 0 0.0990796 0 0.113253)
(0.109701 0.00102295 0 0.0985828 0 0.112822)
(0.109282 0.00105499 0 0.0980819 0 0.112387)
(0.108862 0.00109004 0 0.0975787 0 0.11195)
(0.108442 0.00112848 0 0.097074 0 0.111511)
(0.108022 0.00117058 0 0.0965679 0 0.111069)
(0.107602 0.00121654 0 0.0960604 0 0.110625)
(0.107184 0.00126643 0 0.0955512 0 0.11018)
(0.106767 0.00132023 0 0.0950397 0 0.109733)
(0.106354 0.00137777 0 0.0945258 0 0.109285)
(0.105946 0.00143881 0 0.094009 0 0.108836)
(0.105543 0.001503 0 0.0934889 0 0.108387)
(0.105147 0.00156991 0 0.0929654 0 0.107937)
(0.104759 0.00163904 0 0.0924382 0 0.107488)
(0.104381 0.00170985 0 0.0919071 0 0.107039)
(0.104013 0.00178173 0 0.0913721 0 0.106592)
(0.103657 0.00185407 0 0.090833 0 0.106146)
(0.103314 0.00192624 0 0.0902898 0 0.105702)
(0.102985 0.00199762 0 0.0897426 0 0.10526)
(0.102671 0.00206757 0 0.0891915 0 0.104821)
(0.102373 0.0021355 0 0.0886365 0 0.104386)
(0.102092 0.0022008 0 0.0880776 0 0.103954)
(0.101829 0.00226293 0 0.0875151 0 0.103527)
(0.101584 0.00232135 0 0.086949 0 0.103104)
(0.101359 0.00237556 0 0.0863793 0 0.102686)
(0.101155 0.00242507 0 0.0858062 0 0.102274)
(0.100971 0.00246946 0 0.0852297 0 0.101868)
(0.100809 0.00250829 0 0.0846499 0 0.101468)
(0.100669 0.00254117 0 0.0840668 0 0.101075)
(0.100552 0.00256773 0 0.0834805 0 0.100688)
(0.100458 0.00258758 0 0.082891 0 0.100309)
(0.100388 0.00260039 0 0.0822982 0 0.0999375)
(0.100341 0.00260578 0 0.0817023 0 0.0995738)
(0.100318 0.00260339 0 0.0811031 0 0.0992181)
(0.10032 0.00259288 0 0.0805008 0 0.0988707)
(0.100345 0.00257386 0 0.0798953 0 0.0985317)
(0.100395 0.00254595 0 0.0792868 0 0.0982013)
(0.100469 0.00250876 0 0.0786753 0 0.0978795)
(0.100566 0.00246188 0 0.0780609 0 0.0975665)
(0.100687 0.00240489 0 0.0774438 0 0.0972623)
(0.100831 0.00233735 0 0.0768241 0 0.0969669)
(0.100998 0.0022588 0 0.0762022 0 0.0966803)
(0.101186 0.00216877 0 0.0755784 0 0.0964024)
(0.101395 0.00206677 0 0.074953 0 0.0961332)
(0.101625 0.00195227 0 0.0743266 0 0.0958726)
(0.101875 0.00182473 0 0.0736996 0 0.0956206)
(0.102144 0.0016836 0 0.0730728 0 0.0953772)
(0.102431 0.00152827 0 0.0724468 0 0.0951423)
(0.102736 0.00135811 0 0.0718224 0 0.0949161)
(0.103058 0.00117245 0 0.0712008 0 0.0946986)
(0.103398 0.000970578 0 0.0705828 0 0.0944901)
(0.103755 0.000751728 0 0.0699698 0 0.094291)
(0.10413 0.00051509 0 0.0693631 0 0.0941017)
(0.104524 0.000259805 0 0.0687642 0 0.0939231)
(0.104937 -1.50328e-05 0 0.0681748 0 0.093756)
(0.105371 -0.000310364 0 0.0675968 0 0.0936015)
(0.105829 -0.000627163 0 0.0670321 0 0.093461)
(0.106313 -0.000966423 0 0.066483 0 0.0933362)
(0.106827 -0.00132916 0 0.0659519 0 0.0932291)
(0.107374 -0.0017164 0 0.0654411 0 0.0931419)
(0.10796 -0.0021292 0 0.0649534 0 0.0930774)
(0.10859 -0.00256867 0 0.0644913 0 0.0930385)
(0.10927 -0.00303596 0 0.0640578 0 0.0930284)
(0.110007 -0.00353227 0 0.0636558 0 0.0930507)
(0.110808 -0.00405883 0 0.0632881 0 0.0931094)
(0.11168 -0.00461688 0 0.0629577 0 0.0932083)
(0.112632 -0.00520761 0 0.0626674 0 0.0933516)
(0.113671 -0.00583212 0 0.06242 0 0.0935434)
(0.114805 -0.0064913 0 0.0622181 0 0.0937876)
(0.116039 -0.00718587 0 0.0620636 0 0.094088)
(0.11738 -0.00791617 0 0.0619584 0 0.0944478)
(0.118832 -0.00868226 0 0.0619037 0 0.0948697)
(0.120398 -0.00948373 0 0.0619002 0 0.0953556)
(0.122079 -0.01032 0 0.0619476 0 0.0959063)
(0.123875 -0.01119 0 0.0620467 0 0.0965229)
(0.125778 -0.0120929 0 0.0621952 0 0.097202)
(0.127793 -0.013027 0 0.0623979 0 0.0979468)
(0.129863 -0.0139843 0 0.0626423 0 0.0987355)
(0.132013 -0.0149579 0 0.0629466 0 0.0995744)
(0.133758 -0.0157802 0 0.0632109 0 0.100269)
(0.119512 0.000383649 0 0.108437 0 0.120256)
(0.119175 0.000410688 0 0.107869 0 0.119936)
(0.118835 0.000438599 0 0.107304 0 0.119611)
(0.11849 0.00046727 0 0.106741 0 0.119282)
(0.118142 0.000496547 0 0.106182 0 0.118947)
(0.117789 0.000526251 0 0.105628 0 0.118608)
(0.117431 0.00055619 0 0.105079 0 0.118262)
(0.117068 0.000586181 0 0.104536 0 0.11791)
(0.116699 0.000616048 0 0.103999 0 0.117552)
(0.116321 0.000645641 0 0.103473 0 0.117189)
(0.115922 0.000674857 0 0.102965 0 0.11682)
(0.115469 0.000703629 0 0.10251 0 0.116449)
(0.114839 0.000731919 0 0.102221 0 0.116083)
(0.114218 0.00075967 0 0.101925 0 0.11571)
(0.113608 0.000786928 0 0.101619 0 0.115331)
(0.113004 0.000813827 0 0.101306 0 0.114946)
(0.112407 0.000840594 0 0.100986 0 0.114555)
(0.111818 0.000867539 0 0.10066 0 0.114158)
(0.111241 0.000895049 0 0.10032 0 0.113756)
(0.110703 0.00092358 0 0.099943 0 0.113347)
(0.110288 0.000953642 0 0.0994472 0 0.112928)
(0.10987 0.000985822 0 0.0989513 0 0.112506)
(0.109449 0.00102059 0 0.0984546 0 0.112082)
(0.109028 0.00105839 0 0.0979566 0 0.111655)
(0.108606 0.00109959 0 0.097457 0 0.111227)
(0.108183 0.00114451 0 0.0969555 0 0.110796)
(0.107761 0.00119337 0 0.0964517 0 0.110363)
(0.10734 0.00124629 0 0.0959452 0 0.109928)
(0.106921 0.00130333 0 0.0954357 0 0.109492)
(0.106504 0.00136441 0 0.0949226 0 0.109054)
(0.106092 0.0014294 0 0.0944057 0 0.108616)
(0.105684 0.00149806 0 0.0938843 0 0.108176)
(0.105281 0.00157008 0 0.0933584 0 0.107735)
(0.104885 0.00164509 0 0.0928274 0 0.107293)
(0.104496 0.00172267 0 0.0922912 0 0.106852)
(0.104116 0.00180234 0 0.0917496 0 0.10641)
(0.103744 0.00188362 0 0.0912024 0 0.105969)
(0.103383 0.00196599 0 0.0906495 0 0.105528)
(0.103032 0.00204891 0 0.0900908 0 0.105088)
(0.102693 0.00213185 0 0.0895263 0 0.10465)
(0.102366 0.00221429 0 0.088956 0 0.104212)
(0.102053 0.00229571 0 0.08838 0 0.103777)
(0.101753 0.00237558 0 0.0877982 0 0.103344)
(0.101468 0.00245341 0 0.0872107 0 0.102913)
(0.101197 0.00252872 0 0.0866175 0 0.102486)
(0.100943 0.00260105 0 0.0860188 0 0.102061)
(0.100705 0.00266993 0 0.0854146 0 0.10164)
(0.100484 0.00273494 0 0.084805 0 0.101223)
(0.10028 0.00279565 0 0.0841899 0 0.10081)
(0.100094 0.00285164 0 0.0835696 0 0.100401)
(0.0999262 0.00290251 0 0.082944 0 0.0999969)
(0.099777 0.00294784 0 0.0823131 0 0.0995977)
(0.0996468 0.00298723 0 0.0816772 0 0.0992038)
(0.0995357 0.00302025 0 0.0810362 0 0.0988152)
(0.0994439 0.00304649 0 0.0803902 0 0.0984322)
(0.0993714 0.00306551 0 0.0797394 0 0.098055)
(0.0993184 0.00307687 0 0.0790838 0 0.0976837)
(0.0992848 0.00308012 0 0.0784238 0 0.0973185)
(0.0992703 0.0030748 0 0.0777594 0 0.0969595)
(0.0992748 0.00306042 0 0.0770909 0 0.0966067)
(0.099298 0.0030365 0 0.0764187 0 0.0962603)
(0.0993395 0.00300253 0 0.075743 0 0.0959202)
(0.0993987 0.00295801 0 0.0750644 0 0.0955866)
(0.0994752 0.00290242 0 0.0743832 0 0.0952593)
(0.0995684 0.00283522 0 0.0737 0 0.0949385)
(0.0996777 0.00275589 0 0.0730155 0 0.094624)
(0.0998023 0.0026639 0 0.0723302 0 0.0943159)
(0.0999417 0.00255868 0 0.0716451 0 0.0940142)
(0.100095 0.0024397 0 0.0709608 0 0.093719)
(0.100263 0.00230639 0 0.0702783 0 0.0934302)
(0.100443 0.00215819 0 0.0695986 0 0.0931481)
(0.100637 0.00199453 0 0.0689229 0 0.0928729)
(0.100843 0.00181484 0 0.0682523 0 0.0926047)
(0.101063 0.00161853 0 0.067588 0 0.0923442)
(0.101297 0.00140504 0 0.0669316 0 0.0920918)
(0.101544 0.00117381 0 0.0662845 0 0.0918482)
(0.101808 0.000924285 0 0.0656484 0 0.0916143)
(0.102088 0.000655946 0 0.0650251 0 0.0913912)
(0.102388 0.000368287 0 0.0644164 0 0.0911803)
(0.10271 6.08156e-05 0 0.0638243 0 0.090983)
(0.103057 -0.000266966 0 0.0632508 0 0.0908013)
(0.103433 -0.000615587 0 0.0626982 0 0.0906372)
(0.103843 -0.000985631 0 0.0621686 0 0.0904933)
(0.104291 -0.00137776 0 0.0616645 0 0.0903721)
(0.104783 -0.0017927 0 0.0611883 0 0.0902768)
(0.105326 -0.00223127 0 0.0607424 0 0.0902105)
(0.105926 -0.00269438 0 0.0603295 0 0.0901767)
(0.106589 -0.00318297 0 0.059952 0 0.0901791)
(0.107323 -0.00369802 0 0.0596124 0 0.0902213)
(0.108133 -0.0042405 0 0.0593132 0 0.0903072)
(0.109028 -0.00481131 0 0.0590563 0 0.0904402)
(0.110013 -0.00541129 0 0.0588436 0 0.0906237)
(0.111092 -0.00604104 0 0.0586768 0 0.0908608)
(0.11227 -0.00670116 0 0.0585565 0 0.0911535)
(0.11355 -0.00739171 0 0.0584846 0 0.0915044)
(0.114927 -0.00811289 0 0.0584599 0 0.0919119)
(0.116411 -0.00886381 0 0.0584877 0 0.0923808)
(0.117951 -0.00963822 0 0.058557 0 0.0928932)
(0.119594 -0.0104325 0 0.0586878 0 0.0934636)
(0.120944 -0.0111159 0 0.0588073 0 0.0939429)
(0.11924 0.000345447 0 0.10902 0 0.119966)
(0.118898 0.000370652 0 0.108466 0 0.11964)
(0.118552 0.000396705 0 0.107913 0 0.119311)
(0.118204 0.000423512 0 0.107362 0 0.118978)
(0.117851 0.000450948 0 0.106814 0 0.11864)
(0.117495 0.000478868 0 0.106269 0 0.118297)
(0.117135 0.000507123 0 0.105729 0 0.117949)
(0.11677 0.000535555 0 0.105193 0 0.117596)
(0.116401 0.000564015 0 0.104662 0 0.117237)
(0.116026 0.000592371 0 0.104137 0 0.116873)
(0.115642 0.000620527 0 0.10362 0 0.116504)
(0.115241 0.000648439 0 0.10312 0 0.116131)
(0.11479 0.00067611 0 0.102668 0 0.115755)
(0.114177 0.000703576 0 0.102369 0 0.115383)
(0.113589 0.000730867 0 0.102046 0 0.115005)
(0.113 0.000758094 0 0.101724 0 0.114621)
(0.112415 0.000785452 0 0.101397 0 0.114232)
(0.111841 0.000813216 0 0.10106 0 0.113838)
(0.111303 0.000841745 0 0.100687 0 0.113438)
(0.110892 0.000871472 0 0.100193 0 0.113029)
(0.110476 0.000902884 0 0.0996994 0 0.112617)
(0.110057 0.000936415 0 0.0992065 0 0.112203)
(0.109635 0.000972515 0 0.0987133 0 0.111787)
(0.109211 0.00101159 0 0.0982193 0 0.111369)
(0.108786 0.00105401 0 0.0977237 0 0.110949)
(0.108361 0.00110007 0 0.0972261 0 0.110528)
(0.107937 0.00115001 0 0.0967257 0 0.110104)
(0.107513 0.00120397 0 0.0962221 0 0.109679)
(0.107092 0.00126203 0 0.0957149 0 0.109252)
(0.106673 0.00132419 0 0.0952034 0 0.108824)
(0.106258 0.00139036 0 0.0946873 0 0.108394)
(0.105847 0.00146037 0 0.0941661 0 0.107963)
(0.105441 0.00153401 0 0.0936394 0 0.107531)
(0.105041 0.00161098 0 0.0931069 0 0.107099)
(0.104648 0.00169095 0 0.0925683 0 0.106665)
(0.104261 0.00177354 0 0.0920232 0 0.106231)
(0.103883 0.00185834 0 0.0914716 0 0.105797)
(0.103512 0.00194493 0 0.0909131 0 0.105363)
(0.103151 0.00203286 0 0.0903478 0 0.104928)
(0.1028 0.00212166 0 0.0897754 0 0.104494)
(0.102459 0.00221089 0 0.089196 0 0.104061)
(0.102129 0.00230008 0 0.0886095 0 0.103628)
(0.10181 0.00238877 0 0.0880158 0 0.103197)
(0.101503 0.0024765 0 0.0874151 0 0.102766)
(0.101208 0.00256284 0 0.0868073 0 0.102338)
(0.100927 0.00264734 0 0.0861924 0 0.101911)
(0.100659 0.00272956 0 0.0855705 0 0.101485)
(0.100404 0.00280908 0 0.0849417 0 0.101063)
(0.100164 0.00288547 0 0.084306 0 0.100642)
(0.0999389 0.00295832 0 0.0836635 0 0.100224)
(0.0997285 0.00302719 0 0.0830142 0 0.0998098)
(0.0995334 0.00309167 0 0.0823583 0 0.0993982)
(0.0993538 0.00315131 0 0.0816959 0 0.0989901)
(0.09919 0.00320568 0 0.081027 0 0.0985855)
(0.0990422 0.00325434 0 0.0803518 0 0.0981846)
(0.0989103 0.00329682 0 0.0796705 0 0.0977877)
(0.0987945 0.00333265 0 0.0789832 0 0.0973949)
(0.0986947 0.00336136 0 0.0782902 0 0.0970062)
(0.0986107 0.00338245 0 0.0775918 0 0.0966219)
(0.0985425 0.00339543 0 0.0768882 0 0.096242)
(0.0984896 0.00339978 0 0.0761799 0 0.0958666)
(0.0984517 0.003395 0 0.0754672 0 0.0954957)
(0.0984285 0.00338056 0 0.0747506 0 0.0951293)
(0.0984193 0.00335595 0 0.0740306 0 0.0947676)
(0.0984237 0.00332065 0 0.0733078 0 0.0944104)
(0.0984409 0.00327413 0 0.0725829 0 0.0940577)
(0.0984705 0.00321591 0 0.0718565 0 0.0937096)
(0.0985116 0.00314548 0 0.0711293 0 0.093366)
(0.0985637 0.00306235 0 0.0704024 0 0.093027)
(0.098626 0.00296606 0 0.0696764 0 0.0926924)
(0.098698 0.00285615 0 0.0689523 0 0.0923624)
(0.0987793 0.00273219 0 0.0682312 0 0.0920371)
(0.0988693 0.00259378 0 0.0675141 0 0.0917165)
(0.0989679 0.00244054 0 0.0668022 0 0.0914008)
(0.0990749 0.00227215 0 0.0660967 0 0.0910904)
(0.0991907 0.00208833 0 0.0653988 0 0.0907856)
(0.0993155 0.00188885 0 0.0647099 0 0.0904868)
(0.0994501 0.00167354 0 0.0640315 0 0.0901948)
(0.0995956 0.0014423 0 0.0633651 0 0.0899104)
(0.0997535 0.00119507 0 0.0627122 0 0.0896344)
(0.0999258 0.000931827 0 0.0620744 0 0.0893682)
(0.100115 0.000652554 0 0.0614535 0 0.0891131)
(0.100324 0.000357203 0 0.0608511 0 0.0888707)
(0.100556 4.56766e-05 0 0.0602691 0 0.0886429)
(0.100815 -0.000282202 0 0.0597095 0 0.0884319)
(0.101105 -0.000626708 0 0.0591742 0 0.0882401)
(0.101432 -0.000988234 0 0.0586653 0 0.08807)
(0.101801 -0.00136731 0 0.0581849 0 0.0879245)
(0.102216 -0.00176459 0 0.0577351 0 0.0878068)
(0.102685 -0.00218089 0 0.0573181 0 0.08772)
(0.103213 -0.00261713 0 0.0569361 0 0.0876674)
(0.103807 -0.00307435 0 0.0565908 0 0.0876523)
(0.104471 -0.0035536 0 0.0562843 0 0.0876781)
(0.105211 -0.0040561 0 0.0560179 0 0.0877474)
(0.106032 -0.00458269 0 0.0557941 0 0.0878635)
(0.106933 -0.00513437 0 0.0556124 0 0.0880266)
(0.107925 -0.00571113 0 0.0554785 0 0.0882425)
(0.108968 -0.00630853 0 0.0553832 0 0.0884968)
(0.110122 -0.00692609 0 0.0553485 0 0.0888115)
(0.111074 -0.00746682 0 0.0553245 0 0.0890771)
(0.119003 0.000309942 0 0.109527 0 0.119709)
(0.118655 0.000333205 0 0.108984 0 0.119378)
(0.118305 0.000357275 0 0.108441 0 0.119044)
(0.117953 0.000382078 0 0.1079 0 0.118706)
(0.117596 0.000407517 0 0.107361 0 0.118365)
(0.117237 0.000433481 0 0.106824 0 0.118019)
(0.116874 0.000459844 0 0.106291 0 0.117669)
(0.116507 0.000486481 0 0.105762 0 0.117314)
(0.116136 0.000513267 0 0.105236 0 0.116954)
(0.115761 0.000540094 0 0.104715 0 0.116589)
(0.11538 0.000566879 0 0.104198 0 0.116219)
(0.114993 0.000593575 0 0.103689 0 0.115845)
(0.11459 0.000620194 0 0.103194 0 0.115466)
(0.114153 0.0006468 0 0.102732 0 0.115085)
(0.113682 0.000673477 0 0.102301 0 0.114701)
(0.113073 0.000700369 0 0.102 0 0.11432)
(0.112494 0.000727631 0 0.101671 0 0.113933)
(0.111946 0.000755508 0 0.101311 0 0.11354)
(0.111526 0.000784353 0 0.100827 0 0.113139)
(0.111103 0.000814528 0 0.100343 0 0.112736)
(0.110677 0.0008464 0 0.0998596 0 0.11233)
(0.110249 0.000880377 0 0.0993747 0 0.111924)
(0.10982 0.000916867 0 0.0988881 0 0.111515)
(0.10939 0.000956248 0 0.0983992 0 0.111104)
(0.108961 0.000998858 0 0.0979077 0 0.110692)
(0.108533 0.00104498 0 0.0974131 0 0.110278)
(0.108105 0.00109485 0 0.096915 0 0.109862)
(0.10768 0.00114862 0 0.0964129 0 0.109445)
(0.107257 0.00120638 0 0.0959065 0 0.109026)
(0.106838 0.00126816 0 0.0953953 0 0.108606)
(0.106421 0.0013339 0 0.0948788 0 0.108184)
(0.10601 0.00140349 0 0.0943567 0 0.107762)
(0.105603 0.00147675 0 0.0938286 0 0.107338)
(0.105202 0.00155346 0 0.0932942 0 0.106913)
(0.104807 0.00163334 0 0.092753 0 0.106488)
(0.104418 0.00171607 0 0.0922049 0 0.106062)
(0.104037 0.00180131 0 0.0916496 0 0.105635)
(0.103663 0.0018887 0 0.0910868 0 0.105208)
(0.103298 0.00197785 0 0.0905164 0 0.104781)
(0.102942 0.00206836 0 0.0899383 0 0.104354)
(0.102594 0.00215983 0 0.0893524 0 0.103927)
(0.102256 0.00225185 0 0.0887585 0 0.1035)
(0.101929 0.00234401 0 0.0881566 0 0.103073)
(0.101611 0.00243589 0 0.0875467 0 0.102647)
(0.101305 0.00252709 0 0.0869288 0 0.102222)
(0.10101 0.0026172 0 0.0863028 0 0.101797)
(0.100726 0.0027058 0 0.0856689 0 0.101374)
(0.100455 0.0027925 0 0.085027 0 0.100952)
(0.100195 0.00287688 0 0.0843772 0 0.100532)
(0.0999487 0.00295852 0 0.0837195 0 0.100113)
(0.099715 0.00303702 0 0.0830541 0 0.099696)
(0.0994944 0.00311195 0 0.082381 0 0.0992811)
(0.0992872 0.00318287 0 0.0817004 0 0.0988685)
(0.0990935 0.00324935 0 0.0810123 0 0.0984583)
(0.0989134 0.00331092 0 0.080317 0 0.0980507)
(0.0987471 0.00336713 0 0.0796146 0 0.0976457)
(0.0985945 0.0034175 0 0.0789053 0 0.0972435)
(0.0984556 0.00346154 0 0.0781895 0 0.0968443)
(0.0983303 0.00349877 0 0.0774675 0 0.0964481)
(0.0982182 0.00352867 0 0.0767395 0 0.096055)
(0.0981193 0.00355073 0 0.076006 0 0.0956651)
(0.098033 0.00356444 0 0.0752674 0 0.0952783)
(0.097959 0.00356929 0 0.0745242 0 0.0948948)
(0.0978968 0.00356477 0 0.0737771 0 0.0945146)
(0.0978458 0.00355037 0 0.0730265 0 0.0941375)
(0.0978053 0.0035256 0 0.0722731 0 0.0937636)
(0.0977748 0.00348998 0 0.0715177 0 0.0933929)
(0.0977533 0.00344305 0 0.070761 0 0.0930252)
(0.0977403 0.00338437 0 0.0700039 0 0.0926605)
(0.0977349 0.00331353 0 0.0692471 0 0.0922988)
(0.0977365 0.00323016 0 0.0684916 0 0.09194)
(0.0977443 0.00313392 0 0.0677383 0 0.0915841)
(0.0977577 0.00302451 0 0.0669882 0 0.091231)
(0.0977762 0.00290172 0 0.0662424 0 0.0908809)
(0.0977993 0.00276536 0 0.0655018 0 0.0905337)
(0.0978268 0.00261535 0 0.0647677 0 0.0901896)
(0.0978585 0.00245169 0 0.0640412 0 0.0898489)
(0.0978946 0.00227446 0 0.0633235 0 0.0895118)
(0.0979355 0.00208384 0 0.0626158 0 0.0891788)
(0.0979817 0.00188009 0 0.0619193 0 0.0888504)
(0.0980344 0.00166354 0 0.0612354 0 0.0885273)
(0.0980947 0.00143458 0 0.0605654 0 0.0882103)
(0.0981644 0.0011936 0 0.0599107 0 0.0879005)
(0.0982456 0.000940981 0 0.0592726 0 0.087599)
(0.0983407 0.000677047 0 0.0586525 0 0.0873072)
(0.0984525 0.000402058 0 0.0580521 0 0.0870267)
(0.0985843 0.000116159 0 0.0574729 0 0.0867593)
(0.0987397 -0.000180647 0 0.0569165 0 0.0865071)
(0.0989226 -0.000488528 0 0.0563847 0 0.0862722)
(0.0991375 -0.000807854 0 0.055879 0 0.0860572)
(0.099389 -0.0011392 0 0.0554014 0 0.0858645)
(0.0996821 -0.00148337 0 0.0549535 0 0.085697)
(0.100022 -0.00184135 0 0.0545371 0 0.0855576)
(0.100413 -0.00221437 0 0.0541537 0 0.0854488)
(0.100861 -0.00260353 0 0.0538056 0 0.0853742)
(0.101366 -0.00301009 0 0.0534931 0 0.0853343)
(0.101941 -0.00343457 0 0.0532218 0 0.0853357)
(0.102551 -0.00387388 0 0.0529835 0 0.0853664)
(0.103269 -0.00432998 0 0.0528018 0 0.0854537)
(0.103848 -0.00473357 0 0.0526441 0 0.08552)
(0.118796 0.000277845 0 0.109969 0 0.119481)
(0.118444 0.00029916 0 0.109435 0 0.119146)
(0.11809 0.000321237 0 0.108901 0 0.118808)
(0.117734 0.000344021 0 0.108368 0 0.118467)
(0.117374 0.000367436 0 0.107837 0 0.118122)
(0.117012 0.000391394 0 0.107307 0 0.117773)
(0.116646 0.000415793 0 0.10678 0 0.11742)
(0.116277 0.000440534 0 0.106256 0 0.117063)
(0.115905 0.000465517 0 0.105735 0 0.116702)
(0.115528 0.000490657 0 0.105217 0 0.116336)
(0.115148 0.000515885 0 0.104703 0 0.115965)
(0.114764 0.000541157 0 0.104193 0 0.11559)
(0.114373 0.000566477 0 0.103688 0 0.115211)
(0.113972 0.000591903 0 0.103193 0 0.114828)
(0.113557 0.000617544 0 0.102711 0 0.114442)
(0.113112 0.000643566 0 0.102256 0 0.114054)
(0.11265 0.000670169 0 0.101816 0 0.113663)
(0.112181 0.000697659 0 0.101379 0 0.113271)
(0.111726 0.000726254 0 0.100926 0 0.112876)
(0.111279 0.000756242 0 0.100463 0 0.11248)
(0.110837 0.000787959 0 0.0999922 0 0.112081)
(0.110399 0.000821766 0 0.0995149 0 0.11168)
(0.109964 0.000858019 0 0.0990325 0 0.111277)
(0.109531 0.000897057 0 0.0985455 0 0.110873)
(0.1091 0.000939189 0 0.0980542 0 0.110467)
(0.10867 0.000984681 0 0.0975587 0 0.110059)
(0.108243 0.00103375 0 0.0970587 0 0.10965)
(0.107819 0.00108655 0 0.0965543 0 0.10924)
(0.107397 0.00114317 0 0.0960449 0 0.108828)
(0.106979 0.00120367 0 0.0955304 0 0.108415)
(0.106565 0.001268 0 0.0950103 0 0.108)
(0.106155 0.00133609 0 0.0944844 0 0.107585)
(0.10575 0.00140779 0 0.0939522 0 0.107168)
(0.10535 0.00148292 0 0.0934133 0 0.106751)
(0.104956 0.00156124 0 0.0928676 0 0.106333)
(0.104569 0.00164249 0 0.0923146 0 0.105914)
(0.104189 0.00172637 0 0.0917541 0 0.105495)
(0.103815 0.00181256 0 0.0911859 0 0.105075)
(0.10345 0.00190073 0 0.0906098 0 0.104655)
(0.103093 0.00199051 0 0.0900255 0 0.104235)
(0.102744 0.00208155 0 0.089433 0 0.103814)
(0.102404 0.00217349 0 0.0888321 0 0.103394)
(0.102074 0.00226595 0 0.0882228 0 0.102973)
(0.101753 0.00235855 0 0.0876049 0 0.102553)
(0.101442 0.00245092 0 0.0869784 0 0.102133)
(0.101141 0.00254267 0 0.0863433 0 0.101714)
(0.10085 0.00263344 0 0.0856996 0 0.101296)
(0.100571 0.00272283 0 0.0850474 0 0.100878)
(0.100303 0.00281045 0 0.0843865 0 0.100461)
(0.100046 0.00289591 0 0.0837172 0 0.100046)
(0.0998006 0.00297881 0 0.0830395 0 0.0996313)
(0.0995671 0.00305873 0 0.0823534 0 0.0992183)
(0.0993455 0.00313526 0 0.0816591 0 0.0988068)
(0.0991361 0.00320797 0 0.0809567 0 0.098397)
(0.0989388 0.00327639 0 0.0802465 0 0.097989)
(0.0987538 0.00334009 0 0.0795285 0 0.0975829)
(0.0985809 0.00339859 0 0.0788032 0 0.0971788)
(0.0984202 0.00345141 0 0.0780707 0 0.0967768)
(0.0982715 0.00349806 0 0.0773313 0 0.096377)
(0.0981345 0.00353804 0 0.0765856 0 0.0959794)
(0.098009 0.00357085 0 0.0758338 0 0.0955841)
(0.0978946 0.00359599 0 0.0750764 0 0.0951911)
(0.0977909 0.00361295 0 0.0743141 0 0.0948004)
(0.0976973 0.00362123 0 0.0735473 0 0.094412)
(0.0976132 0.00362034 0 0.0727766 0 0.0940258)
(0.0975381 0.0036098 0 0.0720029 0 0.0936418)
(0.0974711 0.00358916 0 0.0712266 0 0.0932599)
(0.0974115 0.00355798 0 0.0704487 0 0.09288)
(0.0973586 0.00351586 0 0.0696699 0 0.0925021)
(0.0973114 0.00346242 0 0.0688911 0 0.0921259)
(0.0972693 0.00339732 0 0.0681132 0 0.0917514)
(0.0972312 0.00332031 0 0.0673369 0 0.0913785)
(0.0971966 0.00323114 0 0.0665633 0 0.091007)
(0.0971645 0.00312969 0 0.0657934 0 0.090637)
(0.0971345 0.00301586 0 0.0650281 0 0.0902683)
(0.0971058 0.00288971 0 0.0642684 0 0.0899008)
(0.0970781 0.00275135 0 0.0635153 0 0.0895348)
(0.0970511 0.00260104 0 0.0627699 0 0.0891701)
(0.0970247 0.00243914 0 0.0620332 0 0.0888071)
(0.0969989 0.00226613 0 0.0613063 0 0.0884459)
(0.0969741 0.00208258 0 0.0605903 0 0.0880868)
(0.0969508 0.00188915 0 0.0598861 0 0.0877304)
(0.0969299 0.00168655 0 0.0591949 0 0.0873771)
(0.0969124 0.00147552 0 0.0585177 0 0.0870276)
(0.0968996 0.00125678 0 0.0578557 0 0.0866829)
(0.0968931 0.00103103 0 0.05721 0 0.0863438)
(0.0968948 0.00079886 0 0.0565818 0 0.0860114)
(0.0969068 0.000560762 0 0.0559723 0 0.0856872)
(0.0969317 0.000317063 0 0.0553827 0 0.0853724)
(0.0969721 6.78856e-05 0 0.0548144 0 0.0850687)
(0.0970313 -0.000186868 0 0.0542687 0 0.0847781)
(0.0971125 -0.000447574 0 0.0537469 0 0.0845024)
(0.0972198 -0.000714814 0 0.0532504 0 0.0842439)
(0.0973561 -0.000989508 0 0.0527805 0 0.0840047)
(0.0975272 -0.00127252 0 0.0523393 0 0.0837876)
(0.0977316 -0.00156496 0 0.0519267 0 0.0835932)
(0.0979844 -0.00186735 0 0.0515484 0 0.083428)
(0.0982518 -0.00217732 0 0.0511963 0 0.0832811)
(0.0986163 -0.00249827 0 0.050895 0 0.0831835)
(0.0988746 -0.00278144 0 0.0506231 0 0.0830791)
(0.118617 0.000248785 0 0.110351 0 0.119283)
(0.118262 0.000268195 0 0.109824 0 0.118944)
(0.117904 0.000288325 0 0.109298 0 0.118602)
(0.117545 0.00030913 0 0.108772 0 0.118258)
(0.117183 0.000330551 0 0.108246 0 0.11791)
(0.116818 0.000352519 0 0.107722 0 0.117559)
(0.116451 0.000374955 0 0.1072 0 0.117203)
(0.11608 0.000397782 0 0.106679 0 0.116845)
(0.115706 0.000420923 0 0.106162 0 0.116482)
(0.115329 0.000444312 0 0.105646 0 0.116115)
(0.114948 0.000467897 0 0.105134 0 0.115744)
(0.114564 0.000491651 0 0.104624 0 0.115369)
(0.114176 0.000515575 0 0.104117 0 0.11499)
(0.113784 0.000539722 0 0.103614 0 0.114607)
(0.113386 0.0005642 0 0.103115 0 0.114222)
(0.112981 0.000589232 0 0.10262 0 0.113835)
(0.112568 0.000615007 0 0.102129 0 0.113446)
(0.112148 0.000641724 0 0.101643 0 0.113057)
(0.111725 0.000669623 0 0.101156 0 0.112665)
(0.1113 0.000698977 0 0.100669 0 0.112273)
(0.110874 0.000730086 0 0.100179 0 0.111878)
(0.110449 0.000763258 0 0.0996874 0 0.111482)
(0.110024 0.000798804 0 0.0991924 0 0.111085)
(0.109599 0.000837025 0 0.0986943 0 0.110685)
(0.109176 0.000878196 0 0.0981928 0 0.110285)
(0.108754 0.00092256 0 0.0976877 0 0.109882)
(0.108333 0.000970318 0 0.0971786 0 0.109479)
(0.107915 0.00102162 0 0.0966653 0 0.109074)
(0.1075 0.00107657 0 0.0961474 0 0.108668)
(0.107087 0.0011352 0 0.0956246 0 0.10826)
(0.106678 0.00119752 0 0.0950963 0 0.107852)
(0.106274 0.00126344 0 0.0945624 0 0.107443)
(0.105873 0.00133287 0 0.0940223 0 0.107033)
(0.105478 0.00140564 0 0.0934757 0 0.106622)
(0.105089 0.00148155 0 0.0929223 0 0.10621)
(0.104706 0.00156038 0 0.0923617 0 0.105798)
(0.104329 0.00164186 0 0.0917937 0 0.105385)
(0.103959 0.0017257 0 0.0912179 0 0.104972)
(0.103597 0.00181162 0 0.0906341 0 0.104559)
(0.103242 0.00189928 0 0.0900422 0 0.104145)
(0.102895 0.00198837 0 0.0894419 0 0.103731)
(0.102557 0.00207854 0 0.0888331 0 0.103317)
(0.102227 0.00216947 0 0.0882156 0 0.102903)
(0.101907 0.00226079 0 0.0875894 0 0.10249)
(0.101596 0.00235217 0 0.0869543 0 0.102076)
(0.101294 0.00244326 0 0.0863103 0 0.101663)
(0.101003 0.00253369 0 0.0856575 0 0.101251)
(0.100721 0.0026231 0 0.0849957 0 0.100839)
(0.10045 0.00271113 0 0.084325 0 0.100427)
(0.10019 0.00279741 0 0.0836454 0 0.100017)
(0.0999401 0.00288154 0 0.0829571 0 0.0996071)
(0.0997014 0.00296315 0 0.08226 0 0.0991986)
(0.0994738 0.00304182 0 0.0815543 0 0.0987912)
(0.0992573 0.00311713 0 0.0808402 0 0.0983851)
(0.0990521 0.00318866 0 0.0801177 0 0.0979803)
(0.0988581 0.00325596 0 0.0793873 0 0.0975769)
(0.0986753 0.00331859 0 0.078649 0 0.0971751)
(0.0985037 0.00337607 0 0.0779033 0 0.0967749)
(0.0983429 0.00342792 0 0.0771503 0 0.0963763)
(0.0981929 0.00347367 0 0.0763907 0 0.0959793)
(0.0980533 0.00351283 0 0.0756247 0 0.0955841)
(0.0979237 0.0035449 0 0.0748529 0 0.0951906)
(0.0978036 0.00356938 0 0.0740758 0 0.0947987)
(0.0976927 0.00358581 0 0.073294 0 0.0944085)
(0.0975901 0.00359369 0 0.0725081 0 0.0940198)
(0.0974953 0.00359256 0 0.0717188 0 0.0936326)
(0.0974075 0.00358198 0 0.070927 0 0.0932468)
(0.0973259 0.00356153 0 0.0701332 0 0.0928622)
(0.0972497 0.00353083 0 0.0693383 0 0.0924788)
(0.0971781 0.00348951 0 0.0685432 0 0.0920963)
(0.09711 0.00343727 0 0.0677487 0 0.0917146)
(0.0970448 0.00337387 0 0.0669556 0 0.0913335)
(0.0969813 0.00329913 0 0.0661649 0 0.0909529)
(0.0969189 0.00321293 0 0.0653775 0 0.0905726)
(0.0968568 0.00311526 0 0.0645944 0 0.0901924)
(0.0967941 0.00300622 0 0.0638163 0 0.0898123)
(0.0967303 0.00288601 0 0.0630444 0 0.0894321)
(0.0966648 0.00275498 0 0.0622794 0 0.0890518)
(0.0965972 0.0026136 0 0.0615224 0 0.0886713)
(0.0965274 0.00246247 0 0.0607742 0 0.0882908)
(0.0964551 0.00230233 0 0.0600358 0 0.0879104)
(0.0963804 0.002134 0 0.0593081 0 0.0875301)
(0.0963037 0.0019584 0 0.0585918 0 0.0871504)
(0.0962252 0.00177653 0 0.057888 0 0.0867715)
(0.0961455 0.00158937 0 0.0571974 0 0.0863939)
(0.0960654 0.00139792 0 0.0565211 0 0.0860181)
(0.0959857 0.00120312 0 0.0558598 0 0.0856447)
(0.0959076 0.00100585 0 0.0552145 0 0.0852746)
(0.0958321 0.000806809 0 0.0545861 0 0.0849085)
(0.095761 0.000606553 0 0.0539756 0 0.0845474)
(0.0956958 0.000405415 0 0.0533839 0 0.0841926)
(0.0956386 0.000203468 0 0.0528119 0 0.0838452)
(0.0955918 5.66476e-07 0 0.0522607 0 0.0835068)
(0.0955572 -0.000203749 0 0.0517311 0 0.0831787)
(0.0955391 -0.000409952 0 0.0512249 0 0.0828633)
(0.0955352 -0.000618702 0 0.0507418 0 0.0825605)
(0.0955603 -0.0008303 0 0.0502867 0 0.0822765)
(0.0955808 -0.00104255 0 0.0498516 0 0.0820003)
(0.0956857 -0.00125943 0 0.0494612 0 0.0817655)
(0.0956971 -0.00144635 0 0.0491005 0 0.0815286)
(0.118466 0.000222674 0 0.110672 0 0.119114)
(0.118109 0.000240264 0 0.110152 0 0.118772)
(0.117749 0.00025853 0 0.109631 0 0.118428)
(0.117387 0.000277438 0 0.109109 0 0.118081)
(0.117023 0.000296942 0 0.108588 0 0.117731)
(0.116657 0.000316988 0 0.108068 0 0.117377)
(0.116288 0.00033752 0 0.107549 0 0.117021)
(0.115916 0.000358476 0 0.107031 0 0.116661)
(0.115541 0.000379802 0 0.106515 0 0.116297)
(0.115164 0.00040145 0 0.106001 0 0.115929)
(0.114783 0.000423388 0 0.105489 0 0.115558)
(0.1144 0.000445611 0 0.104978 0 0.115184)
(0.114014 0.000468137 0 0.104468 0 0.114807)
(0.113627 0.00049107 0 0.103957 0 0.114427)
(0.113238 0.000514513 0 0.103445 0 0.114046)
(0.112846 0.000538572 0 0.102933 0 0.113663)
(0.112451 0.000563398 0 0.102421 0 0.113279)
(0.112053 0.00058919 0 0.101909 0 0.112893)
(0.111652 0.000616183 0 0.101398 0 0.112506)
(0.111247 0.000644632 0 0.100887 0 0.112117)
(0.110841 0.000674805 0 0.100375 0 0.111727)
(0.110432 0.000706981 0 0.099863 0 0.111335)
(0.110023 0.000741438 0 0.0993493 0 0.110942)
(0.109613 0.000778449 0 0.0988337 0 0.110548)
(0.109202 0.000818264 0 0.098316 0 0.110151)
(0.108792 0.000861105 0 0.0977956 0 0.109754)
(0.108383 0.000907157 0 0.0972721 0 0.109355)
(0.107975 0.000956564 0 0.0967451 0 0.108955)
(0.10757 0.00100942 0 0.0962142 0 0.108554)
(0.107167 0.00106579 0 0.0956788 0 0.108152)
(0.106766 0.00112565 0 0.0951385 0 0.107749)
(0.10637 0.00118897 0 0.0945929 0 0.107346)
(0.105978 0.00125565 0 0.0940416 0 0.106941)
(0.10559 0.00132556 0 0.0934842 0 0.106536)
(0.105207 0.00139853 0 0.0929202 0 0.10613)
(0.104831 0.00147435 0 0.0923493 0 0.105723)
(0.10446 0.0015528 0 0.0917711 0 0.105316)
(0.104096 0.00163361 0 0.0911855 0 0.104909)
(0.103739 0.00171652 0 0.090592 0 0.104502)
(0.103389 0.00180124 0 0.0899904 0 0.104094)
(0.103046 0.00188748 0 0.0893806 0 0.103687)
(0.102712 0.00197492 0 0.0887623 0 0.103279)
(0.102386 0.00206325 0 0.0881353 0 0.102871)
(0.102069 0.00215215 0 0.0874996 0 0.102464)
(0.101761 0.0022413 0 0.0868551 0 0.102056)
(0.101462 0.00233037 0 0.0862015 0 0.10165)
(0.101172 0.00241903 0 0.085539 0 0.101243)
(0.100893 0.00250694 0 0.0848674 0 0.100837)
(0.100623 0.00259374 0 0.0841867 0 0.100432)
(0.100363 0.0026791 0 0.0834971 0 0.100027)
(0.100113 0.00276264 0 0.0827984 0 0.0996234)
(0.0998739 0.002844 0 0.0820909 0 0.0992204)
(0.0996452 0.00292278 0 0.0813746 0 0.0988184)
(0.0994271 0.0029986 0 0.0806496 0 0.0984175)
(0.0992196 0.00307103 0 0.0799162 0 0.0980177)
(0.0990228 0.00313966 0 0.0791745 0 0.097619)
(0.0988365 0.00320406 0 0.0784249 0 0.0972216)
(0.0986606 0.00326377 0 0.0776676 0 0.0968255)
(0.098495 0.00331834 0 0.076903 0 0.0964307)
(0.0983393 0.0033673 0 0.0761315 0 0.0960372)
(0.0981934 0.00341017 0 0.0753535 0 0.095645)
(0.0980568 0.00344649 0 0.0745696 0 0.0952541)
(0.097929 0.00347577 0 0.0737803 0 0.0948645)
(0.0978095 0.00349755 0 0.0729861 0 0.0944761)
(0.0976976 0.00351135 0 0.0721879 0 0.0940887)
(0.0975928 0.00351672 0 0.0713862 0 0.0937024)
(0.0974941 0.00351324 0 0.0705817 0 0.0933169)
(0.0974009 0.00350048 0 0.0697753 0 0.0929321)
(0.0973123 0.00347808 0 0.0689678 0 0.0925478)
(0.0972273 0.00344567 0 0.0681599 0 0.0921638)
(0.097145 0.00340298 0 0.0673526 0 0.09178)
(0.0970646 0.00334976 0 0.0665467 0 0.0913961)
(0.096985 0.00328584 0 0.065743 0 0.091012)
(0.0969054 0.00321112 0 0.0649425 0 0.0906273)
(0.096825 0.00312563 0 0.064146 0 0.090242)
(0.0967429 0.00302948 0 0.0633544 0 0.0898557)
(0.0966584 0.00292291 0 0.0625686 0 0.0894685)
(0.0965707 0.0028063 0 0.0617895 0 0.08908)
(0.0964795 0.00268019 0 0.0610179 0 0.0886902)
(0.0963842 0.00254525 0 0.0602547 0 0.0882991)
(0.0962845 0.00240229 0 0.0595006 0 0.0879067)
(0.0961802 0.00225226 0 0.0587564 0 0.0875129)
(0.0960712 0.00209619 0 0.0580229 0 0.0871179)
(0.0959575 0.00193522 0 0.0573009 0 0.0867217)
(0.0958391 0.00177054 0 0.0565911 0 0.0863247)
(0.0957161 0.00160333 0 0.0558943 0 0.085927)
(0.0955889 0.00143479 0 0.055211 0 0.085529)
(0.0954578 0.00126601 0 0.0545422 0 0.0851311)
(0.0953231 0.00109802 0 0.0538884 0 0.0847337)
(0.0951854 0.000931652 0 0.0532503 0 0.0843373)
(0.0950455 0.000767577 0 0.0526287 0 0.0839426)
(0.0949042 0.000606222 0 0.0520242 0 0.0835504)
(0.0947628 0.000447814 0 0.0514375 0 0.0831616)
(0.0946219 0.000292302 0 0.0508692 0 0.0827769)
(0.0944846 0.000139607 0 0.0503205 0 0.082398)
(0.0943477 -1.04798e-05 0 0.0497908 0 0.0820244)
(0.0942253 -0.000157935 0 0.0492846 0 0.0816617)
(0.0940831 -0.000300546 0 0.0487935 0 0.0812987)
(0.0940149 -0.000442371 0 0.0483419 0 0.0809704)
(0.0938544 -0.000558259 0 0.047918 0 0.0806397)
(0.118349 0.000198887 0 0.110926 0 0.11898)
(0.11799 0.00021474 0 0.110409 0 0.118636)
(0.117629 0.000231224 0 0.109891 0 0.11829)
(0.117266 0.000248318 0 0.109373 0 0.117941)
(0.1169 0.000265987 0 0.108855 0 0.117589)
(0.116533 0.000284193 0 0.108337 0 0.117235)
(0.116163 0.000302894 0 0.107819 0 0.116878)
(0.115791 0.000322051 0 0.107302 0 0.116517)
(0.115417 0.000341629 0 0.106786 0 0.116153)
(0.11504 0.0003616 0 0.10627 0 0.115787)
(0.114662 0.000381951 0 0.105755 0 0.115417)
(0.114282 0.000402763 0 0.105237 0 0.115046)
(0.113901 0.000424034 0 0.104717 0 0.114674)
(0.11352 0.0004458 0 0.104196 0 0.114299)
(0.113137 0.000468131 0 0.103673 0 0.113923)
(0.112752 0.000491126 0 0.103149 0 0.113545)
(0.112366 0.000514923 0 0.102623 0 0.113166)
(0.111978 0.0005397 0 0.102097 0 0.112784)
(0.111588 0.000565664 0 0.101571 0 0.112402)
(0.111196 0.000593046 0 0.101043 0 0.112017)
(0.110802 0.000622093 0 0.100515 0 0.111631)
(0.110407 0.000653058 0 0.0999852 0 0.111244)
(0.110011 0.000686199 0 0.0994547 0 0.110855)
(0.109613 0.000721763 0 0.0989225 0 0.110465)
(0.109216 0.000759977 0 0.0983885 0 0.110073)
(0.108818 0.000801048 0 0.0978523 0 0.10968)
(0.10842 0.000845148 0 0.0973133 0 0.109286)
(0.108024 0.000892414 0 0.0967713 0 0.108891)
(0.107629 0.000942942 0 0.0962256 0 0.108494)
(0.107237 0.000996784 0 0.095676 0 0.108097)
(0.106847 0.00105395 0 0.0951219 0 0.107699)
(0.10646 0.00111441 0 0.0945628 0 0.1073)
(0.106076 0.00117808 0 0.0939984 0 0.1069)
(0.105698 0.00124485 0 0.0934282 0 0.1065)
(0.105323 0.00131458 0 0.0928517 0 0.106099)
(0.104955 0.00138708 0 0.0922687 0 0.105698)
(0.104591 0.00146216 0 0.0916787 0 0.105296)
(0.104234 0.00153957 0 0.0910815 0 0.104895)
(0.103884 0.00161908 0 0.0904766 0 0.104493)
(0.10354 0.00170043 0 0.0898639 0 0.10409)
(0.103204 0.00178335 0 0.089243 0 0.103688)
(0.102876 0.00186754 0 0.0886139 0 0.103286)
(0.102556 0.00195273 0 0.0879762 0 0.102884)
(0.102244 0.0020386 0 0.0873298 0 0.102483)
(0.10194 0.00212488 0 0.0866747 0 0.102081)
(0.101646 0.00221124 0 0.0860106 0 0.10168)
(0.10136 0.00229737 0 0.0853376 0 0.10128)
(0.101084 0.00238296 0 0.0846555 0 0.10088)
(0.100818 0.00246768 0 0.0839644 0 0.100481)
(0.100561 0.0025512 0 0.0832642 0 0.100082)
(0.100314 0.00263318 0 0.082555 0 0.0996839)
(0.100077 0.00271326 0 0.0818369 0 0.0992869)
(0.0998507 0.00279108 0 0.0811099 0 0.0988906)
(0.0996343 0.00286627 0 0.0803743 0 0.0984954)
(0.0994281 0.00293843 0 0.0796301 0 0.0981012)
(0.0992321 0.00300717 0 0.0788776 0 0.097708)
(0.0990462 0.00307207 0 0.0781171 0 0.0973159)
(0.0988703 0.0031327 0 0.077349 0 0.0969249)
(0.0987042 0.00318864 0 0.0765734 0 0.096535)
(0.0985476 0.00323942 0 0.075791 0 0.0961462)
(0.0984003 0.0032846 0 0.0750021 0 0.0957585)
(0.0982617 0.00332373 0 0.0742072 0 0.0953718)
(0.0981315 0.00335633 0 0.0734069 0 0.0949861)
(0.098009 0.00338195 0 0.0726019 0 0.0946013)
(0.0978937 0.00340014 0 0.0717927 0 0.0942172)
(0.0977848 0.00341045 0 0.0709802 0 0.0938337)
(0.0976816 0.00341246 0 0.070165 0 0.0934507)
(0.0975833 0.00340575 0 0.0693478 0 0.0930679)
(0.097489 0.00338996 0 0.0685296 0 0.0926852)
(0.0973977 0.00336473 0 0.0677112 0 0.0923024)
(0.0973086 0.00332977 0 0.0668933 0 0.0919192)
(0.0972207 0.00328484 0 0.0660769 0 0.0915355)
(0.097133 0.00322976 0 0.0652627 0 0.0911508)
(0.0970447 0.00316443 0 0.0644518 0 0.0907651)
(0.0969549 0.00308888 0 0.0636449 0 0.0903781)
(0.0968627 0.00300321 0 0.0628429 0 0.0899895)
(0.0967673 0.00290768 0 0.0620466 0 0.0895992)
(0.0966681 0.00280269 0 0.0612569 0 0.0892069)
(0.0965645 0.00268877 0 0.0604745 0 0.0888126)
(0.0964558 0.00256665 0 0.0597003 0 0.088416)
(0.0963418 0.00243716 0 0.0589349 0 0.0880172)
(0.096222 0.0023013 0 0.0581792 0 0.0876161)
(0.0960961 0.00216021 0 0.0574338 0 0.0872126)
(0.095964 0.00201509 0 0.0566994 0 0.0868069)
(0.0958253 0.00186725 0 0.0559766 0 0.0863989)
(0.0956799 0.00171801 0 0.0552661 0 0.0859888)
(0.0955277 0.00156871 0 0.0545685 0 0.0855766)
(0.0953684 0.00142061 0 0.0538843 0 0.0851627)
(0.095202 0.00127492 0 0.0532143 0 0.084747)
(0.0950284 0.00113269 0 0.0525589 0 0.08433)
(0.0948475 0.000994816 0 0.0519186 0 0.083912)
(0.0946596 0.000861962 0 0.0512938 0 0.0834932)
(0.094465 0.000734623 0 0.0506852 0 0.0830742)
(0.0942636 0.000613054 0 0.050093 0 0.0826555)
(0.0940575 0.000497479 0 0.0495181 0 0.0822381)
(0.0938429 0.000388045 0 0.0489597 0 0.0818212)
(0.0936332 0.000285055 0 0.0484217 0 0.0814101)
(0.093393 0.000190716 0 0.0478954 0 0.0809927)
(0.0932203 0.000101124 0 0.0474051 0 0.0806058)
(0.0929515 3.49701e-05 0 0.0469397 0 0.080214)
(0.118274 0.000177335 0 0.111089 0 0.118891)
(0.117914 0.000191535 0 0.110575 0 0.118546)
(0.117553 0.00020633 0 0.110058 0 0.118198)
(0.117189 0.000221706 0 0.109541 0 0.117849)
(0.116824 0.000237641 0 0.109023 0 0.117497)
(0.116457 0.000254111 0 0.108504 0 0.117142)
(0.116088 0.000271087 0 0.107986 0 0.116785)
(0.115718 0.000288561 0 0.107466 0 0.116426)
(0.115346 0.000306546 0 0.106944 0 0.116065)
(0.114974 0.000325017 0 0.106419 0 0.115703)
(0.1146 0.000343961 0 0.105894 0 0.115338)
(0.114226 0.000363388 0 0.105367 0 0.114972)
(0.11385 0.00038332 0 0.104838 0 0.114603)
(0.113473 0.0004038 0 0.104307 0 0.114233)
(0.113095 0.000424894 0 0.103775 0 0.113862)
(0.112716 0.000446698 0 0.103241 0 0.113488)
(0.112335 0.000469336 0 0.102705 0 0.113113)
(0.111953 0.000492965 0 0.102169 0 0.112736)
(0.11157 0.000517771 0 0.101631 0 0.112358)
(0.111186 0.000543959 0 0.101091 0 0.111977)
(0.110801 0.000571752 0 0.100551 0 0.111596)
(0.110414 0.000601378 0 0.100008 0 0.111213)
(0.110027 0.000633069 0 0.0994646 0 0.110828)
(0.109639 0.000667049 0 0.0989189 0 0.110442)
(0.109251 0.000703527 0 0.0983711 0 0.110054)
(0.108863 0.000742692 0 0.097821 0 0.109666)
(0.108476 0.000784706 0 0.0972681 0 0.109276)
(0.10809 0.000829698 0 0.0967121 0 0.108885)
(0.107705 0.000877765 0 0.0961526 0 0.108493)
(0.107322 0.000928961 0 0.0955892 0 0.1081)
(0.106941 0.000983305 0 0.0950214 0 0.107706)
(0.106564 0.00104077 0 0.0944489 0 0.107312)
(0.10619 0.00110131 0 0.0938711 0 0.106917)
(0.10582 0.00116482 0 0.0932878 0 0.106521)
(0.105454 0.00123118 0 0.0926984 0 0.106125)
(0.105094 0.00130022 0 0.0921026 0 0.105728)
(0.104739 0.00137178 0 0.0915001 0 0.105332)
(0.104389 0.00144564 0 0.0908905 0 0.104935)
(0.104046 0.00152159 0 0.0902734 0 0.104538)
(0.10371 0.00159938 0 0.0896487 0 0.104141)
(0.103381 0.00167878 0 0.089016 0 0.103744)
(0.103059 0.00175951 0 0.0883751 0 0.103347)
(0.102745 0.00184132 0 0.0877258 0 0.10295)
(0.10244 0.00192393 0 0.087068 0 0.102554)
(0.102142 0.00200705 0 0.0864015 0 0.102158)
(0.101853 0.00209041 0 0.0857261 0 0.101762)
(0.101573 0.00217371 0 0.0850418 0 0.101367)
(0.101302 0.00225666 0 0.0843486 0 0.100973)
(0.101041 0.00233894 0 0.0836463 0 0.100579)
(0.100789 0.00242026 0 0.0829351 0 0.100186)
(0.100547 0.00250028 0 0.0822148 0 0.0997939)
(0.100314 0.00257868 0 0.0814857 0 0.0994025)
(0.100091 0.00265511 0 0.0807477 0 0.099012)
(0.0998787 0.00272922 0 0.0800011 0 0.0986223)
(0.099676 0.00280065 0 0.079246 0 0.0982336)
(0.0994832 0.00286901 0 0.0784827 0 0.097846)
(0.0993001 0.00293392 0 0.0777114 0 0.0974593)
(0.0991268 0.00299497 0 0.0769324 0 0.0970736)
(0.098963 0.00305174 0 0.0761462 0 0.0966888)
(0.0988083 0.00310382 0 0.0753531 0 0.0963051)
(0.0986626 0.00315076 0 0.0745536 0 0.0959222)
(0.0985253 0.00319213 0 0.0737482 0 0.0955401)
(0.0983959 0.00322749 0 0.0729376 0 0.0951588)
(0.098274 0.00325638 0 0.0721223 0 0.0947781)
(0.0981588 0.00327837 0 0.071303 0 0.0943979)
(0.0980497 0.00329302 0 0.0704805 0 0.094018)
(0.0979459 0.0032999 0 0.0696554 0 0.0936383)
(0.0978465 0.00329862 0 0.0688286 0 0.0932584)
(0.0977508 0.00328878 0 0.0680009 0 0.0928783)
(0.0976577 0.00327003 0 0.0671731 0 0.0924977)
(0.0975663 0.00324208 0 0.066346 0 0.0921163)
(0.0974758 0.00320466 0 0.0655206 0 0.0917338)
(0.0973851 0.00315758 0 0.0646977 0 0.0913501)
(0.0972934 0.00310074 0 0.0638781 0 0.0909647)
(0.0971997 0.00303413 0 0.0630627 0 0.0905776)
(0.0971034 0.00295785 0 0.0622523 0 0.0901885)
(0.0970035 0.00287214 0 0.0614477 0 0.0897971)
(0.0968994 0.00277738 0 0.0606498 0 0.0894032)
(0.0967906 0.00267413 0 0.0598593 0 0.0890067)
(0.0966764 0.00256308 0 0.0590769 0 0.0886075)
(0.0965564 0.00244511 0 0.0583034 0 0.0882054)
(0.0964303 0.00232124 0 0.0575395 0 0.0878004)
(0.0962976 0.00219263 0 0.0567857 0 0.0873925)
(0.096158 0.00206056 0 0.0560428 0 0.0869816)
(0.0960111 0.0019264 0 0.0553114 0 0.0865677)
(0.0958566 0.00179155 0 0.054592 0 0.0861508)
(0.0956941 0.00165744 0 0.0538853 0 0.085731)
(0.0955231 0.00152547 0 0.0531917 0 0.0853084)
(0.0953431 0.00139694 0 0.0525117 0 0.0848828)
(0.0951537 0.00127306 0 0.0518459 0 0.0844546)
(0.0949544 0.00115484 0 0.0511946 0 0.0840237)
(0.0947449 0.00104313 0 0.0505582 0 0.0835903)
(0.094525 0.000938579 0 0.049937 0 0.0831547)
(0.094294 0.000841657 0 0.0493313 0 0.0827169)
(0.0940535 0.000752789 0 0.0487416 0 0.082278)
(0.0937991 0.000672356 0 0.048167 0 0.0818366)
(0.0935441 0.000600857 0 0.0476109 0 0.0813979)
(0.0932519 0.000540384 0 0.0470645 0 0.0809493)
(0.0930242 0.000487254 0 0.0465519 0 0.0805287)
(0.092695 0.000455438 0 0.0460619 0 0.0801006)
(0.11826 0.000157212 0 0.111131 0 0.118863)
(0.117901 0.000169852 0 0.110616 0 0.118518)
(0.11754 0.000183064 0 0.110098 0 0.118172)
(0.117178 0.000196843 0 0.109578 0 0.117823)
(0.116815 0.00021118 0 0.109056 0 0.117473)
(0.116451 0.000226062 0 0.108533 0 0.117121)
(0.116085 0.000241473 0 0.108007 0 0.116767)
(0.115719 0.000257401 0 0.10748 0 0.116411)
(0.115351 0.000273838 0 0.106951 0 0.116053)
(0.114982 0.000290778 0 0.10642 0 0.115694)
(0.114612 0.000308225 0 0.105888 0 0.115333)
(0.114241 0.00032619 0 0.105353 0 0.11497)
(0.113869 0.000344704 0 0.104816 0 0.114605)
(0.113496 0.00036381 0 0.104278 0 0.114238)
(0.113122 0.000383577 0 0.103738 0 0.11387)
(0.112746 0.000404094 0 0.103196 0 0.1135)
(0.11237 0.000425476 0 0.102653 0 0.113129)
(0.111993 0.000447865 0 0.102108 0 0.112756)
(0.111616 0.000471426 0 0.101561 0 0.112381)
(0.111237 0.000496342 0 0.101012 0 0.112005)
(0.110857 0.000522809 0 0.100461 0 0.111627)
(0.110477 0.000551034 0 0.0999089 0 0.111247)
(0.110097 0.000581224 0 0.0993544 0 0.110867)
(0.109716 0.000613579 0 0.0987977 0 0.110484)
(0.109336 0.000648292 0 0.0982385 0 0.110101)
(0.108955 0.000685537 0 0.0976766 0 0.109716)
(0.108576 0.000725464 0 0.0971117 0 0.10933)
(0.108198 0.000768196 0 0.0965434 0 0.108943)
(0.107821 0.000813827 0 0.0959715 0 0.108555)
(0.107446 0.000862414 0 0.0953955 0 0.108167)
(0.107074 0.000913983 0 0.0948151 0 0.107777)
(0.106705 0.000968523 0 0.0942299 0 0.107387)
(0.106339 0.00102599 0 0.0936394 0 0.106996)
(0.105977 0.00108631 0 0.0930433 0 0.106604)
(0.10562 0.00114936 0 0.0924413 0 0.106213)
(0.105267 0.00121503 0 0.0918328 0 0.105821)
(0.10492 0.00128315 0 0.0912177 0 0.105428)
(0.104579 0.00135353 0 0.0905956 0 0.105036)
(0.104243 0.00142599 0 0.0899661 0 0.104643)
(0.103914 0.00150031 0 0.089329 0 0.104251)
(0.103592 0.00157626 0 0.088684 0 0.103859)
(0.103277 0.00165361 0 0.0880309 0 0.103467)
(0.10297 0.00173211 0 0.0873695 0 0.103075)
(0.102671 0.00181151 0 0.0866996 0 0.102683)
(0.10238 0.00189155 0 0.0860211 0 0.102292)
(0.102097 0.00197198 0 0.0853338 0 0.101902)
(0.101824 0.0020525 0 0.0846377 0 0.101512)
(0.101559 0.00213286 0 0.0839327 0 0.101122)
(0.101303 0.00221277 0 0.0832187 0 0.100734)
(0.101057 0.00229193 0 0.0824957 0 0.100346)
(0.10082 0.00237005 0 0.0817639 0 0.0999588)
(0.100593 0.00244681 0 0.0810232 0 0.0995725)
(0.100375 0.0025219 0 0.0802737 0 0.0991872)
(0.100167 0.00259499 0 0.0795157 0 0.0988027)
(0.0999695 0.00266573 0 0.0787493 0 0.0984191)
(0.0997812 0.00273377 0 0.0779747 0 0.0980364)
(0.0996026 0.00279874 0 0.0771922 0 0.0976547)
(0.0994334 0.00286026 0 0.0764022 0 0.0972739)
(0.0992735 0.00291794 0 0.0756051 0 0.0968939)
(0.0991226 0.00297138 0 0.0748012 0 0.0965148)
(0.0989803 0.00302016 0 0.0739911 0 0.0961364)
(0.0988461 0.00306385 0 0.0731753 0 0.0957586)
(0.0987197 0.00310204 0 0.0723544 0 0.0953814)
(0.0986005 0.0031343 0 0.071529 0 0.0950046)
(0.0984877 0.00316018 0 0.0706999 0 0.094628)
(0.0983807 0.00317926 0 0.0698677 0 0.0942515)
(0.0982786 0.00319112 0 0.0690333 0 0.0938748)
(0.0981808 0.00319534 0 0.0681974 0 0.0934977)
(0.0980863 0.00319155 0 0.0673608 0 0.0931201)
(0.0979941 0.00317937 0 0.0665245 0 0.0927415)
(0.0979035 0.00315849 0 0.0656892 0 0.0923619)
(0.0978134 0.00312862 0 0.0648558 0 0.0919808)
(0.0977229 0.00308955 0 0.0640251 0 0.091598)
(0.0976311 0.00304115 0 0.0631981 0 0.0912134)
(0.0975373 0.00298339 0 0.0623756 0 0.0908265)
(0.0974406 0.00291633 0 0.0615583 0 0.0904372)
(0.0973403 0.0028402 0 0.0607472 0 0.0900454)
(0.0972359 0.00275536 0 0.0599429 0 0.0896507)
(0.0971266 0.00266232 0 0.0591462 0 0.089253)
(0.0970121 0.00256179 0 0.0583579 0 0.0888523)
(0.0968919 0.00245463 0 0.0575786 0 0.0884485)
(0.0967656 0.00234188 0 0.056809 0 0.0880414)
(0.0966329 0.00222471 0 0.0560498 0 0.0876312)
(0.0964934 0.00210445 0 0.0553015 0 0.0872176)
(0.0963467 0.0019825 0 0.0545648 0 0.0868008)
(0.0961922 0.00186033 0 0.0538402 0 0.0863806)
(0.0960296 0.00173943 0 0.0531282 0 0.0859572)
(0.095858 0.00162128 0 0.0524294 0 0.0855305)
(0.095677 0.00150727 0 0.0517443 0 0.0851004)
(0.0954856 0.00139869 0 0.0510732 0 0.0846669)
(0.0952833 0.00129665 0 0.0504165 0 0.0842302)
(0.0950692 0.00120209 0 0.0497746 0 0.08379)
(0.094843 0.00111579 0 0.0491476 0 0.0833467)
(0.0946036 0.00103831 0 0.0485357 0 0.0829)
(0.0943522 0.000970233 0 0.0479394 0 0.0824508)
(0.0940841 0.000912062 0 0.0473575 0 0.0819977)
(0.0938126 0.000864419 0 0.0467932 0 0.0815456)
(0.0935 0.000829164 0 0.0462374 0 0.0810816)
(0.0932517 0.000802847 0 0.0457144 0 0.0806449)
(0.092896 0.000795648 0 0.0452122 0 0.080198)
(0.118326 0.000138578 0 0.111007 0 0.118918)
(0.117968 0.000149725 0 0.110489 0 0.118574)
(0.117608 0.000161414 0 0.109969 0 0.118228)
(0.117248 0.000173646 0 0.109446 0 0.117881)
(0.116886 0.000186418 0 0.108921 0 0.117532)
(0.116524 0.000199724 0 0.108394 0 0.117181)
(0.11616 0.000213559 0 0.107865 0 0.116829)
(0.115796 0.000227916 0 0.107333 0 0.116475)
(0.115431 0.000242794 0 0.106799 0 0.116119)
(0.115064 0.000258196 0 0.106263 0 0.115762)
(0.114697 0.000274131 0 0.105725 0 0.115403)
(0.114329 0.000290619 0 0.105184 0 0.115043)
(0.11396 0.000307693 0 0.104642 0 0.114681)
(0.11359 0.000325402 0 0.104097 0 0.114317)
(0.11322 0.000343813 0 0.10355 0 0.113952)
(0.112848 0.00036301 0 0.103002 0 0.113585)
(0.112476 0.000383102 0 0.102451 0 0.113217)
(0.112103 0.000404216 0 0.101898 0 0.112847)
(0.11173 0.000426502 0 0.101343 0 0.112475)
(0.111356 0.000450122 0 0.100786 0 0.112102)
(0.110981 0.000475253 0 0.100227 0 0.111728)
(0.110606 0.00050208 0 0.0996656 0 0.111352)
(0.110231 0.000530788 0 0.0991018 0 0.110975)
(0.109856 0.000561561 0 0.0985353 0 0.110596)
(0.109482 0.000594571 0 0.097966 0 0.110216)
(0.109108 0.000629978 0 0.0973937 0 0.109835)
(0.108735 0.000667921 0 0.0968181 0 0.109453)
(0.108364 0.000708518 0 0.0962388 0 0.10907)
(0.107994 0.000751859 0 0.0956557 0 0.108686)
(0.107627 0.000798003 0 0.0950682 0 0.108301)
(0.107262 0.000846982 0 0.0944761 0 0.107915)
(0.1069 0.000898794 0 0.093879 0 0.107529)
(0.106542 0.000953408 0 0.0932765 0 0.107142)
(0.106187 0.00101076 0 0.0926684 0 0.106755)
(0.105837 0.00107077 0 0.0920541 0 0.106367)
(0.105492 0.00113332 0 0.0914335 0 0.105979)
(0.105152 0.00119826 0 0.090806 0 0.105591)
(0.104818 0.00126545 0 0.0901716 0 0.105202)
(0.104489 0.00133471 0 0.0895297 0 0.104814)
(0.104168 0.00140585 0 0.0888803 0 0.104426)
(0.103853 0.00147867 0 0.0882229 0 0.104038)
(0.103545 0.00155295 0 0.0875575 0 0.10365)
(0.103245 0.00162848 0 0.0868838 0 0.103263)
(0.102952 0.00170501 0 0.0862016 0 0.102876)
(0.102668 0.00178232 0 0.0855108 0 0.102489)
(0.102392 0.00186017 0 0.0848112 0 0.102103)
(0.102125 0.00193829 0 0.0841028 0 0.101717)
(0.101866 0.00201645 0 0.0833856 0 0.101332)
(0.101617 0.00209437 0 0.0826594 0 0.100948)
(0.101377 0.00217179 0 0.0819243 0 0.100565)
(0.101146 0.00224842 0 0.0811804 0 0.100182)
(0.100925 0.00232399 0 0.0804277 0 0.0998005)
(0.100713 0.0023982 0 0.0796664 0 0.0994195)
(0.100511 0.00247074 0 0.0788966 0 0.0990394)
(0.100318 0.00254128 0 0.0781184 0 0.0986601)
(0.100136 0.0026095 0 0.0773323 0 0.0982817)
(0.0999623 0.00267506 0 0.0765384 0 0.0979041)
(0.0997983 0.00273759 0 0.0757371 0 0.0975273)
(0.0996433 0.00279673 0 0.0749288 0 0.0971513)
(0.0994972 0.0028521 0 0.074114 0 0.0967759)
(0.0993595 0.0029033 0 0.0732932 0 0.0964011)
(0.0992298 0.00294993 0 0.0724669 0 0.0960267)
(0.0991076 0.00299159 0 0.0716358 0 0.0956527)
(0.0989924 0.00302784 0 0.0708005 0 0.0952789)
(0.0988834 0.00305827 0 0.0699618 0 0.094905)
(0.09878 0.00308246 0 0.0691203 0 0.094531)
(0.0986814 0.00309998 0 0.0682769 0 0.0941565)
(0.0985868 0.00311041 0 0.0674323 0 0.0937814)
(0.0984952 0.00311336 0 0.0665875 0 0.0934053)
(0.0984059 0.00310845 0 0.0657433 0 0.0930281)
(0.0983179 0.00309534 0 0.0649005 0 0.0926494)
(0.0982304 0.00307371 0 0.0640601 0 0.092269)
(0.0981423 0.00304333 0 0.0632228 0 0.0918866)
(0.098053 0.00300402 0 0.0623895 0 0.091502)
(0.0979616 0.00295572 0 0.0615612 0 0.091115)
(0.0978675 0.00289847 0 0.0607385 0 0.0907253)
(0.0977699 0.00283244 0 0.0599223 0 0.0903327)
(0.0976684 0.00275796 0 0.0591134 0 0.0899372)
(0.0975624 0.00267552 0 0.0583125 0 0.0895386)
(0.0974516 0.00258581 0 0.0575202 0 0.0891368)
(0.0973357 0.00248967 0 0.0567374 0 0.0887318)
(0.0972142 0.00238814 0 0.0559646 0 0.0883236)
(0.0970869 0.00228241 0 0.0552025 0 0.0879122)
(0.0969535 0.00217383 0 0.0544516 0 0.0874976)
(0.0968135 0.00206382 0 0.0537126 0 0.0870798)
(0.0966665 0.00195393 0 0.0529861 0 0.0866588)
(0.0965117 0.00184568 0 0.0522724 0 0.0862346)
(0.0963486 0.00174062 0 0.0515723 0 0.0858072)
(0.0961762 0.00164021 0 0.050886 0 0.0853764)
(0.0959937 0.00154579 0 0.050214 0 0.0849423)
(0.0958002 0.00145856 0 0.0495567 0 0.0845047)
(0.0955946 0.00137952 0 0.0489143 0 0.0840637)
(0.0953764 0.00130951 0 0.0482871 0 0.0836191)
(0.0951442 0.00124918 0 0.0476749 0 0.0831709)
(0.0948993 0.00119918 0 0.0470783 0 0.0827198)
(0.0946365 0.00116008 0 0.0464961 0 0.0822641)
(0.0943695 0.00113259 0 0.0459312 0 0.081809)
(0.0940594 0.00111824 0 0.0453745 0 0.081341)
(0.0938151 0.00111383 0 0.04485 0 0.0809006)
(0.0934573 0.00112616 0 0.0443453 0 0.0804476)
(0.118459 0.000119071 0 0.11075 0 0.119041)
(0.118103 0.000128819 0 0.110227 0 0.118699)
(0.117746 0.000139082 0 0.109703 0 0.118355)
(0.117388 0.000149866 0 0.109175 0 0.11801)
(0.117029 0.000161175 0 0.108646 0 0.117663)
(0.116669 0.000173011 0 0.108114 0 0.117315)
(0.116308 0.000185374 0 0.107579 0 0.116965)
(0.115947 0.000198268 0 0.107042 0 0.116613)
(0.115584 0.000211697 0 0.106503 0 0.11626)
(0.115221 0.000225673 0 0.105961 0 0.115905)
(0.114857 0.000240211 0 0.105417 0 0.115549)
(0.114492 0.000255339 0 0.10487 0 0.115191)
(0.114126 0.000271092 0 0.104321 0 0.114832)
(0.11376 0.000287522 0 0.10377 0 0.114471)
(0.113393 0.000304695 0 0.103217 0 0.114108)
(0.113025 0.000322693 0 0.102661 0 0.113744)
(0.112657 0.000341617 0 0.102102 0 0.113379)
(0.112288 0.000361585 0 0.101542 0 0.113012)
(0.111919 0.000382732 0 0.100979 0 0.112644)
(0.111549 0.000405207 0 0.100414 0 0.112274)
(0.111179 0.000429167 0 0.0998457 0 0.111903)
(0.110809 0.00045478 0 0.0992752 0 0.11153)
(0.11044 0.000482213 0 0.0987019 0 0.111157)
(0.11007 0.000511632 0 0.0981258 0 0.110782)
(0.109701 0.000543194 0 0.0975465 0 0.110405)
(0.109333 0.000577047 0 0.0969638 0 0.110028)
(0.108967 0.000613319 0 0.0963775 0 0.109649)
(0.108602 0.000652122 0 0.0957874 0 0.10927)
(0.108238 0.000693542 0 0.095193 0 0.108889)
(0.107878 0.000737641 0 0.0945941 0 0.108508)
(0.107519 0.000784455 0 0.0939903 0 0.108126)
(0.107164 0.00083399 0 0.0933814 0 0.107743)
(0.106813 0.000886227 0 0.0927669 0 0.10736)
(0.106465 0.00094112 0 0.0921466 0 0.106977)
(0.106122 0.000998597 0 0.09152 0 0.106593)
(0.105784 0.00105856 0 0.0908869 0 0.106208)
(0.105451 0.0011209 0 0.0902469 0 0.105824)
(0.105124 0.00118547 0 0.0895999 0 0.105439)
(0.104802 0.00125213 0 0.0889453 0 0.105055)
(0.104488 0.0013207 0 0.0882831 0 0.10467)
(0.10418 0.00139101 0 0.087613 0 0.104286)
(0.103879 0.00146286 0 0.0869347 0 0.103902)
(0.103585 0.00153606 0 0.0862481 0 0.103518)
(0.103299 0.0016104 0 0.085553 0 0.103135)
(0.103022 0.00168566 0 0.0848493 0 0.102752)
(0.102753 0.00176163 0 0.0841369 0 0.10237)
(0.102492 0.00183807 0 0.0834156 0 0.101988)
(0.10224 0.00191476 0 0.0826855 0 0.101607)
(0.101997 0.00199145 0 0.0819466 0 0.101226)
(0.101763 0.00206789 0 0.0811987 0 0.100846)
(0.101539 0.00214384 0 0.0804421 0 0.100467)
(0.101324 0.00221903 0 0.0796769 0 0.100089)
(0.101118 0.00229318 0 0.078903 0 0.0997111)
(0.100923 0.00236601 0 0.0781208 0 0.0993342)
(0.100736 0.00243723 0 0.0773304 0 0.0989581)
(0.100559 0.00250653 0 0.0765322 0 0.0985827)
(0.100392 0.00257359 0 0.0757264 0 0.098208)
(0.100234 0.00263808 0 0.0749135 0 0.097834)
(0.100084 0.00269965 0 0.0740938 0 0.0974605)
(0.0999435 0.00275795 0 0.0732678 0 0.0970876)
(0.0998112 0.0028126 0 0.0724362 0 0.096715)
(0.0996867 0.00286321 0 0.0715993 0 0.0963426)
(0.0995697 0.00290941 0 0.070758 0 0.0959704)
(0.0994594 0.00295077 0 0.0699129 0 0.0955981)
(0.0993552 0.00298688 0 0.0690647 0 0.0952256)
(0.0992566 0.00301733 0 0.0682142 0 0.0948526)
(0.0991626 0.00304168 0 0.0673623 0 0.0944789)
(0.0990725 0.00305952 0 0.0665096 0 0.0941043)
(0.0989854 0.00307044 0 0.0656572 0 0.0937285)
(0.0989005 0.00307403 0 0.0648059 0 0.0933512)
(0.0988169 0.00306993 0 0.0639566 0 0.0929723)
(0.0987337 0.00305779 0 0.0631102 0 0.0925914)
(0.0986502 0.00303734 0 0.0622675 0 0.0922083)
(0.0985656 0.00300837 0 0.0614294 0 0.0918228)
(0.0984792 0.00297075 0 0.0605968 0 0.0914348)
(0.0983904 0.0029245 0 0.0597704 0 0.0910439)
(0.0982986 0.00286972 0 0.0589511 0 0.0906503)
(0.0982035 0.00280672 0 0.0581396 0 0.0902536)
(0.0981046 0.00273595 0 0.0573366 0 0.089854)
(0.0980017 0.00265806 0 0.0565429 0 0.0894514)
(0.0978947 0.00257389 0 0.0557591 0 0.0890458)
(0.0977832 0.00248445 0 0.0549859 0 0.0886373)
(0.097667 0.00239097 0 0.0542239 0 0.088226)
(0.0975459 0.00229479 0 0.0534736 0 0.087812)
(0.0974196 0.0021974 0 0.0527358 0 0.0873952)
(0.0972874 0.00210036 0 0.0520108 0 0.0869757)
(0.0971488 0.00200529 0 0.0512993 0 0.0865536)
(0.097003 0.00191376 0 0.0506018 0 0.0861288)
(0.096849 0.00182731 0 0.0499187 0 0.0857012)
(0.0966858 0.00174736 0 0.0492503 0 0.0852707)
(0.0965123 0.00167515 0 0.0485971 0 0.0848373)
(0.0963275 0.00161175 0 0.0479593 0 0.0844008)
(0.0961304 0.00155803 0 0.047337 0 0.0839611)
(0.0959197 0.00151471 0 0.0467303 0 0.083518)
(0.0956964 0.00148248 0 0.0461395 0 0.0830722)
(0.0954554 0.00146196 0 0.0455633 0 0.082622)
(0.0952106 0.00145389 0 0.0450046 0 0.0821727)
(0.0949219 0.00145947 0 0.0444541 0 0.0817101)
(0.0947015 0.00147577 0 0.0439362 0 0.0812762)
(0.094361 0.00150619 0 0.0434375 0 0.0808273)
(0.118649 9.93586e-05 0 0.110367 0 0.119224)
(0.118297 0.000107769 0 0.109837 0 0.118885)
(0.117944 0.000116693 0 0.109305 0 0.118545)
(0.11759 0.000126141 0 0.10877 0 0.118202)
(0.117235 0.000136117 0 0.108233 0 0.117859)
(0.116879 0.000146631 0 0.107693 0 0.117514)
(0.116522 0.000157689 0 0.107151 0 0.117167)
(0.116164 0.0001693 0 0.106606 0 0.116818)
(0.115805 0.000181476 0 0.106059 0 0.116468)
(0.115446 0.000194235 0 0.10551 0 0.116117)
(0.115086 0.000207599 0 0.104957 0 0.115764)
(0.114725 0.000221599 0 0.104403 0 0.115409)
(0.114364 0.000236277 0 0.103846 0 0.115053)
(0.114002 0.000251685 0 0.103286 0 0.114696)
(0.113639 0.000267889 0 0.102724 0 0.114337)
(0.113276 0.000284969 0 0.102159 0 0.113977)
(0.112912 0.000303019 0 0.101592 0 0.113615)
(0.112548 0.00032215 0 0.101022 0 0.113251)
(0.112184 0.000342485 0 0.100449 0 0.112886)
(0.111819 0.00036416 0 0.0998741 0 0.11252)
(0.111455 0.000387318 0 0.0992962 0 0.112152)
(0.111091 0.000412109 0 0.0987154 0 0.111783)
(0.110727 0.000438687 0 0.0981316 0 0.111413)
(0.110363 0.000467202 0 0.0975446 0 0.111042)
(0.11 0.000497798 0 0.0969542 0 0.110669)
(0.109639 0.00053061 0 0.0963602 0 0.110295)
(0.109278 0.000565759 0 0.0957623 0 0.10992)
(0.10892 0.00060335 0 0.0951603 0 0.109544)
(0.108563 0.000643466 0 0.0945539 0 0.109167)
(0.108209 0.00068617 0 0.0939428 0 0.10879)
(0.107857 0.000731502 0 0.0933266 0 0.108411)
(0.107509 0.000779476 0 0.092705 0 0.108032)
(0.107165 0.000830081 0 0.0920778 0 0.107652)
(0.106824 0.000883286 0 0.0914445 0 0.107272)
(0.106488 0.000939033 0 0.090805 0 0.106892)
(0.106157 0.000997245 0 0.0901587 0 0.106511)
(0.105831 0.00105782 0 0.0895056 0 0.10613)
(0.10551 0.00112065 0 0.0888452 0 0.105748)
(0.105196 0.0011856 0 0.0881773 0 0.105367)
(0.104888 0.00125253 0 0.0875016 0 0.104986)
(0.104587 0.00132127 0 0.086818 0 0.104604)
(0.104293 0.00139165 0 0.0861263 0 0.104223)
(0.104006 0.00146351 0 0.0854262 0 0.103842)
(0.103728 0.00153666 0 0.0847176 0 0.103462)
(0.103457 0.0016109 0 0.0840004 0 0.103082)
(0.103194 0.00168604 0 0.0832744 0 0.102702)
(0.10294 0.00176187 0 0.0825397 0 0.102323)
(0.102695 0.00183818 0 0.0817962 0 0.101944)
(0.102459 0.00191476 0 0.0810439 0 0.101566)
(0.102232 0.00199137 0 0.0802829 0 0.101188)
(0.102014 0.0020678 0 0.0795132 0 0.100811)
(0.101805 0.00214379 0 0.0787349 0 0.100435)
(0.101606 0.00221911 0 0.0779482 0 0.100059)
(0.101417 0.00229349 0 0.0771533 0 0.0996842)
(0.101237 0.00236667 0 0.0763505 0 0.0993097)
(0.101066 0.00243836 0 0.07554 0 0.0989357)
(0.100905 0.00250827 0 0.0747223 0 0.0985623)
(0.100753 0.00257609 0 0.0738977 0 0.0981893)
(0.10061 0.0026415 0 0.0730667 0 0.0978167)
(0.100475 0.00270417 0 0.0722297 0 0.0974444)
(0.100349 0.00276374 0 0.0713874 0 0.0970723)
(0.100231 0.00281986 0 0.0705404 0 0.0967002)
(0.10012 0.00287214 0 0.0696894 0 0.096328)
(0.100015 0.0029202 0 0.0688351 0 0.0959554)
(0.0999171 0.00296361 0 0.0679782 0 0.0955824)
(0.0998244 0.00300198 0 0.0671195 0 0.0952088)
(0.0997364 0.00303487 0 0.06626 0 0.0948342)
(0.0996524 0.00306185 0 0.0654004 0 0.0944584)
(0.0995715 0.00308249 0 0.0645417 0 0.0940813)
(0.099493 0.00309636 0 0.0636848 0 0.0937026)
(0.099416 0.00310308 0 0.0628306 0 0.093322)
(0.0993398 0.00310225 0 0.0619799 0 0.0929394)
(0.0992636 0.00309357 0 0.0611338 0 0.0925546)
(0.0991868 0.00307676 0 0.060293 0 0.0921674)
(0.0991089 0.00305166 0 0.0594584 0 0.0917776)
(0.0990293 0.00301822 0 0.0586308 0 0.0913853)
(0.0989476 0.00297651 0 0.0578111 0 0.0909904)
(0.0988637 0.00292676 0 0.057 0 0.0905928)
(0.0987772 0.0028694 0 0.0561982 0 0.0901927)
(0.0986882 0.00280504 0 0.0554064 0 0.0897901)
(0.0985965 0.0027345 0 0.0546252 0 0.0893852)
(0.0985021 0.00265881 0 0.0538554 0 0.0889782)
(0.0984048 0.00257918 0 0.0530975 0 0.0885691)
(0.0983046 0.002497 0 0.0523521 0 0.0881582)
(0.0982011 0.0024138 0 0.0516199 0 0.0877456)
(0.0980937 0.0023312 0 0.0509013 0 0.0873314)
(0.0979819 0.00225088 0 0.0501968 0 0.0869155)
(0.0978648 0.00217449 0 0.0495071 0 0.086498)
(0.0977414 0.00210364 0 0.0488324 0 0.0860788)
(0.0976105 0.00203983 0 0.0481733 0 0.0856577)
(0.0974708 0.00198436 0 0.04753 0 0.0852347)
(0.0973211 0.00193835 0 0.0469029 0 0.0848094)
(0.0971603 0.00190273 0 0.046292 0 0.0843818)
(0.0969869 0.00187825 0 0.0456973 0 0.0839516)
(0.0968019 0.00186564 0 0.0451191 0 0.0835194)
(0.0966001 0.00186555 0 0.0445562 0 0.0830834)
(0.0963956 0.00187879 0 0.0440114 0 0.082649)
(0.0961473 0.00190622 0 0.0434753 0 0.0822016)
(0.0959704 0.00194528 0 0.0429725 0 0.0817845)
(0.0956653 0.00199563 0 0.0424888 0 0.0813493)
(0.1189 7.83732e-05 0 0.109873 0 0.119467)
(0.118553 8.57766e-05 0 0.109332 0 0.119133)
(0.118206 9.37104e-05 0 0.108789 0 0.118797)
(0.117857 0.000102191 0 0.108243 0 0.11846)
(0.117507 0.000111231 0 0.107695 0 0.118121)
(0.117157 0.000120845 0 0.107145 0 0.11778)
(0.116805 0.000131047 0 0.106592 0 0.117438)
(0.116453 0.000141851 0 0.106036 0 0.117094)
(0.1161 0.000153278 0 0.105478 0 0.116748)
(0.115746 0.000165349 0 0.104917 0 0.116401)
(0.115392 0.000178093 0 0.104353 0 0.116053)
(0.115036 0.000191546 0 0.103787 0 0.115702)
(0.114681 0.000205751 0 0.103219 0 0.115351)
(0.114324 0.000220762 0 0.102648 0 0.114997)
(0.113968 0.000236646 0 0.102074 0 0.114643)
(0.11361 0.000253478 0 0.101497 0 0.114286)
(0.113253 0.00027135 0 0.100918 0 0.113928)
(0.112895 0.000290362 0 0.100336 0 0.113569)
(0.112537 0.000310628 0 0.0997513 0 0.113208)
(0.112178 0.000332272 0 0.0991636 0 0.112846)
(0.11182 0.000355425 0 0.098573 0 0.112482)
(0.111462 0.000380223 0 0.0979793 0 0.112117)
(0.111105 0.000406805 0 0.0973823 0 0.11175)
(0.110748 0.000435307 0 0.096782 0 0.111382)
(0.110392 0.000465862 0 0.096178 0 0.111013)
(0.110038 0.000498594 0 0.0955703 0 0.110643)
(0.109684 0.000533615 0 0.0949585 0 0.110271)
(0.109333 0.000571024 0 0.0943424 0 0.109899)
(0.108983 0.000610901 0 0.0937217 0 0.109525)
(0.108636 0.000653309 0 0.0930961 0 0.109151)
(0.108292 0.00069829 0 0.0924654 0 0.108775)
(0.107951 0.000745864 0 0.0918292 0 0.108399)
(0.107614 0.000796031 0 0.0911873 0 0.108022)
(0.107281 0.000848768 0 0.0905392 0 0.107645)
(0.106952 0.000904033 0 0.0898848 0 0.107267)
(0.106628 0.000961764 0 0.0892236 0 0.106888)
(0.106309 0.00102188 0 0.0885555 0 0.10651)
(0.105996 0.00108428 0 0.0878801 0 0.106131)
(0.105689 0.00114886 0 0.0871973 0 0.105751)
(0.105388 0.0012155 0 0.0865067 0 0.105372)
(0.105094 0.00128404 0 0.0858081 0 0.104993)
(0.104807 0.00135436 0 0.0851015 0 0.104613)
(0.104528 0.00142629 0 0.0843865 0 0.104234)
(0.104256 0.00149968 0 0.0836631 0 0.103855)
(0.103992 0.00157435 0 0.0829312 0 0.103476)
(0.103736 0.00165012 0 0.0821906 0 0.103098)
(0.103489 0.00172682 0 0.0814414 0 0.102719)
(0.10325 0.00180426 0 0.0806835 0 0.102341)
(0.103021 0.00188225 0 0.079917 0 0.101964)
(0.102801 0.00196058 0 0.0791419 0 0.101587)
(0.10259 0.00203906 0 0.0783583 0 0.10121)
(0.102388 0.00211746 0 0.0775664 0 0.100834)
(0.102196 0.00219557 0 0.0767664 0 0.100458)
(0.102013 0.00227315 0 0.0759585 0 0.100082)
(0.10184 0.00234996 0 0.0751429 0 0.0997074)
(0.101676 0.00242575 0 0.0743201 0 0.0993328)
(0.101521 0.00250026 0 0.0734904 0 0.0989584)
(0.101376 0.0025732 0 0.0726542 0 0.0985844)
(0.10124 0.00264427 0 0.0718121 0 0.0982105)
(0.101112 0.00271318 0 0.0709645 0 0.0978367)
(0.100993 0.00277959 0 0.0701122 0 0.0974628)
(0.100882 0.00284316 0 0.0692558 0 0.0970888)
(0.100778 0.00290354 0 0.0683959 0 0.0967145)
(0.100681 0.00296034 0 0.0675334 0 0.0963398)
(0.10059 0.00301316 0 0.0666691 0 0.0959644)
(0.100506 0.0030616 0 0.0658037 0 0.0955882)
(0.100426 0.00310523 0 0.0649383 0 0.0952109)
(0.100351 0.0031436 0 0.0640737 0 0.0948325)
(0.100279 0.00317627 0 0.0632108 0 0.0944527)
(0.10021 0.00320279 0 0.0623506 0 0.0940713)
(0.100144 0.00322272 0 0.061494 0 0.0936882)
(0.100079 0.00323566 0 0.060642 0 0.0933032)
(0.100015 0.00324122 0 0.0597955 0 0.0929162)
(0.0999511 0.0032391 0 0.0589553 0 0.0925272)
(0.0998875 0.00322908 0 0.0581224 0 0.0921361)
(0.0998237 0.00321103 0 0.0572976 0 0.0917429)
(0.0997595 0.00318498 0 0.0564816 0 0.0913478)
(0.0996948 0.00315111 0 0.0556753 0 0.0909509)
(0.0996297 0.00310981 0 0.0548794 0 0.0905525)
(0.0995642 0.00306166 0 0.0540945 0 0.0901526)
(0.0994985 0.00300747 0 0.0533214 0 0.0897517)
(0.0994327 0.00294826 0 0.0525605 0 0.0893499)
(0.0993668 0.00288528 0 0.0518126 0 0.0889477)
(0.0993009 0.00281994 0 0.0510783 0 0.0885451)
(0.0992345 0.00275384 0 0.050358 0 0.0881425)
(0.0991673 0.00268867 0 0.0496524 0 0.0877399)
(0.0990985 0.00262617 0 0.0489619 0 0.0873373)
(0.0990271 0.00256811 0 0.048287 0 0.0869348)
(0.098952 0.00251618 0 0.0476282 0 0.0865322)
(0.0988717 0.00247194 0 0.0469858 0 0.0861293)
(0.0987849 0.0024368 0 0.0463603 0 0.0857259)
(0.0986898 0.00241192 0 0.0457517 0 0.0853215)
(0.0985853 0.00239828 0 0.0451604 0 0.084916)
(0.0984697 0.00239668 0 0.0445863 0 0.0845091)
(0.0983439 0.00240788 0 0.0440295 0 0.0841011)
(0.0982026 0.00243256 0 0.0434889 0 0.0836903)
(0.0980601 0.00247169 0 0.0429673 0 0.0832822)
(0.097874 0.0025258 0 0.0424556 0 0.0828614)
(0.0977627 0.0025929 0 0.0419784 0 0.0824728)
(0.0975127 0.00266807 0 0.0415204 0 0.0820621)
(0.119216 6.18945e-05 0 0.109229 0 0.119773)
(0.118877 6.88236e-05 0 0.108674 0 0.119445)
(0.118537 7.63623e-05 0 0.108116 0 0.119116)
(0.118196 8.45286e-05 0 0.107555 0 0.118784)
(0.117854 9.33395e-05 0 0.106992 0 0.118451)
(0.117511 0.000102812 0 0.106427 0 0.118116)
(0.117167 0.000112966 0 0.105859 0 0.11778)
(0.116822 0.00012382 0 0.105288 0 0.117441)
(0.116477 0.000135398 0 0.104715 0 0.117101)
(0.11613 0.000147726 0 0.104139 0 0.11676)
(0.115783 0.000160836 0 0.10356 0 0.116416)
(0.115436 0.000174765 0 0.102979 0 0.116071)
(0.115088 0.000189559 0 0.102395 0 0.115725)
(0.114739 0.00020527 0 0.101808 0 0.115376)
(0.11439 0.000221961 0 0.101219 0 0.115026)
(0.11404 0.000239706 0 0.100627 0 0.114674)
(0.11369 0.000258588 0 0.100032 0 0.114321)
(0.11334 0.000278701 0 0.0994337 0 0.113966)
(0.112989 0.000300148 0 0.0988329 0 0.113609)
(0.112639 0.00032304 0 0.0982291 0 0.113251)
(0.112289 0.000347496 0 0.0976223 0 0.112891)
(0.111939 0.000373638 0 0.0970122 0 0.11253)
(0.111589 0.000401592 0 0.0963987 0 0.112167)
(0.111241 0.00043148 0 0.0957817 0 0.111802)
(0.110893 0.000463423 0 0.095161 0 0.111437)
(0.110546 0.000497533 0 0.0945365 0 0.111069)
(0.110201 0.000533915 0 0.0939077 0 0.110701)
(0.109857 0.000572659 0 0.0932746 0 0.110331)
(0.109516 0.000613843 0 0.0926369 0 0.10996)
(0.109177 0.000657528 0 0.0919942 0 0.109588)
(0.108841 0.000703756 0 0.0913464 0 0.109214)
(0.108508 0.000752555 0 0.0906931 0 0.10884)
(0.108179 0.000803929 0 0.090034 0 0.108465)
(0.107854 0.000857866 0 0.0893688 0 0.108089)
(0.107533 0.000914336 0 0.0886973 0 0.107712)
(0.107216 0.00097329 0 0.0880192 0 0.107335)
(0.106905 0.00103467 0 0.0873342 0 0.106957)
(0.1066 0.00109838 0 0.086642 0 0.106579)
(0.1063 0.00116435 0 0.0859425 0 0.1062)
(0.106007 0.00123246 0 0.0852353 0 0.105821)
(0.10572 0.0013026 0 0.0845204 0 0.105442)
(0.10544 0.00137464 0 0.0837974 0 0.105062)
(0.105168 0.00144846 0 0.0830664 0 0.104683)
(0.104903 0.00152391 0 0.0823271 0 0.104303)
(0.104646 0.00160085 0 0.0815796 0 0.103923)
(0.104398 0.00167912 0 0.0808236 0 0.103543)
(0.104158 0.00175858 0 0.0800593 0 0.103164)
(0.103926 0.00183905 0 0.0792866 0 0.102784)
(0.103704 0.00192038 0 0.0785055 0 0.102405)
(0.103491 0.00200238 0 0.0777163 0 0.102026)
(0.103287 0.00208489 0 0.0769189 0 0.101647)
(0.103092 0.00216772 0 0.0761136 0 0.101269)
(0.102907 0.00225066 0 0.0753006 0 0.10089)
(0.102732 0.00233353 0 0.0744802 0 0.100512)
(0.102566 0.00241611 0 0.0736526 0 0.100134)
(0.10241 0.00249817 0 0.0728184 0 0.0997563)
(0.102264 0.00257949 0 0.0719778 0 0.0993786)
(0.102127 0.00265981 0 0.0711314 0 0.0990011)
(0.101999 0.00273888 0 0.0702798 0 0.0986236)
(0.10188 0.0028164 0 0.0694234 0 0.0982461)
(0.10177 0.0028921 0 0.0685631 0 0.0978684)
(0.101668 0.00296564 0 0.0676994 0 0.0974905)
(0.101574 0.0030367 0 0.0668332 0 0.0971123)
(0.101488 0.00310491 0 0.0659652 0 0.0967337)
(0.101409 0.00316989 0 0.0650964 0 0.0963545)
(0.101337 0.00323124 0 0.0642276 0 0.0959745)
(0.10127 0.00328853 0 0.0633598 0 0.0955937)
(0.101209 0.00334132 0 0.0624939 0 0.095212)
(0.101152 0.00338914 0 0.0616309 0 0.0948292)
(0.1011 0.00343154 0 0.0607718 0 0.0944452)
(0.101051 0.00346804 0 0.0599176 0 0.09406)
(0.101005 0.00349819 0 0.0590692 0 0.0936736)
(0.100962 0.00352158 0 0.0582277 0 0.0932859)
(0.100922 0.00353785 0 0.0573939 0 0.0928971)
(0.100884 0.00354671 0 0.0565688 0 0.0925072)
(0.100848 0.003548 0 0.0557532 0 0.0921165)
(0.100815 0.00354167 0 0.054948 0 0.0917253)
(0.100784 0.00352787 0 0.0541538 0 0.0913338)
(0.100756 0.00350692 0 0.0533715 0 0.0909425)
(0.100731 0.00347939 0 0.0526017 0 0.0905517)
(0.10071 0.00344605 0 0.0518451 0 0.090162)
(0.100692 0.00340794 0 0.0511022 0 0.0897737)
(0.100679 0.00336631 0 0.0503737 0 0.0893872)
(0.10067 0.00332262 0 0.0496601 0 0.0890028)
(0.100664 0.00327852 0 0.048962 0 0.0886209)
(0.100662 0.00323576 0 0.0482798 0 0.0882414)
(0.100662 0.00319619 0 0.0476141 0 0.0878644)
(0.100663 0.00316164 0 0.0469653 0 0.0874898)
(0.100663 0.00313393 0 0.0463338 0 0.0871173)
(0.100661 0.00311473 0 0.0457201 0 0.0867464)
(0.100654 0.00310553 0 0.0451243 0 0.0863767)
(0.100642 0.00310757 0 0.0445468 0 0.0860077)
(0.100621 0.0031219 0 0.0439878 0 0.0856389)
(0.100591 0.00314936 0 0.0434471 0 0.0852697)
(0.100552 0.00319081 0 0.042925 0 0.0849006)
(0.100498 0.00324701 0 0.0424203 0 0.0845295)
(0.100444 0.00331918 0 0.0419358 0 0.0841621)
(0.100347 0.0034077 0 0.0414627 0 0.0837823)
(0.100328 0.00351148 0 0.0410257 0 0.0834368)
(0.100155 0.00361976 0 0.0406083 0 0.0830629)
(0.119626 5.74736e-05 0 0.108421 0 0.120161)
(0.119297 6.55058e-05 0 0.107846 0 0.11984)
(0.118967 7.42695e-05 0 0.107268 0 0.119518)
(0.118636 8.37876e-05 0 0.106687 0 0.119194)
(0.118304 9.40811e-05 0 0.106104 0 0.118867)
(0.117971 0.00010517 0 0.105518 0 0.118539)
(0.117637 0.000117077 0 0.104929 0 0.118209)
(0.117302 0.000129823 0 0.104338 0 0.117877)
(0.116967 0.000143434 0 0.103744 0 0.117543)
(0.11663 0.000157936 0 0.103148 0 0.117207)
(0.116293 0.000173363 0 0.102549 0 0.11687)
(0.115955 0.00018975 0 0.101947 0 0.11653)
(0.115617 0.00020714 0 0.101342 0 0.116189)
(0.115278 0.000225585 0 0.100735 0 0.115845)
(0.114938 0.00024514 0 0.100124 0 0.1155)
(0.114598 0.000265872 0 0.0995113 0 0.115153)
(0.114258 0.000287857 0 0.0988954 0 0.114803)
(0.113917 0.000311178 0 0.0982767 0 0.114452)
(0.113576 0.000335925 0 0.0976549 0 0.114099)
(0.113235 0.000362199 0 0.0970301 0 0.113744)
(0.112894 0.000390103 0 0.0964022 0 0.113387)
(0.112554 0.000419745 0 0.0957711 0 0.113029)
(0.112213 0.000451237 0 0.0951365 0 0.112668)
(0.111874 0.000484687 0 0.0944985 0 0.112306)
(0.111535 0.000520203 0 0.0938568 0 0.111942)
(0.111198 0.000557887 0 0.0932112 0 0.111576)
(0.110861 0.000597832 0 0.0925615 0 0.111209)
(0.110527 0.000640124 0 0.0919075 0 0.11084)
(0.110194 0.000684834 0 0.0912489 0 0.11047)
(0.109864 0.00073202 0 0.0905855 0 0.110098)
(0.109537 0.000781729 0 0.0899171 0 0.109725)
(0.109213 0.000833987 0 0.0892434 0 0.10935)
(0.108892 0.000888809 0 0.0885641 0 0.108975)
(0.108575 0.000946189 0 0.0878788 0 0.108598)
(0.108262 0.00100611 0 0.0871875 0 0.10822)
(0.107954 0.00106854 0 0.0864898 0 0.107841)
(0.107651 0.00113342 0 0.0857854 0 0.107462)
(0.107353 0.0012007 0 0.0850742 0 0.107081)
(0.107061 0.00127031 0 0.0843559 0 0.1067)
(0.106775 0.00134216 0 0.0836303 0 0.106319)
(0.106496 0.00141615 0 0.0828973 0 0.105937)
(0.106224 0.00149218 0 0.0821567 0 0.105554)
(0.105959 0.00157016 0 0.0814083 0 0.105171)
(0.105702 0.00164996 0 0.0806522 0 0.104787)
(0.105453 0.00173146 0 0.0798881 0 0.104404)
(0.105211 0.00181454 0 0.0791162 0 0.10402)
(0.104979 0.00189907 0 0.0783363 0 0.103636)
(0.104755 0.00198492 0 0.0775486 0 0.103252)
(0.104541 0.00207195 0 0.0767531 0 0.102868)
(0.104336 0.00216003 0 0.0759499 0 0.102484)
(0.10414 0.002249 0 0.0751393 0 0.1021)
(0.103954 0.00233871 0 0.0743214 0 0.101716)
(0.103778 0.002429 0 0.0734965 0 0.101332)
(0.103611 0.00251971 0 0.0726649 0 0.100948)
(0.103455 0.00261067 0 0.071827 0 0.100565)
(0.103309 0.00270169 0 0.0709831 0 0.100181)
(0.103173 0.00279257 0 0.0701339 0 0.0997981)
(0.103048 0.00288311 0 0.0692797 0 0.0994149)
(0.102932 0.00297309 0 0.0684213 0 0.0990319)
(0.102826 0.00306226 0 0.0675592 0 0.0986489)
(0.10273 0.00315037 0 0.0666942 0 0.098266)
(0.102643 0.00323714 0 0.0658271 0 0.0978831)
(0.102565 0.00332227 0 0.0649586 0 0.0975001)
(0.102497 0.00340543 0 0.0640896 0 0.0971172)
(0.102437 0.00348628 0 0.0632212 0 0.0967341)
(0.102385 0.00356443 0 0.0623542 0 0.0963509)
(0.10234 0.00363947 0 0.0614897 0 0.0959676)
(0.102304 0.00371096 0 0.0606287 0 0.0955842)
(0.102274 0.00377846 0 0.0597722 0 0.0952006)
(0.102251 0.00384148 0 0.0589214 0 0.0948169)
(0.102234 0.00389953 0 0.0580772 0 0.0944333)
(0.102224 0.00395213 0 0.0572407 0 0.0940499)
(0.102219 0.00399883 0 0.056413 0 0.0936669)
(0.102221 0.00403918 0 0.055595 0 0.0932845)
(0.102229 0.00407286 0 0.0547877 0 0.0929031)
(0.102244 0.0040996 0 0.053992 0 0.0925232)
(0.102265 0.0041193 0 0.0532087 0 0.0921452)
(0.102295 0.00413199 0 0.0524387 0 0.0917697)
(0.102332 0.00413793 0 0.0516825 0 0.0913973)
(0.102378 0.00413761 0 0.050941 0 0.0910285)
(0.102433 0.00413175 0 0.0502147 0 0.0906641)
(0.102498 0.00412133 0 0.0495042 0 0.0903044)
(0.102572 0.00410762 0 0.0488101 0 0.0899501)
(0.102656 0.00409209 0 0.0481327 0 0.0896014)
(0.102749 0.00407642 0 0.0474726 0 0.0892585)
(0.10285 0.00406246 0 0.0468302 0 0.0889214)
(0.102958 0.00405215 0 0.0462058 0 0.0885898)
(0.103071 0.00404746 0 0.0455998 0 0.0882633)
(0.103186 0.00405035 0 0.0450126 0 0.0879412)
(0.103301 0.00406265 0 0.0444444 0 0.0876229)
(0.103414 0.00408601 0 0.0438957 0 0.0873073)
(0.10352 0.00412182 0 0.0433665 0 0.0869935)
(0.10362 0.00417126 0 0.0428573 0 0.0866809)
(0.103709 0.00423531 0 0.0423678 0 0.0863685)
(0.10379 0.00431501 0 0.0418984 0 0.0860567)
(0.103857 0.00441135 0 0.0414482 0 0.0857435)
(0.103925 0.00452606 0 0.0410199 0 0.0854349)
(0.103949 0.00465959 0 0.0406053 0 0.085114)
(0.104056 0.00481266 0 0.0402295 0 0.0848302)
(0.103987 0.00496549 0 0.0398733 0 0.0845084)
(0.120166 9.48168e-05 0 0.107336 0 0.120643)
(0.119851 0.000106581 0 0.106734 0 0.12033)
(0.119534 0.000119283 0 0.106129 0 0.120015)
(0.119216 0.000132939 0 0.105521 0 0.119698)
(0.118897 0.000147565 0 0.104911 0 0.119379)
(0.118577 0.000163174 0 0.104299 0 0.119057)
(0.118257 0.000179782 0 0.103683 0 0.118734)
(0.117935 0.000197404 0 0.103065 0 0.118408)
(0.117612 0.000216058 0 0.102444 0 0.118079)
(0.117288 0.000235766 0 0.101821 0 0.117749)
(0.116963 0.000256553 0 0.101195 0 0.117416)
(0.116638 0.000278448 0 0.100566 0 0.117081)
(0.116312 0.000301485 0 0.0999349 0 0.116743)
(0.115985 0.000325707 0 0.0993008 0 0.116404)
(0.115657 0.000351162 0 0.098664 0 0.116062)
(0.115328 0.000377904 0 0.0980245 0 0.115717)
(0.115 0.000405997 0 0.0973823 0 0.11537)
(0.11467 0.000435513 0 0.0967373 0 0.115021)
(0.114341 0.000466529 0 0.0960894 0 0.11467)
(0.114011 0.000499129 0 0.0954387 0 0.114316)
(0.113681 0.000533403 0 0.0947849 0 0.11396)
(0.113351 0.000569446 0 0.0941281 0 0.113601)
(0.113021 0.000607352 0 0.0934681 0 0.113241)
(0.112692 0.000647219 0 0.0928048 0 0.112878)
(0.112364 0.00068914 0 0.092138 0 0.112513)
(0.112036 0.000733207 0 0.0914676 0 0.112146)
(0.11171 0.000779505 0 0.0907934 0 0.111777)
(0.111385 0.000828112 0 0.0901151 0 0.111406)
(0.111062 0.000879095 0 0.0894326 0 0.111033)
(0.110741 0.000932514 0 0.0887456 0 0.110658)
(0.110423 0.000988412 0 0.0880539 0 0.110282)
(0.110108 0.00104682 0 0.0873573 0 0.109903)
(0.109796 0.00110777 0 0.0866555 0 0.109524)
(0.109487 0.00117126 0 0.0859483 0 0.109142)
(0.109183 0.00123728 0 0.0852354 0 0.10876)
(0.108884 0.00130582 0 0.0845166 0 0.108376)
(0.108589 0.00137685 0 0.0837917 0 0.107991)
(0.1083 0.00145032 0 0.0830605 0 0.107605)
(0.108016 0.00152619 0 0.0823228 0 0.107218)
(0.107739 0.00160439 0 0.0815785 0 0.10683)
(0.107468 0.00168486 0 0.0808273 0 0.106441)
(0.107204 0.00176752 0 0.0800692 0 0.106051)
(0.106947 0.0018523 0 0.079304 0 0.105661)
(0.106699 0.00193911 0 0.0785318 0 0.105271)
(0.106458 0.00202787 0 0.0777525 0 0.10488)
(0.106226 0.00211848 0 0.076966 0 0.104488)
(0.106003 0.00221085 0 0.0761725 0 0.104096)
(0.105789 0.00230488 0 0.075372 0 0.103705)
(0.105585 0.00240049 0 0.0745646 0 0.103313)
(0.10539 0.00249756 0 0.0737505 0 0.102921)
(0.105206 0.00259599 0 0.0729299 0 0.102529)
(0.105032 0.00269569 0 0.0721031 0 0.102137)
(0.104868 0.00279653 0 0.0712704 0 0.101745)
(0.104716 0.00289839 0 0.0704321 0 0.101354)
(0.104575 0.00300117 0 0.0695888 0 0.100963)
(0.104445 0.00310472 0 0.0687407 0 0.100573)
(0.104326 0.00320891 0 0.0678886 0 0.100183)
(0.104219 0.00331358 0 0.067033 0 0.0997937)
(0.104124 0.00341857 0 0.0661745 0 0.099405)
(0.104041 0.0035237 0 0.065314 0 0.0990171)
(0.103969 0.00362878 0 0.0644521 0 0.09863)
(0.103909 0.00373357 0 0.0635898 0 0.0982438)
(0.10386 0.00383782 0 0.0627279 0 0.0978586)
(0.103824 0.00394127 0 0.0618674 0 0.0974745)
(0.103799 0.00404359 0 0.0610094 0 0.0970916)
(0.103785 0.00414444 0 0.0601549 0 0.0967101)
(0.103783 0.00424341 0 0.0593051 0 0.09633)
(0.103792 0.00434009 0 0.058461 0 0.0959516)
(0.103812 0.004434 0 0.0576239 0 0.0955751)
(0.103844 0.00452461 0 0.0567949 0 0.0952008)
(0.103887 0.0046114 0 0.0559752 0 0.0948289)
(0.103941 0.00469378 0 0.055166 0 0.09446)
(0.104007 0.00477119 0 0.0543685 0 0.0940944)
(0.104086 0.00484309 0 0.0535836 0 0.0937327)
(0.104177 0.00490898 0 0.0528126 0 0.0933754)
(0.104282 0.00496845 0 0.0520562 0 0.0930234)
(0.104401 0.00502122 0 0.0513156 0 0.0926773)
(0.104534 0.00506718 0 0.0505914 0 0.092338)
(0.104684 0.00510644 0 0.0498844 0 0.0920062)
(0.10485 0.00513936 0 0.0491953 0 0.0916828)
(0.105033 0.0051666 0 0.0485245 0 0.0913685)
(0.105234 0.00518911 0 0.0478725 0 0.0910638)
(0.105452 0.00520817 0 0.0472397 0 0.0907692)
(0.105686 0.00522535 0 0.0466262 0 0.0904848)
(0.105935 0.00524248 0 0.0460324 0 0.0902103)
(0.106197 0.00526159 0 0.0454583 0 0.0899454)
(0.106469 0.00528488 0 0.0449041 0 0.0896892)
(0.106749 0.00531461 0 0.0443699 0 0.0894406)
(0.107033 0.00535309 0 0.0438557 0 0.0891983)
(0.107317 0.00540252 0 0.0433619 0 0.0889609)
(0.107597 0.00546491 0 0.0428885 0 0.0887268)
(0.107869 0.00554201 0 0.0424358 0 0.0884946)
(0.108133 0.00563537 0 0.0420041 0 0.0882633)
(0.108384 0.00574633 0 0.0415934 0 0.088032)
(0.108626 0.00587634 0 0.0412045 0 0.0878013)
(0.108854 0.00602689 0 0.0408364 0 0.0875697)
(0.109087 0.00620064 0 0.0404927 0 0.0873443)
(0.109277 0.00639865 0 0.0401657 0 0.0871079)
(0.109562 0.00662488 0 0.0398822 0 0.0869139)
(0.109638 0.00684567 0 0.0396163 0 0.0866672)
(0.12092 0.000231892 0 0.105887 0 0.121245)
(0.120623 0.00025249 0 0.105248 0 0.120939)
(0.120324 0.00027418 0 0.104607 0 0.120631)
(0.120024 0.000296969 0 0.103963 0 0.120319)
(0.119722 0.000320865 0 0.103317 0 0.120005)
(0.119419 0.000345873 0 0.102668 0 0.119689)
(0.119115 0.000371998 0 0.102017 0 0.119369)
(0.118809 0.000399249 0 0.101363 0 0.119047)
(0.118502 0.000427633 0 0.100707 0 0.118721)
(0.118194 0.000457161 0 0.100049 0 0.118393)
(0.117885 0.000487849 0 0.0993877 0 0.118062)
(0.117574 0.000519716 0 0.0987245 0 0.117728)
(0.117263 0.000552786 0 0.098059 0 0.117391)
(0.11695 0.00058709 0 0.097391 0 0.117051)
(0.116636 0.000622665 0 0.0967208 0 0.116709)
(0.116322 0.000659554 0 0.0960482 0 0.116363)
(0.116006 0.00069781 0 0.0953732 0 0.116014)
(0.11569 0.000737492 0 0.0946959 0 0.115663)
(0.115373 0.000778665 0 0.0940162 0 0.115309)
(0.115055 0.000821401 0 0.093334 0 0.114951)
(0.114738 0.000865778 0 0.0926493 0 0.114591)
(0.114419 0.000911879 0 0.091962 0 0.114228)
(0.114101 0.000959788 0 0.0912721 0 0.113863)
(0.113783 0.00100959 0 0.0905794 0 0.113495)
(0.113466 0.00106138 0 0.0898837 0 0.113124)
(0.113149 0.00111523 0 0.089185 0 0.11275)
(0.112833 0.00117123 0 0.088483 0 0.112374)
(0.112519 0.00122945 0 0.0877777 0 0.111996)
(0.112206 0.00128997 0 0.0870688 0 0.111615)
(0.111895 0.00135284 0 0.0863561 0 0.111233)
(0.111587 0.00141812 0 0.0856395 0 0.110848)
(0.111281 0.00148585 0 0.0849186 0 0.110461)
(0.110979 0.00155606 0 0.0841934 0 0.110072)
(0.11068 0.00162879 0 0.0834635 0 0.109681)
(0.110385 0.00170404 0 0.0827289 0 0.109289)
(0.110095 0.00178181 0 0.0819892 0 0.108895)
(0.10981 0.00186211 0 0.0812443 0 0.108499)
(0.109531 0.00194491 0 0.080494 0 0.108103)
(0.109257 0.0020302 0 0.0797382 0 0.107705)
(0.10899 0.00211796 0 0.0789767 0 0.107306)
(0.108729 0.00220814 0 0.0782095 0 0.106907)
(0.108476 0.00230072 0 0.0774363 0 0.106506)
(0.108231 0.00239565 0 0.0766573 0 0.106105)
(0.107994 0.00249289 0 0.0758723 0 0.105703)
(0.107766 0.00259241 0 0.0750814 0 0.105302)
(0.107548 0.00269414 0 0.0742846 0 0.104899)
(0.107339 0.00279806 0 0.073482 0 0.104497)
(0.10714 0.00290411 0 0.0726738 0 0.104095)
(0.106952 0.00301224 0 0.0718601 0 0.103693)
(0.106775 0.00312242 0 0.071041 0 0.103292)
(0.10661 0.00323458 0 0.070217 0 0.102891)
(0.106457 0.00334869 0 0.0693884 0 0.102491)
(0.106317 0.00346469 0 0.0685554 0 0.102092)
(0.10619 0.00358253 0 0.0677186 0 0.101693)
(0.106076 0.00370213 0 0.0668785 0 0.101297)
(0.105976 0.00382343 0 0.0660356 0 0.100901)
(0.10589 0.00394634 0 0.0651906 0 0.100508)
(0.105819 0.00407078 0 0.0643441 0 0.100116)
(0.105763 0.00419662 0 0.063497 0 0.0997262)
(0.105722 0.00432373 0 0.0626501 0 0.099339)
(0.105697 0.00445195 0 0.0618043 0 0.0989544)
(0.105688 0.00458107 0 0.0609606 0 0.0985727)
(0.105695 0.00471087 0 0.0601201 0 0.0981942)
(0.10572 0.00484107 0 0.0592839 0 0.0978192)
(0.105761 0.00497132 0 0.0584532 0 0.097448)
(0.105819 0.00510124 0 0.0576292 0 0.0970809)
(0.105895 0.00523038 0 0.0568134 0 0.0967184)
(0.105989 0.00535822 0 0.056007 0 0.0963608)
(0.106101 0.00548416 0 0.0552114 0 0.0960087)
(0.106231 0.00560756 0 0.054428 0 0.0956626)
(0.106381 0.00572772 0 0.0536583 0 0.0953231)
(0.106551 0.0058439 0 0.0529035 0 0.0949908)
(0.106741 0.00595536 0 0.0521651 0 0.0946665)
(0.106952 0.00606137 0 0.0514443 0 0.094351)
(0.107185 0.00616127 0 0.0507423 0 0.0940454)
(0.107442 0.00625452 0 0.0500601 0 0.0937506)
(0.107724 0.00634074 0 0.0493987 0 0.0934677)
(0.108031 0.00641979 0 0.0487588 0 0.0931977)
(0.108364 0.00649182 0 0.0481409 0 0.0929417)
(0.108725 0.00655729 0 0.0475455 0 0.0927007)
(0.109113 0.00661705 0 0.0469726 0 0.0924753)
(0.109528 0.00667235 0 0.0464223 0 0.0922659)
(0.109969 0.0067248 0 0.0458943 0 0.0920726)
(0.110434 0.00677639 0 0.0453882 0 0.091895)
(0.11092 0.00682944 0 0.0449038 0 0.091732)
(0.111423 0.0068865 0 0.0444405 0 0.0915823)
(0.111939 0.0069503 0 0.0439979 0 0.091444)
(0.112462 0.0070237 0 0.0435757 0 0.091315)
(0.112987 0.00710961 0 0.0431739 0 0.0911929)
(0.113509 0.00721088 0 0.0427927 0 0.0910756)
(0.114024 0.0073302 0 0.0424325 0 0.0909611)
(0.114528 0.00747002 0 0.0420941 0 0.0908479)
(0.115022 0.00763261 0 0.0417782 0 0.0907355)
(0.115504 0.0078201 0 0.0414858 0 0.0906239)
(0.11598 0.00803475 0 0.0412183 0 0.0905154)
(0.116449 0.00827904 0 0.0409759 0 0.09041)
(0.116937 0.00855704 0 0.0407631 0 0.0903179)
(0.117396 0.00887161 0 0.0405731 0 0.090222)
(0.11798 0.0092318 0 0.0404378 0 0.090184)
(0.118314 0.00958273 0 0.040316 0 0.0900732)
(0.122028 0.00060305 0 0.103795 0 0.121967)
(0.121755 0.000639304 0 0.103109 0 0.121664)
(0.121479 0.000676687 0 0.102421 0 0.121358)
(0.121201 0.00071518 0 0.101732 0 0.121048)
(0.120922 0.000754767 0 0.10104 0 0.120734)
(0.120641 0.00079543 0 0.100346 0 0.120417)
(0.120358 0.000837161 0 0.09965 0 0.120097)
(0.120073 0.000879954 0 0.0989524 0 0.119772)
(0.119786 0.00092381 0 0.0982531 0 0.119444)
(0.119497 0.000968729 0 0.0975521 0 0.119113)
(0.119207 0.00101472 0 0.0968494 0 0.118777)
(0.118915 0.0010618 0 0.0961451 0 0.118438)
(0.118621 0.00110998 0 0.0954392 0 0.118096)
(0.118326 0.00115929 0 0.0947318 0 0.11775)
(0.118029 0.00120977 0 0.0940229 0 0.1174)
(0.11773 0.00126145 0 0.0933125 0 0.117046)
(0.117431 0.00131438 0 0.0926006 0 0.11669)
(0.11713 0.00136862 0 0.0918872 0 0.116329)
(0.116828 0.00142423 0 0.0911724 0 0.115965)
(0.116524 0.00148128 0 0.090456 0 0.115598)
(0.116221 0.00153984 0 0.089738 0 0.115227)
(0.115916 0.00159999 0 0.0890185 0 0.114853)
(0.115612 0.00166182 0 0.0882972 0 0.114476)
(0.115307 0.00172542 0 0.0875742 0 0.114096)
(0.115002 0.00179086 0 0.0868492 0 0.113712)
(0.114698 0.00185825 0 0.0861223 0 0.113326)
(0.114395 0.00192767 0 0.0853933 0 0.112937)
(0.114092 0.00199919 0 0.0846619 0 0.112545)
(0.113792 0.00207291 0 0.0839282 0 0.11215)
(0.113493 0.0021489 0 0.0831919 0 0.111753)
(0.113197 0.00222723 0 0.0824528 0 0.111354)
(0.112904 0.00230796 0 0.0817107 0 0.110952)
(0.112615 0.00239114 0 0.0809656 0 0.110549)
(0.112329 0.00247684 0 0.0802172 0 0.110143)
(0.112047 0.00256509 0 0.0794654 0 0.109736)
(0.111771 0.00265592 0 0.0787099 0 0.109328)
(0.1115 0.00274936 0 0.0779508 0 0.108918)
(0.111236 0.00284544 0 0.0771877 0 0.108507)
(0.110978 0.00294418 0 0.0764208 0 0.108095)
(0.110727 0.00304559 0 0.0756497 0 0.107682)
(0.110485 0.00314968 0 0.0748746 0 0.107269)
(0.110251 0.00325645 0 0.0740954 0 0.106855)
(0.110026 0.00336591 0 0.073312 0 0.106441)
(0.109812 0.00347806 0 0.0725246 0 0.106028)
(0.109608 0.00359289 0 0.0717332 0 0.105614)
(0.109415 0.00371042 0 0.0709379 0 0.105202)
(0.109234 0.00383063 0 0.070139 0 0.10479)
(0.109066 0.00395351 0 0.0693366 0 0.10438)
(0.108911 0.00407907 0 0.0685309 0 0.103971)
(0.108771 0.00420727 0 0.0677224 0 0.103564)
(0.108645 0.00433811 0 0.0669114 0 0.103159)
(0.108535 0.00447157 0 0.0660984 0 0.102756)
(0.108442 0.00460759 0 0.0652838 0 0.102356)
(0.108366 0.00474615 0 0.0644683 0 0.101959)
(0.108307 0.00488717 0 0.0636524 0 0.101566)
(0.108268 0.00503058 0 0.062837 0 0.101176)
(0.108247 0.00517628 0 0.0620227 0 0.100791)
(0.108247 0.00532414 0 0.0612106 0 0.10041)
(0.108268 0.00547401 0 0.0604015 0 0.100035)
(0.10831 0.00562569 0 0.0595966 0 0.0996649)
(0.108375 0.00577897 0 0.0587969 0 0.0993009)
(0.108463 0.00593355 0 0.0580038 0 0.0989433)
(0.108574 0.00608913 0 0.0572185 0 0.0985927)
(0.10871 0.00624533 0 0.0564424 0 0.0982496)
(0.108871 0.00640173 0 0.0556771 0 0.0979144)
(0.109057 0.00655784 0 0.0549241 0 0.0975878)
(0.10927 0.00671314 0 0.0541851 0 0.0972703)
(0.10951 0.00686704 0 0.0534617 0 0.0969626)
(0.109777 0.00701894 0 0.0527557 0 0.0966655)
(0.110074 0.0071682 0 0.0520688 0 0.0963798)
(0.1104 0.00731421 0 0.0514027 0 0.0961065)
(0.110758 0.00745638 0 0.0507591 0 0.0958467)
(0.111149 0.00759419 0 0.0501395 0 0.0956016)
(0.111574 0.00772726 0 0.0495453 0 0.0953725)
(0.112035 0.00785536 0 0.0489779 0 0.0951611)
(0.112536 0.00797848 0 0.0484381 0 0.094969)
(0.113077 0.00809686 0 0.0479268 0 0.0947978)
(0.113661 0.00821108 0 0.0474443 0 0.0946494)
(0.114289 0.00832203 0 0.0469906 0 0.094525)
(0.114962 0.00843098 0 0.0465654 0 0.0944261)
(0.11568 0.00853954 0 0.0461679 0 0.0943532)
(0.116442 0.00864973 0 0.0457971 0 0.0943065)
(0.117245 0.00876385 0 0.0454517 0 0.0942854)
(0.118085 0.00888455 0 0.0451301 0 0.0942883)
(0.118955 0.00901472 0 0.0448309 0 0.0943131)
(0.119849 0.00915745 0 0.0445528 0 0.0943568)
(0.12076 0.00931602 0 0.0442946 0 0.0944162)
(0.12168 0.00949385 0 0.0440557 0 0.0944879)
(0.122604 0.00969456 0 0.0438362 0 0.0945688)
(0.123524 0.00992185 0 0.0436368 0 0.0946565)
(0.124441 0.0101795 0 0.043459 0 0.0947497)
(0.125353 0.0104711 0 0.0433053 0 0.0948489)
(0.126267 0.0108003 0 0.0431788 0 0.0949563)
(0.127188 0.0111706 0 0.0430825 0 0.0950754)
(0.128129 0.0115855 0 0.0430204 0 0.0952124)
(0.129098 0.0120488 0 0.0429946 0 0.0953713)
(0.130131 0.012566 0 0.0430127 0 0.0955681)
(0.131181 0.0131439 0 0.0430676 0 0.0957864)
(0.132441 0.013799 0 0.0432033 0 0.0961049)
(0.133405 0.0144538 0 0.0433502 0 0.0963282)
(0.123812 0.00147186 0 0.100773 0 0.122806)
(0.123572 0.00153211 0 0.100027 0 0.122499)
(0.123328 0.00159307 0 0.0992804 0 0.122186)
(0.123082 0.00165478 0 0.0985328 0 0.12187)
(0.122834 0.00171724 0 0.0977845 0 0.121548)
(0.122582 0.00178043 0 0.0970358 0 0.121222)
(0.122328 0.00184434 0 0.0962865 0 0.120892)
(0.122071 0.00190898 0 0.0955369 0 0.120557)
(0.121811 0.00197435 0 0.094787 0 0.120218)
(0.121549 0.00204046 0 0.0940369 0 0.119874)
(0.121284 0.00210732 0 0.0932867 0 0.119526)
(0.121017 0.00217497 0 0.0925364 0 0.119173)
(0.120747 0.00224342 0 0.091786 0 0.118816)
(0.120475 0.00231271 0 0.0910358 0 0.118455)
(0.1202 0.00238289 0 0.0902856 0 0.118089)
(0.119924 0.002454 0 0.0895356 0 0.117719)
(0.119646 0.00252611 0 0.0887857 0 0.117346)
(0.119366 0.00259928 0 0.088036 0 0.116968)
(0.119085 0.00267357 0 0.0872865 0 0.116586)
(0.118802 0.00274908 0 0.0865372 0 0.116201)
(0.118518 0.00282587 0 0.0857881 0 0.115812)
(0.118233 0.00290405 0 0.085039 0 0.115419)
(0.117948 0.00298371 0 0.0842901 0 0.115023)
(0.117663 0.00306493 0 0.0835412 0 0.114623)
(0.117377 0.00314783 0 0.0827923 0 0.11422)
(0.117093 0.0032325 0 0.0820432 0 0.113815)
(0.11681 0.00331904 0 0.0812939 0 0.113406)
(0.116528 0.00340754 0 0.0805442 0 0.112995)
(0.116248 0.0034981 0 0.0797941 0 0.112581)
(0.11597 0.00359081 0 0.0790435 0 0.112165)
(0.115696 0.00368576 0 0.0782921 0 0.111747)
(0.115426 0.00378302 0 0.0775399 0 0.111327)
(0.11516 0.00388267 0 0.0767867 0 0.110906)
(0.114899 0.00398477 0 0.0760326 0 0.110483)
(0.114644 0.00408938 0 0.0752772 0 0.11006)
(0.114396 0.00419655 0 0.0745206 0 0.109635)
(0.114154 0.00430633 0 0.0737627 0 0.10921)
(0.113921 0.00441876 0 0.0730035 0 0.108785)
(0.113697 0.00453385 0 0.0722428 0 0.10836)
(0.113483 0.00465164 0 0.0714808 0 0.107936)
(0.113279 0.00477213 0 0.0707174 0 0.107513)
(0.113087 0.00489533 0 0.0699528 0 0.10709)
(0.112908 0.00502125 0 0.069187 0 0.10667)
(0.112741 0.00514986 0 0.0684202 0 0.106251)
(0.11259 0.00528117 0 0.0676527 0 0.105835)
(0.112453 0.00541514 0 0.0668846 0 0.105421)
(0.112334 0.00555174 0 0.0661163 0 0.105011)
(0.112231 0.00569094 0 0.0653481 0 0.104605)
(0.112147 0.00583269 0 0.0645806 0 0.104203)
(0.112083 0.00597693 0 0.0638141 0 0.103805)
(0.112039 0.0061236 0 0.0630493 0 0.103413)
(0.112017 0.00627262 0 0.0622868 0 0.103027)
(0.112018 0.0064239 0 0.0615274 0 0.102646)
(0.112043 0.00657735 0 0.0607718 0 0.102273)
(0.112093 0.00673287 0 0.060021 0 0.101907)
(0.112168 0.00689035 0 0.0592759 0 0.101548)
(0.112271 0.00704968 0 0.0585377 0 0.101199)
(0.112402 0.00721075 0 0.0578075 0 0.100858)
(0.112562 0.00737345 0 0.0570867 0 0.100526)
(0.112752 0.0075377 0 0.0563766 0 0.100205)
(0.112973 0.00770343 0 0.0556788 0 0.0998948)
(0.113227 0.00787057 0 0.0549949 0 0.0995958)
(0.113514 0.00803913 0 0.0543266 0 0.0993087)
(0.113836 0.00820915 0 0.0536758 0 0.0990345)
(0.114194 0.00838073 0 0.0530445 0 0.0987738)
(0.11459 0.00855406 0 0.0524348 0 0.0985277)
(0.115025 0.00872942 0 0.0518486 0 0.0982973)
(0.115502 0.00890722 0 0.0512883 0 0.0980837)
(0.116024 0.00908798 0 0.0507561 0 0.0978887)
(0.116593 0.00927238 0 0.0502541 0 0.0977139)
(0.117214 0.00946127 0 0.0497844 0 0.0975617)
(0.117891 0.00965568 0 0.0493493 0 0.0974344)
(0.118628 0.00985679 0 0.0489504 0 0.0973352)
(0.119432 0.010066 0 0.0485895 0 0.0972671)
(0.120308 0.0102848 0 0.0482678 0 0.0972339)
(0.121262 0.0105149 0 0.0479864 0 0.0972393)
(0.1223 0.010758 0 0.0477456 0 0.097287)
(0.123427 0.0110159 0 0.0475454 0 0.0973807)
(0.124646 0.0112905 0 0.0473852 0 0.0975233)
(0.125959 0.0115836 0 0.0472636 0 0.0977171)
(0.127365 0.0118969 0 0.0471789 0 0.0979632)
(0.128862 0.0122322 0 0.0471289 0 0.0982612)
(0.130441 0.0125913 0 0.047111 0 0.0986096)
(0.132095 0.0129761 0 0.0471227 0 0.0990052)
(0.133813 0.0133886 0 0.0471618 0 0.0994441)
(0.135584 0.0138314 0 0.0472266 0 0.0999214)
(0.137397 0.0143073 0 0.0473163 0 0.100432)
(0.139243 0.0148195 0 0.047431 0 0.100973)
(0.141115 0.0153724 0 0.0475724 0 0.10154)
(0.143012 0.0159709 0 0.0477438 0 0.102133)
(0.144941 0.0166213 0 0.0479502 0 0.102756)
(0.146917 0.0173303 0 0.0481977 0 0.103416)
(0.148957 0.0181042 0 0.0484932 0 0.104123)
(0.151082 0.018948 0 0.0488429 0 0.104888)
(0.153315 0.0198658 0 0.0492532 0 0.105722)
(0.15567 0.0208605 0 0.0497266 0 0.106633)
(0.158197 0.0219354 0 0.050272 0 0.107645)
(0.160828 0.0230998 0 0.0508756 0 0.108732)
(0.163871 0.0243808 0 0.0516006 0 0.110017)
(0.166585 0.0257075 0 0.0523531 0 0.1112)
(0.127117 0.00331163 0 0.0961365 0 0.123772)
(0.126932 0.00339958 0 0.0953229 0 0.12345)
(0.126743 0.00348733 0 0.094511 0 0.123123)
(0.12655 0.00357492 0 0.0937011 0 0.12279)
(0.126354 0.0036624 0 0.0928934 0 0.122452)
(0.126153 0.00374981 0 0.0920878 0 0.122108)
(0.125948 0.0038372 0 0.0912846 0 0.121759)
(0.125739 0.00392462 0 0.0904839 0 0.121405)
(0.125527 0.0040121 0 0.0896857 0 0.121046)
(0.125311 0.0040997 0 0.0888902 0 0.120682)
(0.125092 0.00418748 0 0.0880975 0 0.120313)
(0.124869 0.00427549 0 0.0873076 0 0.119939)
(0.124643 0.0043638 0 0.0865205 0 0.11956)
(0.124415 0.00445246 0 0.0857365 0 0.119177)
(0.124183 0.00454156 0 0.0849554 0 0.118789)
(0.123949 0.00463117 0 0.0841775 0 0.118397)
(0.123712 0.00472136 0 0.0834027 0 0.118001)
(0.123474 0.00481223 0 0.082631 0 0.117601)
(0.123234 0.00490385 0 0.0818626 0 0.117197)
(0.122992 0.00499633 0 0.0810973 0 0.116789)
(0.12275 0.00508976 0 0.0803353 0 0.116378)
(0.122507 0.00518424 0 0.0795766 0 0.115964)
(0.122264 0.00527986 0 0.078821 0 0.115546)
(0.122021 0.00537674 0 0.0780687 0 0.115126)
(0.12178 0.00547497 0 0.0773195 0 0.114704)
(0.12154 0.00557465 0 0.0765736 0 0.114279)
(0.121302 0.0056759 0 0.0758307 0 0.113852)
(0.121068 0.00577879 0 0.075091 0 0.113423)
(0.120837 0.00588344 0 0.0743543 0 0.112994)
(0.12061 0.00598993 0 0.0736207 0 0.112563)
(0.120389 0.00609834 0 0.07289 0 0.112132)
(0.120174 0.00620875 0 0.0721624 0 0.1117)
(0.119967 0.00632124 0 0.0714379 0 0.111269)
(0.119767 0.00643588 0 0.0707163 0 0.110839)
(0.119576 0.00655273 0 0.0699978 0 0.110409)
(0.119396 0.00667185 0 0.0692825 0 0.109982)
(0.119227 0.00679329 0 0.0685704 0 0.109556)
(0.119071 0.00691711 0 0.0678616 0 0.109133)
(0.118928 0.00704336 0 0.0671563 0 0.108713)
(0.1188 0.00717207 0 0.0664548 0 0.108297)
(0.118689 0.00730332 0 0.0657572 0 0.107885)
(0.118595 0.00743714 0 0.0650639 0 0.107478)
(0.118519 0.00757362 0 0.0643751 0 0.107076)
(0.118464 0.00771281 0 0.0636913 0 0.10668)
(0.11843 0.00785481 0 0.063013 0 0.106292)
(0.11842 0.00799972 0 0.0623406 0 0.10591)
(0.118433 0.00814769 0 0.0616747 0 0.105537)
(0.118473 0.00829887 0 0.061016 0 0.105172)
(0.11854 0.00845344 0 0.0603652 0 0.104816)
(0.118636 0.00861164 0 0.0597231 0 0.104471)
(0.118762 0.00877375 0 0.0590906 0 0.104136)
(0.118921 0.00894009 0 0.0584686 0 0.103813)
(0.119112 0.00911109 0 0.0578583 0 0.103502)
(0.11934 0.00928725 0 0.0572608 0 0.103203)
(0.119604 0.00946916 0 0.0566774 0 0.102918)
(0.119908 0.00965757 0 0.0561095 0 0.102648)
(0.120253 0.00985334 0 0.0555588 0 0.102392)
(0.120641 0.0100575 0 0.0550268 0 0.102153)
(0.121076 0.0102713 0 0.0545156 0 0.101932)
(0.121559 0.0104961 0 0.0540272 0 0.101728)
(0.122095 0.0107336 0 0.0535637 0 0.101544)
(0.122688 0.0109857 0 0.0531278 0 0.101382)
(0.123342 0.0112546 0 0.0527219 0 0.101244)
(0.124062 0.0115428 0 0.0523492 0 0.101131)
(0.124855 0.0118531 0 0.0520126 0 0.101047)
(0.125729 0.0121886 0 0.0517155 0 0.100994)
(0.126691 0.0125526 0 0.0514615 0 0.100978)
(0.127753 0.0129489 0 0.0512545 0 0.101003)
(0.128924 0.0133813 0 0.0510983 0 0.101075)
(0.13022 0.0138539 0 0.0509971 0 0.101199)
(0.131654 0.0143706 0 0.0509551 0 0.101385)
(0.133242 0.0149356 0 0.0509767 0 0.101639)
(0.135001 0.0155526 0 0.0510658 0 0.101973)
(0.13695 0.0162249 0 0.0512267 0 0.102395)
(0.139104 0.0169552 0 0.0514627 0 0.102916)
(0.141481 0.0177457 0 0.0517769 0 0.103547)
(0.144094 0.0185973 0 0.0521716 0 0.104297)
(0.146954 0.0195101 0 0.0526479 0 0.105175)
(0.150066 0.0204829 0 0.0532058 0 0.106187)
(0.15343 0.0215138 0 0.0538437 0 0.107339)
(0.15704 0.0225998 0 0.0545586 0 0.108631)
(0.160882 0.0237375 0 0.0553462 0 0.110061)
(0.164938 0.0249238 0 0.0562008 0 0.111624)
(0.169185 0.0261556 0 0.0571163 0 0.113313)
(0.173598 0.0274313 0 0.0580864 0 0.11512)
(0.178154 0.0287507 0 0.0591055 0 0.117034)
(0.182833 0.0301151 0 0.0601689 0 0.119048)
(0.187615 0.0315265 0 0.061273 0 0.121153)
(0.19249 0.0329893 0 0.0624168 0 0.123344)
(0.197462 0.0345111 0 0.0636036 0 0.125622)
(0.202564 0.0361052 0 0.0648435 0 0.128006)
(0.207838 0.0377834 0 0.0661484 0 0.130516)
(0.213299 0.0395474 0 0.0675219 0 0.133162)
(0.218937 0.0413911 0 0.0689604 0 0.135938)
(0.224733 0.0433026 0 0.0704555 0 0.138834)
(0.230632 0.0452655 0 0.0719886 0 0.141823)
(0.236644 0.0472601 0 0.0735487 0 0.144897)
(0.24257 0.0492774 0 0.0750893 0 0.147974)
(0.248996 0.0513615 0 0.0766841 0 0.15125)
(0.254931 0.0535459 0 0.0782787 0 0.154389)
(0.135244 0.0071291 0 0.0889367 0 0.125414)
(0.135201 0.00723684 0 0.0880695 0 0.125085)
(0.135152 0.0073441 0 0.0872101 0 0.12475)
(0.135098 0.00745094 0 0.0863585 0 0.12441)
(0.135038 0.00755747 0 0.085515 0 0.124064)
(0.134973 0.00766385 0 0.0846797 0 0.123713)
(0.134902 0.00777026 0 0.0838527 0 0.123356)
(0.134827 0.00787689 0 0.0830342 0 0.122995)
(0.134747 0.0079839 0 0.0822242 0 0.122628)
(0.134662 0.00809149 0 0.0814229 0 0.122257)
(0.134574 0.00819984 0 0.0806303 0 0.121882)
(0.134481 0.00830913 0 0.0798465 0 0.121503)
(0.134386 0.00841957 0 0.0790718 0 0.121119)
(0.134287 0.00853134 0 0.078306 0 0.120733)
(0.134186 0.00864464 0 0.0775493 0 0.120343)
(0.134083 0.00875968 0 0.0768018 0 0.119949)
(0.133979 0.00887667 0 0.0760636 0 0.119554)
(0.133874 0.00899582 0 0.0753347 0 0.119155)
(0.133768 0.00911735 0 0.0746152 0 0.118755)
(0.133663 0.0092415 0 0.0739052 0 0.118353)
(0.133559 0.00936849 0 0.0732046 0 0.11795)
(0.133457 0.00949859 0 0.0725137 0 0.117546)
(0.133358 0.00963203 0 0.0718324 0 0.117142)
(0.133263 0.00976909 0 0.0711609 0 0.116738)
(0.133173 0.00991004 0 0.0704992 0 0.116334)
(0.133088 0.0100552 0 0.0698474 0 0.115932)
(0.133011 0.0102048 0 0.0692056 0 0.115531)
(0.132942 0.0103592 0 0.068574 0 0.115133)
(0.132883 0.0105187 0 0.0679525 0 0.114738)
(0.132835 0.0106837 0 0.0673415 0 0.114346)
(0.132799 0.0108544 0 0.066741 0 0.113959)
(0.132778 0.0110314 0 0.0661513 0 0.113577)
(0.132773 0.0112149 0 0.0655725 0 0.113201)
(0.132786 0.0114054 0 0.0650049 0 0.112832)
(0.132818 0.0116034 0 0.0644488 0 0.112471)
(0.132872 0.0118093 0 0.0639045 0 0.112118)
(0.13295 0.0120235 0 0.0633724 0 0.111774)
(0.133053 0.0122468 0 0.0628529 0 0.111441)
(0.133184 0.0124796 0 0.0623463 0 0.111119)
(0.133346 0.0127227 0 0.0618533 0 0.11081)
(0.13354 0.0129766 0 0.0613745 0 0.110514)
(0.133769 0.0132423 0 0.0609103 0 0.110232)
(0.134036 0.0135205 0 0.0604617 0 0.109967)
(0.134344 0.0138123 0 0.0600293 0 0.109718)
(0.134695 0.0141186 0 0.059614 0 0.109487)
(0.135093 0.0144407 0 0.0592168 0 0.109276)
(0.135542 0.0147799 0 0.0588388 0 0.109086)
(0.136044 0.0151375 0 0.0584811 0 0.108918)
(0.136603 0.0155153 0 0.0581452 0 0.108774)
(0.137225 0.0159149 0 0.0578324 0 0.108656)
(0.137912 0.0163382 0 0.0575443 0 0.108565)
(0.13867 0.0167875 0 0.0572828 0 0.108503)
(0.139505 0.0172652 0 0.0570498 0 0.108472)
(0.140423 0.0177741 0 0.0568478 0 0.108476)
(0.141432 0.018317 0 0.0566793 0 0.108517)
(0.14254 0.0188975 0 0.0565472 0 0.108598)
(0.143757 0.0195192 0 0.0564548 0 0.108724)
(0.145094 0.0201861 0 0.0564059 0 0.1089)
(0.146564 0.0209028 0 0.0564047 0 0.109131)
(0.148182 0.0216743 0 0.056456 0 0.109423)
(0.149965 0.0225058 0 0.0565652 0 0.109784)
(0.151933 0.0234032 0 0.0567386 0 0.110223)
(0.15411 0.0243728 0 0.0569829 0 0.11075)
(0.156521 0.0254214 0 0.057306 0 0.111378)
(0.159197 0.026556 0 0.0577165 0 0.112121)
(0.162171 0.0277844 0 0.0582241 0 0.112994)
(0.165482 0.0291144 0 0.0588394 0 0.114016)
(0.169172 0.0305541 0 0.0595742 0 0.115208)
(0.173288 0.0321118 0 0.0604412 0 0.116594)
(0.177879 0.0337956 0 0.0614537 0 0.118199)
(0.183001 0.0356134 0 0.0626259 0 0.120052)
(0.188706 0.0375724 0 0.0639725 0 0.122182)
(0.195051 0.0396789 0 0.0655079 0 0.124622)
(0.202088 0.0419378 0 0.0672459 0 0.127402)
(0.209864 0.0443519 0 0.0691991 0 0.130553)
(0.218416 0.0469218 0 0.0713777 0 0.134104)
(0.227768 0.0496448 0 0.0737887 0 0.138077)
(0.237926 0.0525145 0 0.0764346 0 0.142488)
(0.248873 0.05552 0 0.0793119 0 0.147344)
(0.260565 0.058646 0 0.0824104 0 0.152639)
(0.272929 0.0618719 0 0.0857117 0 0.158354)
(0.285863 0.0651723 0 0.0891888 0 0.164455)
(0.299238 0.0685176 0 0.0928063 0 0.170893)
(0.312901 0.0718748 0 0.0965205 0 0.177605)
(0.326685 0.0752089 0 0.100281 0 0.184516)
(0.340415 0.0784841 0 0.104032 0 0.191546)
(0.353899 0.0816595 0 0.107714 0 0.198599)
(0.366894 0.0846827 0 0.11125 0 0.205551)
(0.379197 0.087514 0 0.114575 0 0.212292)
(0.390667 0.0901303 0 0.11764 0 0.218739)
(0.40151 0.0925981 0 0.12047 0 0.224981)
(0.411924 0.0949721 0 0.123095 0 0.231104)
(0.421493 0.0971403 0 0.12543 0 0.236891)
(0.429878 0.0990142 0 0.127403 0 0.242153)
(0.436854 0.100532 0 0.128965 0 0.24675)
(0.442232 0.101652 0 0.130074 0 0.250567)
(0.446125 0.102373 0 0.130747 0 0.253609)
(0.448092 0.102625 0 0.13088 0 0.255689)
(0.450284 0.102777 0 0.130869 0 0.257605)
(0.450149 0.102726 0 0.13013 0 0.258477)
(0.17327 0.0333482 0 0.0792801 0 0.135992)
(0.174082 0.033767 0 0.078618 0 0.135953)
(0.174891 0.0341811 0 0.0779808 0 0.135913)
(0.175696 0.0345911 0 0.0773683 0 0.135873)
(0.176499 0.0349971 0 0.0767804 0 0.135834)
(0.177299 0.0353995 0 0.0762169 0 0.135796)
(0.178097 0.0357986 0 0.0756778 0 0.13576)
(0.178894 0.0361946 0 0.0751629 0 0.135725)
(0.17969 0.036588 0 0.0746721 0 0.135693)
(0.180487 0.036979 0 0.0742053 0 0.135663)
(0.181284 0.037368 0 0.0737622 0 0.135637)
(0.182083 0.0377553 0 0.0733428 0 0.135614)
(0.182885 0.0381415 0 0.0729469 0 0.135596)
(0.183691 0.0385269 0 0.0725744 0 0.135582)
(0.184501 0.038912 0 0.0722252 0 0.135574)
(0.185317 0.0392972 0 0.0718991 0 0.135572)
(0.186141 0.0396831 0 0.071596 0 0.135576)
(0.186973 0.0400703 0 0.0713157 0 0.135588)
(0.187816 0.0404593 0 0.0710583 0 0.135608)
(0.18867 0.0408508 0 0.0708235 0 0.135637)
(0.189538 0.0412454 0 0.0706114 0 0.135676)
(0.190422 0.0416439 0 0.0704219 0 0.135725)
(0.191324 0.042047 0 0.0702551 0 0.135787)
(0.192246 0.0424554 0 0.0701108 0 0.135861)
(0.193191 0.0428701 0 0.0699892 0 0.13595)
(0.194162 0.0432919 0 0.0698905 0 0.136054)
(0.19516 0.0437218 0 0.0698146 0 0.136174)
(0.196191 0.0441608 0 0.0697619 0 0.136313)
(0.197256 0.0446098 0 0.0697326 0 0.136471)
(0.198359 0.0450701 0 0.069727 0 0.13665)
(0.199505 0.0455426 0 0.0697454 0 0.136853)
(0.200696 0.0460288 0 0.0697882 0 0.13708)
(0.201939 0.0465298 0 0.069856 0 0.137333)
(0.203236 0.047047 0 0.0699494 0 0.137615)
(0.204593 0.0475818 0 0.070069 0 0.137928)
(0.206016 0.0481358 0 0.0702155 0 0.138274)
(0.207509 0.0487106 0 0.0703899 0 0.138656)
(0.209079 0.049308 0 0.0705929 0 0.139075)
(0.210731 0.0499297 0 0.0708258 0 0.139535)
(0.212474 0.0505777 0 0.0710896 0 0.140039)
(0.214313 0.0512543 0 0.0713857 0 0.140589)
(0.216257 0.0519617 0 0.0717155 0 0.141189)
(0.218315 0.0527023 0 0.0720807 0 0.141843)
(0.220496 0.0534791 0 0.0724829 0 0.142554)
(0.222809 0.0542947 0 0.0729243 0 0.143327)
(0.225267 0.0551526 0 0.0734069 0 0.144166)
(0.22788 0.0560561 0 0.0739333 0 0.145077)
(0.230663 0.0570092 0 0.074506 0 0.146064)
(0.23363 0.0580161 0 0.0751282 0 0.147134)
(0.236798 0.0590815 0 0.0758031 0 0.148295)
(0.240185 0.0602105 0 0.0765345 0 0.149552)
(0.24381 0.0614087 0 0.0773264 0 0.150915)
(0.247697 0.0626823 0 0.0781834 0 0.152394)
(0.251869 0.0640381 0 0.0791107 0 0.153998)
(0.256356 0.0654836 0 0.0801138 0 0.155739)
(0.261187 0.0670271 0 0.0811989 0 0.15763)
(0.266398 0.0686775 0 0.0823732 0 0.159686)
(0.272026 0.070445 0 0.0836442 0 0.161923)
(0.278116 0.0723405 0 0.0850206 0 0.164361)
(0.284716 0.0743763 0 0.0865119 0 0.167019)
(0.29188 0.0765655 0 0.0881287 0 0.169922)
(0.299669 0.0789229 0 0.0898828 0 0.173095)
(0.30815 0.0814646 0 0.091787 0 0.17657)
(0.317397 0.084208 0 0.0938559 0 0.18038)
(0.327496 0.0871722 0 0.0961051 0 0.184563)
(0.338537 0.0903781 0 0.0985521 0 0.189161)
(0.350622 0.0938477 0 0.101216 0 0.194222)
(0.36386 0.0976047 0 0.104117 0 0.199799)
(0.378371 0.101674 0 0.107277 0 0.20595)
(0.39428 0.106081 0 0.110719 0 0.212739)
(0.411717 0.110853 0 0.114469 0 0.220234)
(0.430815 0.116014 0 0.118549 0 0.228507)
(0.4517 0.121587 0 0.122985 0 0.237632)
(0.474488 0.127593 0 0.127799 0 0.247681)
(0.499275 0.134045 0 0.133007 0 0.258723)
(0.526119 0.140949 0 0.138624 0 0.270813)
(0.555029 0.148297 0 0.14465 0 0.283992)
(0.585947 0.156066 0 0.151078 0 0.29827)
(0.618724 0.164214 0 0.157879 0 0.313623)
(0.653107 0.172672 0 0.165008 0 0.329977)
(0.68872 0.181346 0 0.172394 0 0.347203)
(0.725059 0.19011 0 0.179938 0 0.365105)
(0.761488 0.198811 0 0.187517 0 0.383418)
(0.797258 0.207269 0 0.19498 0 0.401809)
(0.831533 0.215282 0 0.202155 0 0.41989)
(0.863416 0.222635 0 0.208855 0 0.437222)
(0.892008 0.229102 0 0.21489 0 0.453344)
(0.91546 0.234207 0 0.219889 0 0.467326)
(0.933024 0.237799 0 0.223716 0 0.478731)
(0.944348 0.239829 0 0.2263 0 0.48729)
(0.949032 0.240218 0 0.227542 0 0.492694)
(0.947012 0.238966 0 0.227396 0 0.494791)
(0.939175 0.236312 0 0.225986 0 0.49391)
(0.926506 0.232508 0 0.223462 0 0.490453)
(0.910031 0.227801 0 0.219997 0 0.484863)
(0.890599 0.222391 0 0.215733 0 0.477529)
(0.869273 0.216521 0 0.210905 0 0.468932)
(0.845957 0.210059 0 0.205373 0 0.459106)
(0.824133 0.20378 0 0.200004 0 0.449452)
(0.801799 0.197275 0 0.19326 0 0.439579)
(0.473782 0.115557 0 0.103571 0 0.270085)
(0.478347 0.116232 0 0.104405 0 0.27269)
(0.482768 0.116898 0 0.105237 0 0.275248)
(0.487043 0.117554 0 0.106062 0 0.277755)
(0.491169 0.118197 0 0.10688 0 0.280208)
(0.495143 0.118824 0 0.107687 0 0.282603)
(0.498965 0.119435 0 0.10848 0 0.284937)
(0.502629 0.120026 0 0.109258 0 0.287206)
(0.506136 0.120597 0 0.110018 0 0.289407)
(0.509482 0.121145 0 0.110758 0 0.291538)
(0.512664 0.121669 0 0.111476 0 0.293594)
(0.515682 0.122166 0 0.11217 0 0.295573)
(0.518533 0.122636 0 0.112838 0 0.297472)
(0.521214 0.123077 0 0.113479 0 0.299288)
(0.523725 0.123488 0 0.11409 0 0.301019)
(0.526064 0.123867 0 0.114671 0 0.302661)
(0.528228 0.124214 0 0.115221 0 0.304212)
(0.530216 0.124526 0 0.115737 0 0.305669)
(0.532027 0.124804 0 0.116219 0 0.307031)
(0.53366 0.125046 0 0.116665 0 0.308295)
(0.535112 0.125251 0 0.117074 0 0.309459)
(0.536382 0.125418 0 0.117446 0 0.31052)
(0.537469 0.125546 0 0.11778 0 0.311478)
(0.538371 0.125635 0 0.118074 0 0.312329)
(0.539087 0.125683 0 0.118327 0 0.313073)
(0.539615 0.12569 0 0.11854 0 0.313707)
(0.539954 0.125655 0 0.11871 0 0.314229)
(0.540102 0.125577 0 0.118838 0 0.314639)
(0.540056 0.125455 0 0.118922 0 0.314933)
(0.539815 0.125288 0 0.118962 0 0.315111)
(0.539377 0.125075 0 0.118956 0 0.31517)
(0.538738 0.124816 0 0.118905 0 0.31511)
(0.537897 0.124509 0 0.118808 0 0.314927)
(0.53685 0.124154 0 0.118663 0 0.31462)
(0.535594 0.123748 0 0.118469 0 0.314186)
(0.534125 0.123292 0 0.118227 0 0.313625)
(0.53244 0.122783 0 0.117934 0 0.312932)
(0.530533 0.122222 0 0.117591 0 0.312107)
(0.528401 0.121605 0 0.117195 0 0.311145)
(0.526038 0.120933 0 0.116747 0 0.310044)
(0.523439 0.120203 0 0.116244 0 0.308802)
(0.520599 0.119415 0 0.115687 0 0.307415)
(0.517512 0.118567 0 0.115073 0 0.30588)
(0.51417 0.117657 0 0.114402 0 0.304194)
(0.510569 0.116685 0 0.113672 0 0.302352)
(0.506701 0.115648 0 0.112882 0 0.300351)
(0.502559 0.114545 0 0.112031 0 0.298187)
(0.498137 0.113374 0 0.111117 0 0.295857)
(0.493428 0.112135 0 0.11014 0 0.293356)
(0.488424 0.110826 0 0.109098 0 0.29068)
(0.483119 0.109446 0 0.107989 0 0.287825)
(0.477508 0.107994 0 0.106814 0 0.284788)
(0.471583 0.106468 0 0.10557 0 0.281565)
(0.465339 0.104869 0 0.104257 0 0.278153)
(0.458774 0.103195 0 0.102874 0 0.274548)
(0.451882 0.101447 0 0.101422 0 0.270749)
(0.444662 0.0996243 0 0.0998992 0 0.266753)
(0.437114 0.0977284 0 0.0983067 0 0.26256)
(0.42924 0.0957602 0 0.0966453 0 0.25817)
(0.421044 0.0937219 0 0.0949164 0 0.253585)
(0.412535 0.0916162 0 0.093122 0 0.248808)
(0.403722 0.0894468 0 0.0912653 0 0.243843)
(0.394623 0.0872187 0 0.0893501 0 0.2387)
(0.385257 0.0849379 0 0.0873817 0 0.233388)
(0.375654 0.0826122 0 0.0853666 0 0.227922)
(0.365846 0.0802507 0 0.0833132 0 0.22232)
(0.355877 0.0778649 0 0.0812317 0 0.216604)
(0.345801 0.075468 0 0.0791344 0 0.210803)
(0.335681 0.073076 0 0.0770361 0 0.204953)
(0.325594 0.0707072 0 0.0749546 0 0.199095)
(0.315628 0.0683825 0 0.0729104 0 0.19328)
(0.305889 0.0661259 0 0.0709275 0 0.187567)
(0.296496 0.0639637 0 0.0690329 0 0.182024)
(0.287581 0.0619249 0 0.0672573 0 0.176728)
(0.279292 0.0600402 0 0.065634 0 0.171768)
(0.271782 0.0583417 0 0.0641986 0 0.167236)
(0.265214 0.0568615 0 0.0629881 0 0.163232)
(0.259745 0.0556301 0 0.0620391 0 0.159858)
(0.25552 0.0546753 0 0.0613858 0 0.157209)
(0.252662 0.0540192 0 0.0610573 0 0.155372)
(0.251256 0.053677 0 0.0610745 0 0.154415)
(0.251337 0.0536543 0 0.0614473 0 0.154379)
(0.252884 0.053946 0 0.0621716 0 0.15527)
(0.255809 0.0545354 0 0.0632276 0 0.157054)
(0.259961 0.0553947 0 0.0645794 0 0.159658)
(0.265134 0.0564849 0 0.0661757 0 0.162966)
(0.27112 0.0577673 0 0.0679657 0 0.166856)
(0.279396 0.0595848 0 0.0703117 0 0.172076)
(0.289099 0.0617144 0 0.0730067 0 0.178216)
(0.299146 0.0639195 0 0.0757814 0 0.18469)
(0.308654 0.0660225 0 0.0784073 0 0.190968)
(0.316955 0.0678927 0 0.0807054 0 0.196616)
(0.323665 0.0694537 0 0.0825648 0 0.201351)
(0.328637 0.0706726 0 0.0839349 0 0.205031)
(0.331918 0.0715518 0 0.0848193 0 0.207638)
(0.333582 0.0720962 0 0.08523 0 0.209191)
(0.334048 0.0724013 0 0.0852882 0 0.20991)
(0.333004 0.0723194 0 0.0848706 0 0.209635)
(0.333004 0.0726629 0 0.0847682 0 0.209767)
(0.332588 0.0727412 0 0.0843456 0 0.209521)
(0.00379602 0.000769532 0 0.0101719 0 0.00993956)
(0.00907906 -0.000385467 0 0.0128867 0 0.0160268)
(0.0127917 -0.00163244 0 0.0144645 0 0.0192142)
(0.0162677 -0.00237928 0 0.0142797 0 0.0210396)
(0.0189652 -0.00282183 0 0.0135476 0 0.0220523)
(0.0210236 -0.00307005 0 0.0125891 0 0.0225362)
(0.0225996 -0.00318792 0 0.0115709 0 0.0226694)
(0.0237988 -0.00321777 0 0.0106067 0 0.0225723)
(0.0246418 -0.00321609 0 0.00972163 0 0.0222796)
(0.025211 -0.00321392 0 0.00891194 0 0.0218351)
(0.0258685 -0.0031686 0 0.00821811 0 0.0214792)
(0.026615 -0.00297287 0 0.00763217 0 0.0212496)
(0.0272292 -0.0025871 0 0.00713962 0 0.0210424)
(0.0277707 -0.00212143 0 0.00675556 0 0.0208806)
(0.0283212 -0.00164385 0 0.00649191 0 0.0208077)
(0.0289756 -0.00120618 0 0.00635894 0 0.0208796)
(0.0298324 -0.00084892 0 0.00636485 0 0.0211579)
(0.0309803 -0.000596153 0 0.0065154 0 0.0217023)
(0.0324482 -0.000442848 0 0.00681014 0 0.0225457)
(0.0342684 -0.000356691 0 0.00725886 0 0.0237457)
(0.0365668 -0.000310993 0 0.00793755 0 0.0254837)
(0.0399746 -0.000325391 0 0.0090696 0 0.0283878)
(0.046966 -3.91963e-06 0 0.0111544 0 0.0343334)
(0.0577709 0.000928329 0 0.0138425 0 0.042863)
(0.0715453 0.00246806 0 0.0169851 0 0.0531396)
(0.0869811 0.00450837 0 0.0204041 0 0.0641974)
(0.102874 0.00690678 0 0.0239559 0 0.075289)
(0.118454 0.00951686 0 0.0275554 0 0.0860084)
(0.133367 0.0122023 0 0.0311605 0 0.0962107)
(0.147528 0.014855 0 0.034747 0 0.105894)
(0.160986 0.0173995 0 0.0382965 0 0.115118)
(0.173838 0.0197868 0 0.0417928 0 0.123959)
(0.186175 0.021987 0 0.0452196 0 0.132479)
(0.198018 0.0239977 0 0.0485518 0 0.140691)
(0.209362 0.0258321 0 0.0517685 0 0.14859)
(0.2202 0.0275111 0 0.0548573 0 0.156173)
(0.23054 0.0290544 0 0.0578175 0 0.163452)
(0.240427 0.0304685 0 0.0606603 0 0.170462)
(0.249871 0.0317613 0 0.0633949 0 0.17722)
(0.25887 0.0329354 0 0.0660289 0 0.183731)
(0.267408 0.0339834 0 0.0685689 0 0.190001)
(0.275452 0.0348832 0 0.0710197 0 0.196027)
(0.282953 0.0355868 0 0.0733843 0 0.201804)
(0.28983 0.0359836 0 0.0756664 0 0.207324)
(0.295972 0.0357944 0 0.0778743 0 0.212579)
(0.301636 0.0350874 0 0.08007 0 0.217681)
(0.307147 0.0343344 0 0.0823121 0 0.222719)
(0.31254 0.0335176 0 0.0846183 0 0.227722)
(0.317825 0.0326037 0 0.0869937 0 0.232701)
(0.322968 0.0315695 0 0.0894314 0 0.237639)
(0.32794 0.0303978 0 0.0919202 0 0.242515)
(0.33272 0.0290749 0 0.0944517 0 0.247317)
(0.337298 0.027591 0 0.09702 0 0.252032)
(0.341668 0.0259388 0 0.0996211 0 0.256654)
(0.345829 0.0241123 0 0.102252 0 0.261175)
(0.349782 0.0221059 0 0.104908 0 0.265592)
(0.353532 0.019915 0 0.107589 0 0.2699)
(0.357088 0.017535 0 0.11029 0 0.274095)
(0.360458 0.0149622 0 0.113008 0 0.278176)
(0.363656 0.0121929 0 0.115739 0 0.28214)
(0.366695 0.009224 0 0.118479 0 0.285987)
(0.369592 0.00605275 0 0.121221 0 0.289716)
(0.372367 0.00267841 0 0.123957 0 0.293323)
(0.37504 -0.00089724 0 0.126675 0 0.296807)
(0.377632 -0.00467105 0 0.129361 0 0.300168)
(0.380171 -0.0086404 0 0.132001 0 0.303405)
(0.382688 -0.0128077 0 0.134578 0 0.306525)
(0.385234 -0.0171965 0 0.137077 0 0.309542)
(0.387924 -0.021902 0 0.139472 0 0.312504)
(0.391079 -0.027239 0 0.1417 0 0.31554)
(0.395904 -0.0342348 0 0.143552 0 0.319122)
(0.403377 -0.0426447 0 0.145039 0 0.323645)
(0.410301 -0.0490422 0 0.146771 0 0.327851)
(0.416606 -0.054213 0 0.148475 0 0.331659)
(0.422567 -0.0586905 0 0.150084 0 0.335209)
(0.428334 -0.0627596 0 0.15159 0 0.338582)
(0.433858 -0.0666321 0 0.152976 0 0.341738)
(0.438374 -0.0703681 0 0.154258 0 0.344241)
(0.439174 -0.0737822 0 0.156192 0 0.344823)
(0.431812 -0.0787262 0 0.162887 0 0.34219)
(0.434697 -0.0832489 0 0.163486 0 0.342867)
(0.440506 -0.0865324 0 0.161952 0 0.344754)
(0.445688 -0.0871884 0 0.15919 0 0.346129)
(0.448957 -0.0887395 0 0.158046 0 0.346813)
(0.451216 -0.0902274 0 0.157164 0 0.346962)
(0.452612 -0.0915595 0 0.156243 0 0.346583)
(0.453267 -0.0926912 0 0.15517 0 0.345714)
(0.453266 -0.0936062 0 0.153905 0 0.344399)
(0.452677 -0.0943088 0 0.152446 0 0.342678)
(0.451566 -0.0948108 0 0.150805 0 0.340592)
(0.449987 -0.0951298 0 0.149003 0 0.338185)
(0.448002 -0.0952819 0 0.147064 0 0.335497)
(0.445658 -0.0952956 0 0.145019 0 0.332571)
(0.443043 -0.0951808 0 0.142901 0 0.329466)
(0.440193 -0.0950141 0 0.140764 0 0.32623)
(0.43738 -0.0947454 0 0.138668 0 0.323027)
(0.434508 -0.0947281 0 0.136747 0 0.319898)
(0.433121 -0.0945009 0 0.135281 0 0.317699)
(0.431474 -0.095664 0 0.134214 0 0.315806)
(0.441863 -0.098206 0 0.137686 0 0.32162)
(0.00779468 0.00272338 0 0.0172243 0 0.0178507)
(0.0173951 0.000194929 0 0.0221092 0 0.0301753)
(0.0282321 -8.39859e-05 0 0.0240761 0 0.0374277)
(0.0377949 0.000137933 0 0.0232015 0 0.0412244)
(0.0448509 0.000374614 0 0.0223286 0 0.043906)
(0.0507879 0.000585878 0 0.0212005 0 0.0459467)
(0.0559225 0.000844622 0 0.0199939 0 0.0476139)
(0.060458 0.00111634 0 0.0188709 0 0.0490404)
(0.0645224 0.0012866 0 0.0178651 0 0.0502858)
(0.0683467 0.00133746 0 0.0169735 0 0.0514478)
(0.0722484 0.00131522 0 0.0162022 0 0.0526664)
(0.0766314 0.00130849 0 0.0155696 0 0.0541418)
(0.0818142 0.00136594 0 0.0151189 0 0.0560538)
(0.0880795 0.00146445 0 0.0149006 0 0.0585679)
(0.0957409 0.00151523 0 0.0149628 0 0.0618649)
(0.105154 0.00137917 0 0.015348 0 0.0661462)
(0.116702 0.000890239 0 0.0160965 0 0.0716263)
(0.130768 -0.000136622 0 0.0172583 0 0.0785248)
(0.146986 -0.00177517 0 0.0188508 0 0.0866998)
(0.164786 -0.0038411 0 0.0208967 0 0.0959543)
(0.182928 -0.00575078 0 0.0233461 0 0.105832)
(0.198812 -0.00658882 0 0.0259942 0 0.115338)
(0.208907 -0.00546061 0 0.0286532 0 0.123083)
(0.212684 -0.0024111 0 0.0314902 0 0.128913)
(0.2138 0.00114006 0 0.0348078 0 0.134459)
(0.215934 0.00356043 0 0.0388268 0 0.141185)
(0.221298 0.00396414 0 0.0435341 0 0.149801)
(0.230762 0.00214111 0 0.048798 0 0.16045)
(0.244589 -0.00174807 0 0.0544975 0 0.173087)
(0.262735 -0.0073769 0 0.0605357 0 0.187605)
(0.28493 -0.0143526 0 0.0668256 0 0.203852)
(0.310724 -0.0222733 0 0.0732828 0 0.221626)
(0.339414 -0.0307421 0 0.0798045 0 0.240605)
(0.370025 -0.0393976 0 0.0862974 0 0.260328)
(0.40166 -0.0479552 0 0.092696 0 0.280391)
(0.433625 -0.0562172 0 0.0989636 0 0.30049)
(0.465471 -0.0640773 0 0.105088 0 0.320437)
(0.496959 -0.0715158 0 0.111066 0 0.340138)
(0.527914 -0.0785642 0 0.116913 0 0.359517)
(0.558201 -0.0852882 0 0.122663 0 0.378515)
(0.587692 -0.091771 0 0.128365 0 0.39707)
(0.61623 -0.0980992 0 0.134081 0 0.415108)
(0.643611 -0.104348 0 0.139882 0 0.432526)
(0.669596 -0.110562 0 0.145832 0 0.449204)
(0.69388 -0.116716 0 0.151973 0 0.464981)
(0.716372 -0.12278 0 0.158319 0 0.479821)
(0.737622 -0.128862 0 0.164895 0 0.494019)
(0.758129 -0.13508 0 0.171709 0 0.50783)
(0.778135 -0.14152 0 0.178786 0 0.521381)
(0.797716 -0.148192 0 0.186101 0 0.534704)
(0.816854 -0.155052 0 0.193597 0 0.547775)
(0.835552 -0.162057 0 0.201235 0 0.560583)
(0.853798 -0.169174 0 0.208984 0 0.573114)
(0.871578 -0.176373 0 0.21682 0 0.585353)
(0.888869 -0.183631 0 0.224719 0 0.597283)
(0.905648 -0.190926 0 0.232661 0 0.608884)
(0.921888 -0.19824 0 0.240626 0 0.620138)
(0.937564 -0.205554 0 0.24859 0 0.631024)
(0.952649 -0.212849 0 0.256532 0 0.641524)
(0.967117 -0.220106 0 0.264426 0 0.651617)
(0.980942 -0.227306 0 0.272248 0 0.661283)
(0.9941 -0.234432 0 0.279969 0 0.670502)
(1.00657 -0.241465 0 0.287557 0 0.679258)
(1.01834 -0.24838 0 0.29497 0 0.687532)
(1.02941 -0.255151 0 0.302164 0 0.695312)
(1.03976 -0.261748 0 0.30909 0 0.70259)
(1.04942 -0.268145 0 0.315701 0 0.709366)
(1.05842 -0.274322 0 0.321944 0 0.715645)
(1.0668 -0.280289 0 0.327782 0 0.721446)
(1.07464 -0.286103 0 0.333206 0 0.726789)
(1.08183 -0.291757 0 0.338244 0 0.731629)
(1.0879 -0.296937 0 0.342917 0 0.735755)
(1.09251 -0.301268 0 0.347115 0 0.739002)
(1.09588 -0.304771 0 0.35063 0 0.74145)
(1.09816 -0.307481 0 0.353351 0 0.743159)
(1.09933 -0.309483 0 0.355276 0 0.744106)
(1.099 -0.311027 0 0.356611 0 0.74409)
(1.09613 -0.312583 0 0.357916 0 0.742618)
(1.08981 -0.314296 0 0.359608 0 0.739303)
(1.08175 -0.315305 0 0.360481 0 0.734918)
(1.07648 -0.315107 0 0.359023 0 0.731515)
(1.07285 -0.314254 0 0.357136 0 0.72871)
(1.06906 -0.313266 0 0.355555 0 0.725684)
(1.0637 -0.312118 0 0.354268 0 0.721807)
(1.05669 -0.310462 0 0.352667 0 0.71701)
(1.04832 -0.308188 0 0.350465 0 0.711406)
(1.03881 -0.305288 0 0.347568 0 0.705098)
(1.02831 -0.301808 0 0.343982 0 0.698169)
(1.01696 -0.297809 0 0.33976 0 0.690693)
(1.00488 -0.293355 0 0.334967 0 0.682734)
(0.992139 -0.288503 0 0.329679 0 0.674344)
(0.978815 -0.2833 0 0.323968 0 0.665573)
(0.96493 -0.277785 0 0.317917 0 0.65645)
(0.950562 -0.271973 0 0.31159 0 0.647029)
(0.935544 -0.265843 0 0.305093 0 0.637262)
(0.920215 -0.259296 0 0.29844 0 0.627328)
(0.903554 -0.252032 0 0.291801 0 0.616844)
(0.888146 -0.243746 0 0.285102 0 0.607027)
(0.868704 -0.232423 0 0.277938 0 0.595738)
(0.861757 -0.224676 0 0.274764 0 0.590841)
(0.0139495 0.00335067 0 0.0206173 0 0.0248838)
(0.0305796 -0.00118024 0 0.0282017 0 0.0424304)
(0.0453118 -0.00133508 0 0.0310923 0 0.0510879)
(0.0565574 -0.00154787 0 0.0317369 0 0.0563109)
(0.0663408 -0.00180995 0 0.0311562 0 0.0600637)
(0.0756804 -0.00203884 0 0.0294856 0 0.0629463)
(0.083498 -0.00209563 0 0.0282272 0 0.0655811)
(0.090545 -0.00204502 0 0.0272539 0 0.0681166)
(0.0971195 -0.00213519 0 0.0265535 0 0.0706064)
(0.103534 -0.00245088 0 0.0261415 0 0.0731544)
(0.109927 -0.00290024 0 0.025947 0 0.0757755)
(0.116692 -0.00336372 0 0.0259407 0 0.0786353)
(0.124325 -0.0038218 0 0.026133 0 0.0819685)
(0.133368 -0.00439338 0 0.0265667 0 0.0860395)
(0.144351 -0.00527839 0 0.0273132 0 0.0911163)
(0.157713 -0.00669392 0 0.028463 0 0.0974381)
(0.173614 -0.00878016 0 0.0301027 0 0.105135)
(0.19164 -0.0114443 0 0.0322603 0 0.114101)
(0.210472 -0.0142088 0 0.0348329 0 0.123866)
(0.227965 -0.0162423 0 0.0375674 0 0.133632)
(0.241851 -0.0167025 0 0.0401998 0 0.142578)
(0.250728 -0.0152601 0 0.0426945 0 0.150247)
(0.254961 -0.0123816 0 0.0453734 0 0.156877)
(0.257134 -0.00921352 0 0.0487808 0 0.163535)
(0.261043 -0.00716571 0 0.0533344 0 0.17171)
(0.270043 -0.00737224 0 0.0591058 0 0.182638)
(0.286337 -0.0104107 0 0.0658659 0 0.197051)
(0.310875 -0.0163239 0 0.0732925 0 0.215184)
(0.3434 -0.0247789 0 0.0811437 0 0.236815)
(0.382511 -0.035208 0 0.0893159 0 0.261271)
(0.426086 -0.0469477 0 0.0978156 0 0.287619)
(0.471703 -0.0593252 0 0.10665 0 0.314803)
(0.517026 -0.0717493 0 0.115787 0 0.34178)
(0.560383 -0.083824 0 0.125187 0 0.367795)
(0.600956 -0.0953625 0 0.13482 0 0.392478)
(0.638645 -0.106337 0 0.144652 0 0.415777)
(0.67378 -0.116811 0 0.154644 0 0.437835)
(0.706854 -0.126884 0 0.16475 0 0.458865)
(0.738364 -0.136662 0 0.174929 0 0.479089)
(0.768737 -0.146244 0 0.185152 0 0.498696)
(0.798294 -0.15572 0 0.195401 0 0.517833)
(0.827269 -0.16516 0 0.20567 0 0.536603)
(0.855818 -0.174621 0 0.215965 0 0.55508)
(0.884073 -0.184158 0 0.226308 0 0.573325)
(0.912189 -0.193851 0 0.236746 0 0.59141)
(0.940331 -0.203803 0 0.247343 0 0.609421)
(0.968617 -0.214065 0 0.258126 0 0.627418)
(0.997126 -0.224632 0 0.26908 0 0.645436)
(1.02561 -0.23537 0 0.280088 0 0.663343)
(1.05387 -0.246209 0 0.291109 0 0.681044)
(1.0818 -0.257126 0 0.302159 0 0.698486)
(1.10928 -0.268102 0 0.313244 0 0.715622)
(1.13622 -0.279113 0 0.32436 0 0.732408)
(1.16256 -0.290135 0 0.335493 0 0.748805)
(1.18823 -0.301142 0 0.346626 0 0.764778)
(1.21317 -0.312109 0 0.357735 0 0.780294)
(1.23733 -0.323008 0 0.368796 0 0.795322)
(1.26066 -0.333815 0 0.37978 0 0.80983)
(1.28312 -0.3445 0 0.390657 0 0.823789)
(1.30464 -0.355037 0 0.401394 0 0.837168)
(1.3252 -0.365396 0 0.411957 0 0.849936)
(1.34473 -0.375554 0 0.422314 0 0.862063)
(1.36317 -0.385477 0 0.432421 0 0.873509)
(1.38048 -0.39513 0 0.442229 0 0.884242)
(1.39661 -0.404471 0 0.451685 0 0.894234)
(1.41154 -0.413461 0 0.460736 0 0.903466)
(1.42526 -0.422055 0 0.469324 0 0.911928)
(1.43778 -0.4302 0 0.477381 0 0.919614)
(1.44911 -0.43784 0 0.484839 0 0.926525)
(1.45923 -0.444905 0 0.491633 0 0.932631)
(1.468 -0.451344 0 0.497762 0 0.93787)
(1.4752 -0.457125 0 0.503288 0 0.942135)
(1.4806 -0.462144 0 0.508162 0 0.945319)
(1.4842 -0.466282 0 0.512201 0 0.947421)
(1.48612 -0.469518 0 0.5153 0 0.948477)
(1.4864 -0.471972 0 0.517466 0 0.948486)
(1.48487 -0.473929 0 0.518906 0 0.947381)
(1.48108 -0.475622 0 0.519915 0 0.944966)
(1.47428 -0.476691 0 0.520499 0 0.94097)
(1.46497 -0.47621 0 0.519987 0 0.935637)
(1.45519 -0.473916 0 0.517662 0 0.929859)
(1.4458 -0.470815 0 0.514282 0 0.924015)
(1.436 -0.467455 0 0.51042 0 0.917771)
(1.42493 -0.463745 0 0.506139 0 0.910766)
(1.41232 -0.459422 0 0.501264 0 0.902888)
(1.39824 -0.45439 0 0.495694 0 0.894175)
(1.38283 -0.448642 0 0.489402 0 0.8847)
(1.36623 -0.442221 0 0.482408 0 0.874538)
(1.34857 -0.435181 0 0.474762 0 0.863761)
(1.32996 -0.427582 0 0.466528 0 0.852433)
(1.31051 -0.419483 0 0.457781 0 0.840611)
(1.29027 -0.410929 0 0.448592 0 0.828342)
(1.2693 -0.401957 0 0.439037 0 0.815659)
(1.24762 -0.392547 0 0.429161 0 0.802592)
(1.22516 -0.382667 0 0.419035 0 0.789121)
(1.20204 -0.372063 0 0.408566 0 0.77532)
(1.17781 -0.360492 0 0.397793 0 0.761035)
(1.1543 -0.347322 0 0.386298 0 0.747088)
(1.1299 -0.332133 0 0.374032 0 0.733018)
(1.11888 -0.321698 0 0.364871 0 0.725565)
(0.0218225 0.00281384 0 0.0242331 0 0.0323463)
(0.0454951 -0.00299681 0 0.0337215 0 0.0528717)
(0.0639625 -0.00392178 0 0.0370671 0 0.0623877)
(0.0776711 -0.00452403 0 0.0385835 0 0.0686066)
(0.0889363 -0.00511057 0 0.0391356 0 0.0734851)
(0.0991701 -0.00578779 0 0.0389223 0 0.0776609)
(0.109047 -0.00646501 0 0.0379042 0 0.0813937)
(0.11784 -0.00706316 0 0.0374139 0 0.0849998)
(0.126128 -0.00769284 0 0.0372069 0 0.0885566)
(0.134016 -0.00847228 0 0.0372857 0 0.0920623)
(0.141809 -0.00948227 0 0.0376891 0 0.0956466)
(0.149973 -0.0107502 0 0.0384151 0 0.0995135)
(0.159064 -0.0123312 0 0.0394543 0 0.103911)
(0.169596 -0.0143222 0 0.0408181 0 0.109077)
(0.181906 -0.0168126 0 0.0425398 0 0.115187)
(0.195994 -0.0198001 0 0.0446509 0 0.122291)
(0.211359 -0.0230855 0 0.0471342 0 0.130245)
(0.226913 -0.0262089 0 0.04988 0 0.138683)
(0.241163 -0.0285151 0 0.0526973 0 0.147095)
(0.252714 -0.0293974 0 0.0554262 0 0.155024)
(0.260941 -0.0286345 0 0.058109 0 0.162321)
(0.266486 -0.0266275 0 0.0610745 0 0.169321)
(0.271336 -0.0243409 0 0.0648155 0 0.176841)
(0.278451 -0.0229977 0 0.0697287 0 0.186032)
(0.291035 -0.0237548 0 0.0759299 0 0.19811)
(0.311752 -0.0274401 0 0.083256 0 0.214057)
(0.34199 -0.0343715 0 0.0914182 0 0.234301)
(0.381317 -0.0442906 0 0.100191 0 0.258515)
(0.427821 -0.0565327 0 0.10953 0 0.285826)
(0.478797 -0.0702713 0 0.119498 0 0.315082)
(0.531446 -0.08476 0 0.130149 0 0.345092)
(0.583489 -0.099494 0 0.141484 0 0.374861)
(0.633621 -0.114259 0 0.153489 0 0.4038)
(0.681454 -0.129026 0 0.166135 0 0.431712)
(0.727166 -0.143819 0 0.179358 0 0.458654)
(0.771134 -0.158627 0 0.193059 0 0.484774)
(0.813705 -0.173396 0 0.207115 0 0.510217)
(0.855116 -0.188052 0 0.221408 0 0.535086)
(0.895512 -0.202538 0 0.235841 0 0.559445)
(0.935003 -0.216831 0 0.250351 0 0.583345)
(0.97371 -0.230948 0 0.264901 0 0.606837)
(1.01179 -0.24493 0 0.279477 0 0.629986)
(1.04942 -0.258826 0 0.294069 0 0.652866)
(1.08681 -0.272683 0 0.308667 0 0.67556)
(1.12414 -0.286543 0 0.323262 0 0.698137)
(1.1615 -0.300443 0 0.337854 0 0.720621)
(1.19873 -0.314375 0 0.352431 0 0.742946)
(1.23541 -0.328208 0 0.366878 0 0.7649)
(1.27147 -0.341932 0 0.381195 0 0.786446)
(1.30688 -0.355557 0 0.395395 0 0.807579)
(1.34163 -0.369102 0 0.409502 0 0.828283)
(1.37567 -0.382579 0 0.42353 0 0.848533)
(1.40894 -0.395983 0 0.437474 0 0.868294)
(1.44136 -0.409296 0 0.451319 0 0.887529)
(1.47288 -0.422492 0 0.465045 0 0.906201)
(1.50342 -0.435544 0 0.478625 0 0.924271)
(1.53291 -0.448422 0 0.492031 0 0.941701)
(1.56129 -0.461094 0 0.505229 0 0.958451)
(1.58848 -0.473526 0 0.518183 0 0.974483)
(1.61442 -0.485683 0 0.530855 0 0.989758)
(1.63904 -0.497531 0 0.543206 0 1.00424)
(1.66227 -0.509037 0 0.555198 0 1.01789)
(1.68399 -0.520142 0 0.566763 0 1.03062)
(1.70411 -0.530794 0 0.577846 0 1.04241)
(1.72257 -0.540947 0 0.588392 0 1.0532)
(1.73931 -0.550552 0 0.598348 0 1.06297)
(1.75431 -0.559551 0 0.60765 0 1.0717)
(1.76754 -0.567881 0 0.616232 0 1.07938)
(1.779 -0.575489 0 0.624033 0 1.08599)
(1.78861 -0.582264 0 0.630933 0 1.09147)
(1.79634 -0.588157 0 0.636875 0 1.0958)
(1.8021 -0.593167 0 0.641866 0 1.09894)
(1.80578 -0.59725 0 0.645897 0 1.10085)
(1.80733 -0.600351 0 0.648907 0 1.10151)
(1.80687 -0.602494 0 0.650859 0 1.10097)
(1.80448 -0.603807 0 0.651819 0 1.09926)
(1.80007 -0.604481 0 0.651957 0 1.09636)
(1.79326 -0.604588 0 0.651448 0 1.09214)
(1.78356 -0.603854 0 0.650239 0 1.08643)
(1.77107 -0.601606 0 0.647762 0 1.0793)
(1.75699 -0.597657 0 0.643517 0 1.07121)
(1.74233 -0.592632 0 0.637864 0 1.06259)
(1.72694 -0.586956 0 0.631274 0 1.05341)
(1.71031 -0.580692 0 0.623978 0 1.04349)
(1.69219 -0.573757 0 0.615985 0 1.03274)
(1.67259 -0.566107 0 0.60728 0 1.02119)
(1.65157 -0.557739 0 0.597866 0 1.00889)
(1.62926 -0.548682 0 0.587774 0 0.995882)
(1.60578 -0.538983 0 0.577057 0 0.982249)
(1.58124 -0.528697 0 0.56578 0 0.968049)
(1.55574 -0.517882 0 0.554019 0 0.95334)
(1.52935 -0.506579 0 0.541842 0 0.938167)
(1.50214 -0.49482 0 0.529314 0 0.922569)
(1.47413 -0.482571 0 0.516459 0 0.906566)
(1.44532 -0.469783 0 0.503302 0 0.890164)
(1.41579 -0.456165 0 0.489693 0 0.873395)
(1.38558 -0.441577 0 0.475584 0 0.856306)
(1.35617 -0.425441 0 0.460527 0 0.839541)
(1.32853 -0.408557 0 0.44494 0 0.823771)
(1.31371 -0.396618 0 0.432763 0 0.814344)
(0.0295793 0.00126444 0 0.027747 0 0.0388359)
(0.0603995 -0.00496941 0 0.0385866 0 0.061624)
(0.0825115 -0.00648814 0 0.0429318 0 0.0721647)
(0.0982157 -0.00764987 0 0.045678 0 0.0793648)
(0.110509 -0.00880961 0 0.0476726 0 0.0852487)
(0.121244 -0.010122 0 0.0491903 0 0.0904913)
(0.131004 -0.0115724 0 0.0502804 0 0.0953424)
(0.140427 -0.013096 0 0.0508809 0 0.0999141)
(0.150151 -0.0147205 0 0.050779 0 0.104305)
(0.159288 -0.0165516 0 0.0513617 0 0.10869)
(0.168321 -0.0187186 0 0.0525169 0 0.113225)
(0.177637 -0.0213107 0 0.0542034 0 0.11806)
(0.187601 -0.0243844 0 0.0563806 0 0.123351)
(0.198454 -0.0279579 0 0.0590155 0 0.12921)
(0.210207 -0.0319628 0 0.0620648 0 0.135667)
(0.222561 -0.036186 0 0.0654497 0 0.14263)
(0.234892 -0.0402404 0 0.0690351 0 0.149892)
(0.246381 -0.0436121 0 0.0726431 0 0.157181)
(0.256293 -0.0458089 0 0.0761263 0 0.164276)
(0.264355 -0.0465816 0 0.0794795 0 0.171151)
(0.27109 -0.046114 0 0.0829146 0 0.178092)
(0.27796 -0.0450731 0 0.0868148 0 0.185735)
(0.287223 -0.0444741 0 0.091578 0 0.195003)
(0.301583 -0.0454395 0 0.0974627 0 0.206971)
(0.323621 -0.0489614 0 0.104542 0 0.222636)
(0.354911 -0.0556173 0 0.112748 0 0.242533)
(0.395331 -0.0653746 0 0.121986 0 0.266491)
(0.443196 -0.0776758 0 0.132244 0 0.293737)
(0.495995 -0.0917477 0 0.143566 0 0.323212)
(0.55115 -0.106905 0 0.155976 0 0.353828)
(0.606733 -0.12275 0 0.16946 0 0.384751)
(0.661728 -0.139157 0 0.183981 0 0.415519)
(0.71584 -0.156114 0 0.199473 0 0.445971)
(0.769111 -0.173575 0 0.215815 0 0.476096)
(0.821618 -0.191404 0 0.232838 0 0.505906)
(0.873328 -0.209397 0 0.250353 0 0.535378)
(0.924116 -0.227358 0 0.268181 0 0.564452)
(0.973838 -0.245141 0 0.286186 0 0.593064)
(1.02241 -0.262679 0 0.304282 0 0.621171)
(1.06984 -0.279977 0 0.322425 0 0.648769)
(1.11626 -0.297079 0 0.340601 0 0.675897)
(1.16184 -0.314035 0 0.358795 0 0.702616)
(1.2068 -0.330882 0 0.376983 0 0.728993)
(1.25132 -0.34765 0 0.39514 0 0.755088)
(1.29554 -0.364346 0 0.413219 0 0.780938)
(1.33936 -0.380888 0 0.431086 0 0.806469)
(1.38257 -0.397181 0 0.448613 0 0.831563)
(1.42512 -0.413249 0 0.465834 0 0.8562)
(1.46697 -0.429134 0 0.482798 0 0.880364)
(1.50808 -0.444859 0 0.499539 0 0.90404)
(1.54842 -0.460434 0 0.516075 0 0.927204)
(1.58785 -0.475843 0 0.532392 0 0.949793)
(1.62627 -0.491065 0 0.548474 0 0.971753)
(1.6636 -0.506077 0 0.564302 0 0.993043)
(1.69976 -0.520847 0 0.579852 0 1.01362)
(1.73466 -0.535345 0 0.595093 0 1.03343)
(1.7682 -0.549537 0 0.609993 0 1.05244)
(1.80031 -0.563386 0 0.624514 0 1.0706)
(1.83089 -0.576854 0 0.638616 0 1.08786)
(1.85986 -0.589903 0 0.652259 0 1.10417)
(1.88717 -0.602505 0 0.665408 0 1.11951)
(1.91271 -0.614619 0 0.67802 0 1.13383)
(1.93622 -0.626114 0 0.689957 0 1.14696)
(1.95766 -0.636969 0 0.701191 0 1.1589)
(1.97698 -0.647139 0 0.711676 0 1.16962)
(1.99412 -0.65657 0 0.721349 0 1.17909)
(2.00904 -0.665197 0 0.730142 0 1.18727)
(2.02168 -0.672949 0 0.73798 0 1.19416)
(2.03204 -0.679751 0 0.744781 0 1.19971)
(2.04008 -0.68554 0 0.750472 0 1.20392)
(2.04582 -0.690297 0 0.755023 0 1.20679)
(2.04925 -0.694035 0 0.758441 0 1.2083)
(2.05034 -0.696747 0 0.76072 0 1.20847)
(2.04907 -0.698408 0 0.761828 0 1.20728)
(2.04555 -0.699047 0 0.761764 0 1.20479)
(2.03984 -0.698764 0 0.760599 0 1.20103)
(2.03188 -0.69767 0 0.758457 0 1.19602)
(2.02143 -0.695778 0 0.755432 0 1.18968)
(2.00815 -0.69286 0 0.751433 0 1.18191)
(1.99204 -0.68851 0 0.746127 0 1.17272)
(1.97384 -0.682632 0 0.739245 0 1.16239)
(1.95435 -0.675618 0 0.731021 0 1.15125)
(1.93373 -0.667793 0 0.721779 0 1.13941)
(1.91181 -0.659268 0 0.711713 0 1.12683)
(1.88847 -0.650037 0 0.700889 0 1.1135)
(1.86371 -0.640098 0 0.689349 0 1.09943)
(1.83759 -0.629469 0 0.677138 0 1.08467)
(1.81021 -0.618188 0 0.664311 0 1.06927)
(1.78169 -0.606306 0 0.650933 0 1.0533)
(1.75214 -0.593881 0 0.637077 0 1.03682)
(1.72166 -0.580968 0 0.622815 0 1.01989)
(1.69034 -0.567606 0 0.608209 0 1.00254)
(1.65825 -0.553822 0 0.593314 0 0.984829)
(1.62542 -0.539573 0 0.578134 0 0.966756)
(1.59191 -0.524812 0 0.562666 0 0.948355)
(1.55782 -0.509274 0 0.546734 0 0.929646)
(1.52358 -0.492935 0 0.530294 0 0.910827)
(1.49044 -0.475381 0 0.512954 0 0.892438)
(1.46107 -0.45816 0 0.49564 0 0.875852)
(1.44368 -0.445702 0 0.481818 0 0.865222)
(0.0351161 -0.00154025 0 0.0318871 0 0.0445159)
(0.0733731 -0.00727623 0 0.0438094 0 0.0693608)
(0.0990494 -0.00962081 0 0.049298 0 0.08091)
(0.116723 -0.0115537 0 0.0532958 0 0.089017)
(0.130066 -0.0135076 0 0.0567022 0 0.0958119)
(0.141401 -0.0156427 0 0.0597506 0 0.101954)
(0.151458 -0.0180016 0 0.0624659 0 0.1077)
(0.1611 -0.0206066 0 0.0648209 0 0.113226)
(0.17091 -0.0235084 0 0.0667471 0 0.118648)
(0.181426 -0.0267529 0 0.0681564 0 0.124074)
(0.191553 -0.0304072 0 0.070505 0 0.12957)
(0.201693 -0.0345734 0 0.0736409 0 0.135277)
(0.212035 -0.0392855 0 0.077495 0 0.141283)
(0.22266 -0.0444793 0 0.0819699 0 0.147626)
(0.233461 -0.0499723 0 0.0869311 0 0.154271)
(0.244152 -0.0554445 0 0.0921891 0 0.16111)
(0.254328 -0.0604674 0 0.0975097 0 0.167996)
(0.263622 -0.0645923 0 0.102658 0 0.174809)
(0.271928 -0.067494 0 0.107481 0 0.18155)
(0.279633 -0.0691276 0 0.111986 0 0.188432)
(0.287774 -0.0698359 0 0.116381 0 0.195931)
(0.298047 -0.0703484 0 0.121022 0 0.204785)
(0.312626 -0.071659 0 0.126312 0 0.215903)
(0.333771 -0.0748137 0 0.132602 0 0.230206)
(0.363198 -0.080643 0 0.14015 0 0.248359)
(0.401381 -0.0894921 0 0.149119 0 0.270493)
(0.447329 -0.101129 0 0.159585 0 0.296144)
(0.499063 -0.114925 0 0.171543 0 0.324462)
(0.554418 -0.130189 0 0.184911 0 0.354528)
(0.611692 -0.146453 0 0.199592 0 0.385608)
(0.669895 -0.163536 0 0.21552 0 0.417253)
(0.728591 -0.181414 0 0.232647 0 0.449252)
(0.787575 -0.200063 0 0.250893 0 0.481493)
(0.846602 -0.219358 0 0.270114 0 0.513856)
(0.90537 -0.239104 0 0.290122 0 0.546201)
(0.963552 -0.259087 0 0.310725 0 0.578378)
(1.02087 -0.279132 0 0.331746 0 0.610257)
(1.07717 -0.299131 0 0.353044 0 0.641748)
(1.1324 -0.319032 0 0.374515 0 0.67281)
(1.18664 -0.338828 0 0.396087 0 0.703444)
(1.24005 -0.358535 0 0.417703 0 0.733688)
(1.29279 -0.378155 0 0.439303 0 0.763578)
(1.34495 -0.397663 0 0.460813 0 0.79312)
(1.39651 -0.417001 0 0.482136 0 0.822271)
(1.44713 -0.435989 0 0.503033 0 0.85086)
(1.49666 -0.454562 0 0.523422 0 0.878807)
(1.54512 -0.472734 0 0.543321 0 0.906104)
(1.59253 -0.490538 0 0.56276 0 0.932757)
(1.6389 -0.508011 0 0.581774 0 0.958768)
(1.68423 -0.525184 0 0.600399 0 0.984135)
(1.72854 -0.542093 0 0.618671 0 1.00886)
(1.77151 -0.558648 0 0.636496 0 1.03278)
(1.81314 -0.574863 0 0.653892 0 1.05589)
(1.85336 -0.590722 0 0.670847 0 1.07816)
(1.89209 -0.606197 0 0.687336 0 1.09954)
(1.92923 -0.621255 0 0.703326 0 1.11998)
(1.96468 -0.635858 0 0.718781 0 1.13945)
(1.99834 -0.649965 0 0.733658 0 1.15787)
(2.0301 -0.663534 0 0.747913 0 1.1752)
(2.05986 -0.67652 0 0.761498 0 1.19139)
(2.08751 -0.688874 0 0.77436 0 1.20638)
(2.11294 -0.700538 0 0.786437 0 1.22011)
(2.13601 -0.711449 0 0.797662 0 1.23249)
(2.15663 -0.721562 0 0.807985 0 1.24351)
(2.17473 -0.730822 0 0.817347 0 1.2531)
(2.19024 -0.73917 0 0.825684 0 1.26125)
(2.2031 -0.746542 0 0.832927 0 1.26792)
(2.21329 -0.752871 0 0.839006 0 1.27309)
(2.22077 -0.7581 0 0.843854 0 1.27675)
(2.22559 -0.762189 0 0.847419 0 1.27889)
(2.22776 -0.765129 0 0.849681 0 1.27955)
(2.22733 -0.76693 0 0.85064 0 1.27873)
(2.22432 -0.767599 0 0.850308 0 1.27646)
(2.21877 -0.767142 0 0.84869 0 1.27278)
(2.21078 -0.765606 0 0.845823 0 1.26774)
(2.20043 -0.763074 0 0.841786 0 1.26139)
(2.18772 -0.759629 0 0.836686 0 1.25377)
(2.17253 -0.755278 0 0.830596 0 1.24487)
(2.15466 -0.749892 0 0.823469 0 1.23463)
(2.13414 -0.743245 0 0.815116 0 1.22309)
(2.11147 -0.735281 0 0.805387 0 1.21043)
(2.08722 -0.726228 0 0.794427 0 1.1969)
(2.06167 -0.716318 0 0.782473 0 1.18264)
(2.03482 -0.705678 0 0.769707 0 1.1677)
(2.00668 -0.694363 0 0.75624 0 1.1521)
(1.97729 -0.682413 0 0.742152 0 1.13589)
(1.94673 -0.66987 0 0.727512 0 1.11911)
(1.9151 -0.656782 0 0.712389 0 1.10184)
(1.88252 -0.643203 0 0.696854 0 1.08412)
(1.84909 -0.629186 0 0.680976 0 1.06602)
(1.81491 -0.614783 0 0.664821 0 1.04758)
(1.78006 -0.600025 0 0.648441 0 1.02885)
(1.74462 -0.584931 0 0.631878 0 1.00985)
(1.70861 -0.569461 0 0.615119 0 0.990598)
(1.67216 -0.553576 0 0.59815 0 0.971129)
(1.63536 -0.537058 0 0.580795 0 0.951467)
(1.59893 -0.519982 0 0.563051 0 0.931898)
(1.56389 -0.5021 0 0.544613 0 0.912889)
(1.53392 -0.485338 0 0.526783 0 0.896184)
(1.515 -0.473025 0 0.512385 0 0.885016)
(0.0395535 -0.00387061 0 0.0366297 0 0.049736)
(0.0841998 -0.00960088 0 0.0492442 0 0.0760356)
(0.11256 -0.0129365 0 0.0558663 0 0.0884065)
(0.131761 -0.0159781 0 0.0612119 0 0.0973803)
(0.146183 -0.0190576 0 0.0661924 0 0.105142)
(0.15853 -0.0224022 0 0.0710558 0 0.112367)
(0.169596 -0.0260884 0 0.0758288 0 0.119296)
(0.180221 -0.0301688 0 0.0804868 0 0.126076)
(0.190913 -0.0346914 0 0.0849676 0 0.132786)
(0.202128 -0.0396912 0 0.0892113 0 0.139493)
(0.214236 -0.0451696 0 0.0930681 0 0.146229)
(0.225849 -0.051135 0 0.0981109 0 0.153019)
(0.237228 -0.0575992 0 0.104092 0 0.159949)
(0.248386 -0.0644543 0 0.11085 0 0.167029)
(0.259252 -0.0714616 0 0.118145 0 0.174217)
(0.269661 -0.078264 0 0.125671 0 0.181426)
(0.279437 -0.0844439 0 0.133086 0 0.188567)
(0.288545 -0.089626 0 0.140081 0 0.195624)
(0.297263 -0.0935958 0 0.14645 0 0.202728)
(0.306342 -0.0964182 0 0.152169 0 0.210217)
(0.317064 -0.0985091 0 0.157431 0 0.218664)
(0.331195 -0.100627 0 0.162643 0 0.22884)
(0.350724 -0.103752 0 0.168349 0 0.241603)
(0.377404 -0.108856 0 0.175125 0 0.257696)
(0.412197 -0.116631 0 0.183469 0 0.277522)
(0.454828 -0.127253 0 0.19369 0 0.300957)
(0.503891 -0.140352 0 0.205826 0 0.327396)
(0.557633 -0.155304 0 0.219728 0 0.356092)
(0.614574 -0.171546 0 0.235181 0 0.386394)
(0.673752 -0.188775 0 0.252037 0 0.417864)
(0.734642 -0.206925 0 0.270239 0 0.450253)
(0.79691 -0.226023 0 0.289769 0 0.483406)
(0.860184 -0.24604 0 0.31056 0 0.517163)
(0.923829 -0.266791 0 0.332402 0 0.551229)
(0.987469 -0.288101 0 0.355118 0 0.585441)
(1.05075 -0.309769 0 0.378492 0 0.619631)
(1.11341 -0.331618 0 0.402316 0 0.65366)
(1.1753 -0.353512 0 0.426409 0 0.687426)
(1.2364 -0.375365 0 0.450622 0 0.720874)
(1.29673 -0.397136 0 0.474856 0 0.753975)
(1.35631 -0.418797 0 0.499028 0 0.786698)
(1.41509 -0.440291 0 0.523052 0 0.818989)
(1.47274 -0.461416 0 0.546658 0 0.85066)
(1.52893 -0.482016 0 0.569633 0 0.88155)
(1.58364 -0.502094 0 0.591983 0 0.911626)
(1.63685 -0.521667 0 0.613723 0 0.940877)
(1.68862 -0.540766 0 0.63488 0 0.969304)
(1.73896 -0.559418 0 0.655472 0 0.996916)
(1.78792 -0.577646 0 0.67551 0 1.02371)
(1.83547 -0.595454 0 0.694995 0 1.04968)
(1.88158 -0.612828 0 0.713909 0 1.07478)
(1.9261 -0.629741 0 0.732225 0 1.09895)
(1.96898 -0.646177 0 0.74993 0 1.12216)
(2.01011 -0.662105 0 0.766999 0 1.14435)
(2.04939 -0.677491 0 0.7834 0 1.16547)
(2.08671 -0.692299 0 0.799096 0 1.18547)
(2.12197 -0.706489 0 0.814049 0 1.2043)
(2.15504 -0.720019 0 0.828213 0 1.2219)
(2.18583 -0.732842 0 0.841542 0 1.23822)
(2.21421 -0.744911 0 0.853985 0 1.25319)
(2.24008 -0.756173 0 0.865485 0 1.26677)
(2.26333 -0.766576 0 0.875986 0 1.27889)
(2.28385 -0.776068 0 0.885433 0 1.28951)
(2.30156 -0.7846 0 0.893775 0 1.29858)
(2.31639 -0.792118 0 0.900955 0 1.30606)
(2.32827 -0.798569 0 0.906916 0 1.31194)
(2.33716 -0.803897 0 0.9116 0 1.31618)
(2.34304 -0.808054 0 0.914955 0 1.31878)
(2.34592 -0.811 0 0.916935 0 1.31975)
(2.34586 -0.812713 0 0.917511 0 1.3191)
(2.34292 -0.813198 0 0.916682 0 1.31687)
(2.33718 -0.812477 0 0.914466 0 1.31311)
(2.32873 -0.810578 0 0.910895 0 1.30786)
(2.31765 -0.807536 0 0.906006 0 1.30119)
(2.30408 -0.803408 0 0.899857 0 1.29317)
(2.28815 -0.798275 0 0.892538 0 1.28389)
(2.2699 -0.792213 0 0.884154 0 1.2734)
(2.24932 -0.785249 0 0.874781 0 1.26174)
(2.22636 -0.777322 0 0.864421 0 1.24891)
(2.20108 -0.76832 0 0.852991 0 1.23497)
(2.17382 -0.758222 0 0.840433 0 1.22005)
(2.14503 -0.747179 0 0.826862 0 1.20434)
(2.11501 -0.735371 0 0.81246 0 1.188)
(2.08387 -0.722926 0 0.797389 0 1.17111)
(2.0517 -0.709922 0 0.781767 0 1.15373)
(2.01859 -0.696421 0 0.765689 0 1.13592)
(1.98462 -0.682476 0 0.749236 0 1.11774)
(1.94991 -0.66814 0 0.732479 0 1.09925)
(1.91455 -0.653464 0 0.715489 0 1.08049)
(1.87864 -0.638497 0 0.698327 0 1.06152)
(1.84226 -0.623278 0 0.681048 0 1.04238)
(1.80549 -0.607834 0 0.663691 0 1.02308)
(1.76837 -0.592173 0 0.64628 0 1.00366)
(1.73095 -0.576257 0 0.628792 0 0.984116)
(1.69335 -0.560056 0 0.611205 0 0.96449)
(1.65569 -0.543404 0 0.59336 0 0.944803)
(1.6188 -0.526442 0 0.575297 0 0.925384)
(1.58355 -0.509062 0 0.556801 0 0.906637)
(1.55408 -0.493327 0 0.539397 0 0.890462)
(1.53469 -0.481664 0 0.525265 0 0.879374)
(0.0436991 -0.00620038 0 0.0402474 0 0.0535173)
(0.0923456 -0.0122889 0 0.0543333 0 0.0812028)
(0.122712 -0.0170457 0 0.062601 0 0.0947363)
(0.143522 -0.0215664 0 0.0697989 0 0.104955)
(0.159625 -0.0261897 0 0.0768947 0 0.114089)
(0.173842 -0.0311984 0 0.0841639 0 0.122824)
(0.186987 -0.0366809 0 0.0916423 0 0.131393)
(0.199855 -0.042699 0 0.0993139 0 0.139922)
(0.212846 -0.0492751 0 0.107103 0 0.148459)
(0.226314 -0.0564085 0 0.114914 0 0.157021)
(0.240465 -0.0640596 0 0.122606 0 0.165587)
(0.255576 -0.0721424 0 0.129875 0 0.174096)
(0.269761 -0.0805703 0 0.138425 0 0.18259)
(0.283243 -0.0892302 0 0.147824 0 0.191071)
(0.295964 -0.0978735 0 0.157748 0 0.199486)
(0.307866 -0.106133 0 0.167747 0 0.207746)
(0.31892 -0.113611 0 0.177389 0 0.215791)
(0.329328 -0.119997 0 0.186305 0 0.223667)
(0.339669 -0.12517 0 0.194265 0 0.231602)
(0.350973 -0.129282 0 0.201232 0 0.24003)
(0.364707 -0.132803 0 0.207428 0 0.24959)
(0.382703 -0.136531 0 0.213383 0 0.261096)
(0.406741 -0.141434 0 0.219835 0 0.275345)
(0.438065 -0.148393 0 0.227567 0 0.29291)
(0.477135 -0.15799 0 0.237257 0 0.314052)
(0.523095 -0.170227 0 0.249187 0 0.338433)
(0.574193 -0.18458 0 0.263181 0 0.365286)
(0.629257 -0.200527 0 0.278994 0 0.394116)
(0.687407 -0.217647 0 0.29634 0 0.424512)
(0.748137 -0.235746 0 0.315055 0 0.456211)
(0.81112 -0.254802 0 0.335087 0 0.489047)
(0.875987 -0.274831 0 0.356419 0 0.522859)
(0.942226 -0.295783 0 0.378975 0 0.557436)
(1.00925 -0.317522 0 0.402607 0 0.592532)
(1.07657 -0.339865 0 0.427121 0 0.627925)
(1.14376 -0.362605 0 0.45229 0 0.663413)
(1.21055 -0.385554 0 0.477885 0 0.698835)
(1.27676 -0.408568 0 0.503704 0 0.734066)
(1.34229 -0.431547 0 0.529586 0 0.769014)
(1.40705 -0.454418 0 0.555401 0 0.803594)
(1.47075 -0.477038 0 0.580941 0 0.837635)
(1.53287 -0.499173 0 0.60589 0 0.87088)
(1.59326 -0.520773 0 0.63018 0 0.903244)
(1.65186 -0.541834 0 0.653798 0 0.93468)
(1.70867 -0.562355 0 0.676741 0 0.965167)
(1.76367 -0.58233 0 0.698991 0 0.994686)
(1.81689 -0.601751 0 0.720532 0 1.02323)
(1.86833 -0.620607 0 0.741343 0 1.05079)
(1.91799 -0.638887 0 0.76141 0 1.07734)
(1.96582 -0.656575 0 0.780713 0 1.10286)
(2.01178 -0.673655 0 0.799235 0 1.12732)
(2.05578 -0.690111 0 0.816964 0 1.15066)
(2.09774 -0.705923 0 0.833881 0 1.17285)
(2.13755 -0.721064 0 0.849963 0 1.19385)
(2.17512 -0.7355 0 0.865175 0 1.21359)
(2.21034 -0.749196 0 0.879484 0 1.23202)
(2.24309 -0.762111 0 0.892847 0 1.2491)
(2.27328 -0.774202 0 0.905221 0 1.26477)
(2.3008 -0.785424 0 0.916558 0 1.27898)
(2.32553 -0.795727 0 0.926808 0 1.29167)
(2.34738 -0.805062 0 0.935918 0 1.30279)
(2.36626 -0.813382 0 0.943839 0 1.3123)
(2.38209 -0.820641 0 0.950525 0 1.32017)
(2.39479 -0.826797 0 0.955932 0 1.32635)
(2.40432 -0.831807 0 0.960017 0 1.33082)
(2.41063 -0.835633 0 0.96274 0 1.33358)
(2.41372 -0.838239 0 0.964066 0 1.33462)
(2.41361 -0.839597 0 0.963966 0 1.33394)
(2.41035 -0.839691 0 0.962422 0 1.33158)
(2.404 -0.838522 0 0.959431 0 1.32758)
(2.3947 -0.83611 0 0.955014 0 1.32199)
(2.38257 -0.832494 0 0.94921 0 1.31489)
(2.36773 -0.827721 0 0.942073 0 1.30635)
(2.35034 -0.821846 0 0.933667 0 1.29646)
(2.33058 -0.814942 0 0.924076 0 1.28532)
(2.3086 -0.807097 0 0.913404 0 1.27303)
(2.28454 -0.798395 0 0.901765 0 1.25969)
(2.25846 -0.788886 0 0.889255 0 1.24535)
(2.23041 -0.778568 0 0.875917 0 1.23008)
(2.20051 -0.767403 0 0.861743 0 1.21395)
(2.16903 -0.755399 0 0.84673 0 1.19708)
(2.13633 -0.742668 0 0.830977 0 1.17962)
(2.10269 -0.729351 0 0.814631 0 1.16171)
(2.06828 -0.715566 0 0.797833 0 1.14346)
(2.03322 -0.701397 0 0.780701 0 1.12494)
(1.99762 -0.686914 0 0.76333 0 1.10621)
(1.96158 -0.672172 0 0.745798 0 1.08734)
(1.9252 -0.657222 0 0.728172 0 1.06836)
(1.88856 -0.642106 0 0.710511 0 1.04933)
(1.85172 -0.626862 0 0.692862 0 1.03028)
(1.81476 -0.611517 0 0.675263 0 1.01122)
(1.7777 -0.596084 0 0.657734 0 0.992176)
(1.74059 -0.580562 0 0.640285 0 0.973151)
(1.70345 -0.564912 0 0.622881 0 0.954136)
(1.6664 -0.549108 0 0.605493 0 0.935167)
(1.62954 -0.533033 0 0.587985 0 0.916261)
(1.59376 -0.516861 0 0.57043 0 0.897756)
(1.55976 -0.500595 0 0.552697 0 0.879999)
(1.53177 -0.486272 0 0.536389 0 0.864897)
(1.5129 -0.475622 0 0.523146 0 0.854408)
(0.0459532 -0.00885384 0 0.0438662 0 0.0563056)
(0.0971908 -0.0154143 0 0.0599395 0 0.085633)
(0.129648 -0.0219971 0 0.0703365 0 0.100707)
(0.152777 -0.0285292 0 0.0800071 0 0.11264)
(0.171667 -0.0353119 0 0.0899536 0 0.123697)
(0.189226 -0.0426691 0 0.100467 0 0.134582)
(0.206264 -0.050671 0 0.11158 0 0.145525)
(0.223507 -0.0593574 0 0.123271 0 0.156648)
(0.241198 -0.068693 0 0.135426 0 0.167957)
(0.259501 -0.0786151 0 0.147895 0 0.17942)
(0.278418 -0.0890212 0 0.160449 0 0.190945)
(0.297944 -0.0997713 0 0.172765 0 0.202409)
(0.318292 -0.110666 0 0.184167 0 0.213637)
(0.33692 -0.121531 0 0.196654 0 0.224633)
(0.354142 -0.132167 0 0.209537 0 0.235335)
(0.369847 -0.142174 0 0.222256 0 0.245597)
(0.384102 -0.151169 0 0.234266 0 0.255339)
(0.397323 -0.158955 0 0.245245 0 0.264674)
(0.410415 -0.165524 0 0.255002 0 0.27394)
(0.424707 -0.171101 0 0.263506 0 0.283665)
(0.441835 -0.176191 0 0.270995 0 0.294538)
(0.463817 -0.181652 0 0.278163 0 0.307486)
(0.492098 -0.188386 0 0.285868 0 0.323167)
(0.527203 -0.197092 0 0.294959 0 0.341869)
(0.569124 -0.208174 0 0.306115 0 0.363707)
(0.616886 -0.221538 0 0.319546 0 0.388333)
(0.669197 -0.236762 0 0.335062 0 0.415214)
(0.725087 -0.253389 0 0.352325 0 0.443915)
(0.783958 -0.271092 0 0.371024 0 0.474129)
(0.845525 -0.289734 0 0.390995 0 0.505678)
(0.909568 -0.309304 0 0.412191 0 0.538438)
(0.975741 -0.329805 0 0.434584 0 0.572257)
(1.04353 -0.351184 0 0.458098 0 0.606928)
(1.11237 -0.373322 0 0.482602 0 0.642215)
(1.18171 -0.396044 0 0.507899 0 0.677874)
(1.25111 -0.41916 0 0.533774 0 0.713685)
(1.32021 -0.442487 0 0.560003 0 0.749457)
(1.38876 -0.465871 0 0.586374 0 0.785024)
(1.45641 -0.489137 0 0.612644 0 0.820191)
(1.5226 -0.512011 0 0.638428 0 0.854664)
(1.58702 -0.534362 0 0.663547 0 0.888278)
(1.64955 -0.556153 0 0.687955 0 0.920956)
(1.71011 -0.577363 0 0.711627 0 0.952645)
(1.76864 -0.597976 0 0.734546 0 0.9833)
(1.82508 -0.617968 0 0.756685 0 1.01288)
(1.8794 -0.637314 0 0.778015 0 1.04137)
(1.93159 -0.655994 0 0.798509 0 1.06872)
(1.98161 -0.673987 0 0.818141 0 1.09493)
(2.02946 -0.691277 0 0.836888 0 1.11997)
(2.07508 -0.707846 0 0.854725 0 1.14381)
(2.11844 -0.723675 0 0.871631 0 1.16641)
(2.15947 -0.738746 0 0.887586 0 1.18774)
(2.19807 -0.753035 0 0.902566 0 1.20775)
(2.23417 -0.766511 0 0.916541 0 1.22641)
(2.26766 -0.779139 0 0.929475 0 1.24365)
(2.29845 -0.790878 0 0.941332 0 1.25944)
(2.32642 -0.801689 0 0.952069 0 1.27371)
(2.35147 -0.811528 0 0.961644 0 1.28643)
(2.37353 -0.820351 0 0.970012 0 1.29754)
(2.39248 -0.828112 0 0.977129 0 1.30699)
(2.40825 -0.83477 0 0.982952 0 1.31477)
(2.42079 -0.840288 0 0.987443 0 1.32082)
(2.43004 -0.844634 0 0.990572 0 1.32513)
(2.43597 -0.847781 0 0.992313 0 1.3277)
(2.43856 -0.849707 0 0.992644 0 1.3285)
(2.43783 -0.850393 0 0.991551 0 1.32756)
(2.43379 -0.84983 0 0.989023 0 1.32489)
(2.42653 -0.848013 0 0.985062 0 1.32053)
(2.41613 -0.844951 0 0.979677 0 1.31452)
(2.40271 -0.840666 0 0.972893 0 1.30694)
(2.38643 -0.835198 0 0.964754 0 1.29785)
(2.36746 -0.8286 0 0.955322 0 1.28736)
(2.34599 -0.82094 0 0.944674 0 1.27556)
(2.32221 -0.81229 0 0.932897 0 1.26257)
(2.29634 -0.80274 0 0.920097 0 1.2485)
(2.26859 -0.792387 0 0.90639 0 1.23349)
(2.23915 -0.781327 0 0.891904 0 1.21764)
(2.20815 -0.769633 0 0.876749 0 1.20105)
(2.17572 -0.757341 0 0.861002 0 1.18381)
(2.14201 -0.74446 0 0.844699 0 1.166)
(2.10725 -0.731022 0 0.827876 0 1.14773)
(2.07175 -0.717114 0 0.810622 0 1.12914)
(2.03575 -0.702853 0 0.793058 0 1.11036)
(1.99944 -0.688338 0 0.775305 0 1.09148)
(1.96294 -0.67365 0 0.757462 0 1.07257)
(1.92636 -0.658848 0 0.739612 0 1.05369)
(1.88979 -0.643984 0 0.72182 0 1.03489)
(1.8533 -0.629094 0 0.704139 0 1.01621)
(1.81695 -0.614208 0 0.686608 0 0.997666)
(1.78077 -0.599349 0 0.669258 0 0.979281)
(1.74478 -0.584527 0 0.652106 0 0.961058)
(1.709 -0.569741 0 0.635153 0 0.94299)
(1.67343 -0.55498 0 0.618392 0 0.925071)
(1.63806 -0.540199 0 0.601778 0 0.907278)
(1.60302 -0.52538 0 0.585278 0 0.889635)
(1.56836 -0.510435 0 0.568777 0 0.872152)
(1.53496 -0.495558 0 0.55237 0 0.855154)
(1.50339 -0.480826 0 0.535995 0 0.83894)
(1.47772 -0.468155 0 0.52123 0 0.825323)
(1.46017 -0.458753 0 0.509295 0 0.815828)
(0.0462852 -0.0114109 0 0.0472291 0 0.058103)
(0.0995855 -0.0194202 0 0.0660848 0 0.0896414)
(0.134971 -0.02877 0 0.0799646 0 0.107175)
(0.161704 -0.0379891 0 0.0933223 0 0.121692)
(0.185231 -0.0477406 0 0.107407 0 0.135612)
(0.208447 -0.0583815 0 0.122577 0 0.149714)
(0.232154 -0.0699145 0 0.138844 0 0.164258)
(0.256991 -0.082323 0 0.156151 0 0.179375)
(0.282967 -0.0954841 0 0.174287 0 0.195008)
(0.309991 -0.109253 0 0.193017 0 0.211049)
(0.337756 -0.123448 0 0.212022 0 0.227308)
(0.36593 -0.137851 0 0.230882 0 0.243552)
(0.3942 -0.15219 0 0.248947 0 0.259484)
(0.422847 -0.1661 0 0.264824 0 0.274758)
(0.448572 -0.179402 0 0.281154 0 0.28938)
(0.471702 -0.191691 0 0.29666 0 0.303054)
(0.492066 -0.202666 0 0.311113 0 0.315648)
(0.510332 -0.212252 0 0.32433 0 0.327366)
(0.527849 -0.220588 0 0.33619 0 0.338702)
(0.546213 -0.227915 0 0.346576 0 0.350229)
(0.567027 -0.23469 0 0.355652 0 0.36255)
(0.592262 -0.241777 0 0.364227 0 0.37659)
(0.623234 -0.249999 0 0.373231 0 0.393001)
(0.660446 -0.259969 0 0.38354 0 0.41211)
(0.703644 -0.271962 0 0.395739 0 0.433934)
(0.751925 -0.285865 0 0.409981 0 0.45817)
(0.804219 -0.301335 0 0.426075 0 0.484393)
(0.8597 -0.318006 0 0.443689 0 0.512237)
(0.917892 -0.335624 0 0.462547 0 0.541451)
(0.978594 -0.354087 0 0.482511 0 0.571899)
(1.04165 -0.373382 0 0.503534 0 0.603484)
(1.10677 -0.393486 0 0.525562 0 0.636069)
(1.1735 -0.41434 0 0.548507 0 0.669467)
(1.24138 -0.435866 0 0.572276 0 0.703487)
(1.30984 -0.4579 0 0.596687 0 0.737872)
(1.37842 -0.48028 0 0.621563 0 0.772399)
(1.44656 -0.502765 0 0.646614 0 0.806787)
(1.51353 -0.525024 0 0.671409 0 0.840676)
(1.57886 -0.546846 0 0.695669 0 0.87383)
(1.64242 -0.568184 0 0.719332 0 0.906163)
(1.70407 -0.588991 0 0.74234 0 0.937589)
(1.76369 -0.609236 0 0.76465 0 0.96804)
(1.82119 -0.628888 0 0.786223 0 0.997457)
(1.87648 -0.647914 0 0.80702 0 1.02579)
(1.9295 -0.666281 0 0.826995 0 1.05298)
(1.98018 -0.683951 0 0.846103 0 1.079)
(2.02847 -0.700891 0 0.864304 0 1.1038)
(2.07434 -0.71707 0 0.881555 0 1.12735)
(2.11773 -0.732459 0 0.897821 0 1.14962)
(2.15861 -0.747027 0 0.913068 0 1.17058)
(2.19691 -0.76075 0 0.927267 0 1.19018)
(2.23257 -0.7736 0 0.94039 0 1.20839)
(2.2655 -0.785549 0 0.952409 0 1.22516)
(2.29561 -0.796561 0 0.963291 0 1.24046)
(2.32282 -0.806601 0 0.973001 0 1.25423)
(2.34704 -0.81563 0 0.981501 0 1.26643)
(2.36818 -0.823609 0 0.988755 0 1.27702)
(2.38615 -0.830501 0 0.994726 0 1.28595)
(2.40089 -0.83627 0 0.99938 0 1.2932)
(2.41235 -0.840885 0 1.00269 0 1.29873)
(2.42047 -0.844318 0 1.00462 0 1.30253)
(2.42523 -0.84655 0 1.00516 0 1.30458)
(2.42664 -0.847569 0 1.00429 0 1.30489)
(2.42469 -0.84737 0 1.00202 0 1.30346)
(2.41944 -0.845951 0 0.998349 0 1.30031)
(2.41092 -0.843318 0 0.993283 0 1.29548)
(2.39923 -0.839483 0 0.986841 0 1.28901)
(2.38447 -0.834464 0 0.979049 0 1.28095)
(2.36677 -0.828292 0 0.969942 0 1.27138)
(2.34631 -0.821006 0 0.959571 0 1.26038)
(2.32327 -0.812665 0 0.948 0 1.24806)
(2.29786 -0.803337 0 0.935311 0 1.23451)
(2.2703 -0.793104 0 0.921602 0 1.21987)
(2.24085 -0.782057 0 0.906978 0 1.20426)
(2.20975 -0.770298 0 0.89156 0 1.18782)
(2.17724 -0.757933 0 0.875479 0 1.17069)
(2.14355 -0.74507 0 0.858868 0 1.15299)
(2.10887 -0.731795 0 0.841848 0 1.13484)
(2.07337 -0.718168 0 0.824512 0 1.11635)
(2.03721 -0.704226 0 0.806923 0 1.0976)
(2.0006 -0.690009 0 0.789131 0 1.07871)
(1.96379 -0.675592 0 0.771215 0 1.05977)
(1.927 -0.661062 0 0.753271 0 1.0409)
(1.89037 -0.6465 0 0.735392 0 1.02217)
(1.85402 -0.631969 0 0.717656 0 1.00365)
(1.81804 -0.617515 0 0.700126 0 0.985378)
(1.78249 -0.603174 0 0.682846 0 0.967393)
(1.7474 -0.588967 0 0.66585 0 0.949709)
(1.7128 -0.574909 0 0.649158 0 0.932334)
(1.67867 -0.561002 0 0.632777 0 0.915264)
(1.64502 -0.547243 0 0.616707 0 0.898485)
(1.61181 -0.533615 0 0.60093 0 0.881975)
(1.57903 -0.520095 0 0.585423 0 0.865708)
(1.54662 -0.506637 0 0.570135 0 0.84965)
(1.51468 -0.493222 0 0.555028 0 0.833815)
(1.48327 -0.479789 0 0.540007 0 0.818203)
(1.45318 -0.466532 0 0.525178 0 0.803112)
(1.42487 -0.453578 0 0.510533 0 0.788801)
(1.40211 -0.44267 0 0.497557 0 0.77693)
(1.38646 -0.434627 0 0.487154 0 0.768682)
(0.0448039 -0.0133128 0 0.0513986 0 0.0595749)
(0.100516 -0.0251729 0 0.0751744 0 0.0946765)
(0.141527 -0.0382405 0 0.0938481 0 0.115937)
(0.175116 -0.0515405 0 0.112657 0 0.134491)
(0.206641 -0.0657013 0 0.132935 0 0.15288)
(0.239341 -0.0810935 0 0.154928 0 0.171991)
(0.274024 -0.0976666 0 0.178554 0 0.19214)
(0.311144 -0.115335 0 0.203677 0 0.21344)
(0.35028 -0.133831 0 0.229864 0 0.235655)
(0.39107 -0.152925 0 0.256756 0 0.258562)
(0.432933 -0.172364 0 0.28394 0 0.281859)
(0.475237 -0.191861 0 0.310934 0 0.305195)
(0.517228 -0.211025 0 0.337013 0 0.328126)
(0.558022 -0.22942 0 0.361105 0 0.350135)
(0.598578 -0.246596 0 0.380581 0 0.370898)
(0.633442 -0.261819 0 0.398782 0 0.389592)
(0.663557 -0.275172 0 0.415405 0 0.406341)
(0.689707 -0.286889 0 0.430697 0 0.421455)
(0.713457 -0.297148 0 0.444442 0 0.435429)
(0.73653 -0.3062 0 0.456526 0 0.448856)
(0.760808 -0.314529 0 0.467173 0 0.462475)
(0.788148 -0.322848 0 0.47701 0 0.477107)
(0.819885 -0.331877 0 0.486863 0 0.493406)
(0.856618 -0.342162 0 0.497529 0 0.511747)
(0.898211 -0.353948 0 0.509542 0 0.532193)
(0.943999 -0.367181 0 0.52307 0 0.554555)
(0.993154 -0.381627 0 0.537989 0 0.57853)
(1.045 -0.397023 0 0.554057 0 0.603835)
(1.09914 -0.41319 0 0.571078 0 0.630275)
(1.15542 -0.430066 0 0.588981 0 0.657762)
(1.21376 -0.447642 0 0.607754 0 0.686234)
(1.27386 -0.46587 0 0.627327 0 0.715558)
(1.33538 -0.484699 0 0.647618 0 0.745583)
(1.39808 -0.504128 0 0.668633 0 0.776213)
(1.46102 -0.523854 0 0.690001 0 0.807023)
(1.5234 -0.543592 0 0.711384 0 0.837649)
(1.58471 -0.563143 0 0.732546 0 0.867849)
(1.64473 -0.582424 0 0.753395 0 0.897511)
(1.70324 -0.601346 0 0.773814 0 0.926515)
(1.76007 -0.619853 0 0.793724 0 0.954766)
(1.81508 -0.637892 0 0.813056 0 0.98218)
(1.86813 -0.655412 0 0.831749 0 1.00868)
(1.91908 -0.672366 0 0.849745 0 1.03418)
(1.96783 -0.688707 0 0.866989 0 1.05863)
(2.01428 -0.704388 0 0.883424 0 1.08197)
(2.05832 -0.719363 0 0.898996 0 1.10413)
(2.09989 -0.733585 0 0.913652 0 1.12507)
(2.1389 -0.747014 0 0.927344 0 1.14474)
(2.17529 -0.759609 0 0.940024 0 1.1631)
(2.20899 -0.771332 0 0.95165 0 1.18009)
(2.23993 -0.782147 0 0.962182 0 1.19569)
(2.26805 -0.79202 0 0.971583 0 1.20984)
(2.29326 -0.800916 0 0.979819 0 1.22252)
(2.31548 -0.8088 0 0.986855 0 1.23366)
(2.33464 -0.815637 0 0.992657 0 1.24324)
(2.35067 -0.821395 0 0.997194 0 1.25121)
(2.36351 -0.826044 0 1.00044 0 1.25756)
(2.37311 -0.829561 0 1.00236 0 1.26224)
(2.37943 -0.831924 0 1.00295 0 1.26525)
(2.38247 -0.83312 0 1.00219 0 1.26657)
(2.38221 -0.833141 0 1.00007 0 1.2662)
(2.37868 -0.831987 0 0.996603 0 1.26416)
(2.37192 -0.829662 0 0.991785 0 1.26046)
(2.36198 -0.82618 0 0.985637 0 1.25513)
(2.34893 -0.821556 0 0.978182 0 1.24821)
(2.33289 -0.815815 0 0.969451 0 1.23975)
(2.31395 -0.808983 0 0.959481 0 1.22982)
(2.29228 -0.801099 0 0.94832 0 1.2185)
(2.26805 -0.792209 0 0.936024 0 1.20586)
(2.24144 -0.782372 0 0.922664 0 1.19202)
(2.21268 -0.771659 0 0.908324 0 1.17708)
(2.18202 -0.760154 0 0.893103 0 1.16117)
(2.14972 -0.747952 0 0.877113 0 1.14443)
(2.11603 -0.735156 0 0.860472 0 1.12699)
(2.08122 -0.721875 0 0.84331 0 1.109)
(2.04557 -0.708222 0 0.825759 0 1.09061)
(2.00931 -0.694304 0 0.807954 0 1.07194)
(1.97266 -0.680214 0 0.790014 0 1.05311)
(1.93579 -0.666021 0 0.772034 0 1.03424)
(1.89887 -0.651769 0 0.754083 0 1.01541)
(1.86209 -0.637502 0 0.736215 0 0.996704)
(1.82562 -0.623275 0 0.718493 0 0.978219)
(1.78964 -0.609153 0 0.700986 0 0.960033)
(1.75427 -0.595192 0 0.68376 0 0.942205)
(1.71959 -0.581434 0 0.666869 0 0.924778)
(1.68565 -0.56791 0 0.65035 0 0.90778)
(1.65247 -0.554635 0 0.634228 0 0.891224)
(1.62005 -0.541614 0 0.618514 0 0.875109)
(1.58838 -0.528845 0 0.603208 0 0.859423)
(1.55742 -0.516314 0 0.588299 0 0.844145)
(1.52713 -0.504004 0 0.573769 0 0.829246)
(1.49743 -0.491884 0 0.559587 0 0.814685)
(1.46829 -0.479924 0 0.545716 0 0.800428)
(1.43963 -0.468075 0 0.5321 0 0.786426)
(1.41153 -0.456315 0 0.518701 0 0.772684)
(1.38401 -0.444606 0 0.505439 0 0.759195)
(1.35778 -0.433131 0 0.492424 0 0.746225)
(1.33322 -0.422049 0 0.47969 0 0.733996)
(1.3137 -0.412902 0 0.468586 0 0.723987)
(1.30031 -0.40623 0 0.459788 0 0.71711)
(0.0413086 -0.015246 0 0.0541722 0 0.0593773)
(0.103749 -0.03385 0 0.0876651 0 0.101993)
(0.157792 -0.0545142 0 0.116634 0 0.130976)
(0.204256 -0.0742657 0 0.145387 0 0.156872)
(0.250484 -0.095217 0 0.176013 0 0.183029)
(0.299825 -0.117879 0 0.20891 0 0.210645)
(0.352671 -0.141898 0 0.243758 0 0.23998)
(0.409016 -0.167036 0 0.280103 0 0.270904)
(0.467378 -0.192663 0 0.316927 0 0.30263)
(0.527389 -0.218608 0 0.353901 0 0.334909)
(0.588165 -0.244574 0 0.390576 0 0.367317)
(0.648999 -0.270265 0 0.426494 0 0.39946)
(0.708792 -0.295148 0 0.460816 0 0.430742)
(0.766574 -0.318671 0 0.492446 0 0.46057)
(0.820911 -0.340104 0 0.519664 0 0.488191)
(0.873152 -0.358401 0 0.537012 0 0.512953)
(0.914988 -0.374131 0 0.554722 0 0.534288)
(0.950315 -0.38768 0 0.570926 0 0.552946)
(0.980907 -0.39933 0 0.585207 0 0.569414)
(1.00843 -0.409389 0 0.597556 0 0.584278)
(1.03473 -0.41829 0 0.608184 0 0.598263)
(1.06165 -0.426612 0 0.617542 0 0.612145)
(1.09068 -0.434971 0 0.62629 0 0.626608)
(1.12269 -0.443875 0 0.635123 0 0.642124)
(1.1579 -0.453606 0 0.644555 0 0.658899)
(1.19603 -0.464218 0 0.654824 0 0.67692)
(1.23662 -0.475626 0 0.665929 0 0.696052)
(1.27927 -0.487706 0 0.677772 0 0.71615)
(1.32375 -0.500382 0 0.690284 0 0.737124)
(1.3701 -0.513672 0 0.703511 0 0.758984)
(1.41825 -0.527572 0 0.717476 0 0.781699)
(1.46767 -0.541941 0 0.732004 0 0.805044)
(1.51799 -0.556689 0 0.746975 0 0.82885)
(1.56848 -0.57159 0 0.762094 0 0.852791)
(1.61898 -0.586652 0 0.777393 0 0.876818)
(1.66919 -0.601792 0 0.792794 0 0.900793)
(1.71877 -0.616907 0 0.808184 0 0.924571)
(1.76749 -0.631911 0 0.82346 0 0.948026)
(1.8151 -0.646715 0 0.838512 0 0.97104)
(1.8614 -0.661246 0 0.853247 0 0.993506)
(1.90621 -0.675434 0 0.867578 0 1.01532)
(1.94935 -0.689213 0 0.881426 0 1.03639)
(1.99064 -0.702519 0 0.894716 0 1.05663)
(2.02994 -0.715289 0 0.907371 0 1.07594)
(2.0671 -0.727461 0 0.919319 0 1.09426)
(2.10198 -0.738972 0 0.930488 0 1.11151)
(2.13448 -0.749763 0 0.940809 0 1.12762)
(2.16448 -0.759778 0 0.950218 0 1.14252)
(2.19189 -0.768964 0 0.958655 0 1.15617)
(2.21661 -0.777273 0 0.966066 0 1.1685)
(2.23858 -0.784663 0 0.972404 0 1.17948)
(2.25772 -0.791097 0 0.977628 0 1.18905)
(2.27396 -0.796543 0 0.981705 0 1.19717)
(2.28723 -0.80097 0 0.984603 0 1.20382)
(2.29749 -0.804355 0 0.986296 0 1.20896)
(2.30469 -0.806678 0 0.986764 0 1.21256)
(2.30881 -0.807924 0 0.985991 0 1.21461)
(2.30983 -0.808081 0 0.983965 0 1.21509)
(2.30774 -0.807143 0 0.98068 0 1.214)
(2.30257 -0.805111 0 0.976138 0 1.21135)
(2.29433 -0.801988 0 0.970344 0 1.20715)
(2.28309 -0.797784 0 0.963312 0 1.20142)
(2.26891 -0.792516 0 0.955063 0 1.19419)
(2.25187 -0.786206 0 0.945628 0 1.18552)
(2.23209 -0.778882 0 0.935043 0 1.17545)
(2.20969 -0.770582 0 0.923355 0 1.16405)
(2.18482 -0.761348 0 0.910619 0 1.1514)
(2.15766 -0.751233 0 0.8969 0 1.13759)
(2.12841 -0.7403 0 0.882274 0 1.12271)
(2.0973 -0.728623 0 0.866826 0 1.10689)
(2.06456 -0.716285 0 0.850656 0 1.09025)
(2.03046 -0.703381 0 0.833872 0 1.07292)
(1.99527 -0.690011 0 0.816592 0 1.05504)
(1.95926 -0.676284 0 0.798938 0 1.03674)
(1.9227 -0.662307 0 0.781038 0 1.01818)
(1.88585 -0.64819 0 0.763018 0 0.999483)
(1.84895 -0.634035 0 0.745002 0 0.980783)
(1.8122 -0.619927 0 0.727098 0 0.962194)
(1.77577 -0.605934 0 0.709394 0 0.943811)
(1.73982 -0.592098 0 0.691952 0 0.925713)
(1.70448 -0.578455 0 0.674818 0 0.907973)
(1.66989 -0.565043 0 0.658037 0 0.890655)
(1.63617 -0.551903 0 0.641654 0 0.873816)
(1.6034 -0.53907 0 0.625709 0 0.857493)
(1.57161 -0.526566 0 0.610231 0 0.841711)
(1.54083 -0.514402 0 0.595235 0 0.826477)
(1.51104 -0.502577 0 0.580726 0 0.811786)
(1.4822 -0.491081 0 0.566697 0 0.797623)
(1.45428 -0.479897 0 0.553131 0 0.78396)
(1.4272 -0.468999 0 0.540002 0 0.77076)
(1.40089 -0.458357 0 0.52728 0 0.757983)
(1.37526 -0.447932 0 0.514922 0 0.745577)
(1.35024 -0.437687 0 0.502884 0 0.733496)
(1.32575 -0.427573 0 0.491108 0 0.721688)
(1.30182 -0.417569 0 0.479555 0 0.710146)
(1.27847 -0.407648 0 0.468162 0 0.698857)
(1.25632 -0.39798 0 0.457033 0 0.688058)
(1.23568 -0.388743 0 0.446237 0 0.677937)
(1.2195 -0.381276 0 0.436967 0 0.669785)
(1.20851 -0.375911 0 0.429732 0 0.664292)
(0.0399756 -0.0155899 0 0.061044 0 0.0623235)
(0.126412 -0.0556466 0 0.121794 0 0.123612)
(0.210518 -0.0892156 0 0.166644 0 0.166272)
(0.285691 -0.120683 0 0.211874 0 0.20609)
(0.360302 -0.153132 0 0.259093 0 0.246346)
(0.438399 -0.186721 0 0.307344 0 0.287938)
(0.518958 -0.220662 0 0.355725 0 0.330473)
(0.601164 -0.254709 0 0.403903 0 0.373513)
(0.683377 -0.288262 0 0.451069 0 0.416255)
(0.764843 -0.321039 0 0.496799 0 0.458255)
(0.844694 -0.35276 0 0.540696 0 0.49909)
(0.922454 -0.383242 0 0.582579 0 0.538528)
(0.997101 -0.412098 0 0.621897 0 0.576059)
(1.06781 -0.438785 0 0.657612 0 0.611144)
(1.13389 -0.462501 0 0.687446 0 0.643167)
(1.19792 -0.482334 0 0.705145 0 0.672137)
(1.24838 -0.498487 0 0.72149 0 0.696158)
(1.28903 -0.511635 0 0.735474 0 0.716137)
(1.32188 -0.522324 0 0.747257 0 0.73269)
(1.34889 -0.530967 0 0.75685 0 0.746484)
(1.37201 -0.537993 0 0.764414 0 0.758264)
(1.3931 -0.543889 0 0.770274 0 0.768777)
(1.41378 -0.549192 0 0.774967 0 0.778737)
(1.43522 -0.554376 0 0.779091 0 0.788717)
(1.45801 -0.559765 0 0.783141 0 0.799077)
(1.48228 -0.565525 0 0.787425 0 0.809984)
(1.508 -0.571717 0 0.792087 0 0.821493)
(1.53513 -0.578357 0 0.797178 0 0.833619)
(1.56364 -0.585453 0 0.80273 0 0.846373)
(1.59336 -0.592952 0 0.808709 0 0.859692)
(1.62408 -0.600801 0 0.815073 0 0.873503)
(1.65592 -0.609081 0 0.82194 0 0.887884)
(1.6888 -0.617795 0 0.829316 0 0.902807)
(1.72248 -0.626888 0 0.837128 0 0.918168)
(1.75675 -0.636328 0 0.845345 0 0.933888)
(1.79135 -0.646047 0 0.853902 0 0.949853)
(1.82599 -0.655957 0 0.862707 0 0.965935)
(1.86039 -0.665962 0 0.871655 0 0.982006)
(1.89428 -0.675965 0 0.880631 0 0.997939)
(1.92744 -0.685877 0 0.889527 0 1.01361)
(1.95961 -0.695608 0 0.898239 0 1.0289)
(1.99059 -0.705074 0 0.906667 0 1.0437)
(2.02015 -0.714193 0 0.914717 0 1.0579)
(2.04809 -0.722884 0 0.922297 0 1.0714)
(2.07425 -0.731073 0 0.929319 0 1.08409)
(2.09844 -0.738685 0 0.9357 0 1.0959)
(2.12053 -0.745656 0 0.941364 0 1.10674)
(2.14038 -0.751923 0 0.946238 0 1.11653)
(2.15788 -0.757433 0 0.950259 0 1.12522)
(2.17294 -0.762138 0 0.953371 0 1.13274)
(2.18547 -0.766 0 0.955527 0 1.13904)
(2.1954 -0.768985 0 0.956686 0 1.14408)
(2.20268 -0.771067 0 0.956816 0 1.14782)
(2.20726 -0.772223 0 0.955888 0 1.15023)
(2.20909 -0.772434 0 0.95388 0 1.15129)
(2.20814 -0.771686 0 0.950775 0 1.15096)
(2.2044 -0.769967 0 0.946558 0 1.14925)
(2.19787 -0.76727 0 0.941224 0 1.14613)
(2.18856 -0.763592 0 0.93477 0 1.14162)
(2.17649 -0.758935 0 0.927201 0 1.13572)
(2.16171 -0.753308 0 0.918529 0 1.12846)
(2.14429 -0.746725 0 0.908775 0 1.11987)
(2.12432 -0.739211 0 0.897971 0 1.10998)
(2.1019 -0.730798 0 0.886157 0 1.09886)
(2.07717 -0.721527 0 0.873385 0 1.08658)
(2.05029 -0.711447 0 0.859715 0 1.0732)
(2.02142 -0.700617 0 0.845217 0 1.05881)
(1.99078 -0.689102 0 0.829969 0 1.04353)
(1.95858 -0.676977 0 0.814059 0 1.02745)
(1.92505 -0.664326 0 0.797583 0 1.0107)
(1.89044 -0.651237 0 0.780645 0 0.993401)
(1.85503 -0.637806 0 0.763353 0 0.975681)
(1.81905 -0.624135 0 0.745822 0 0.957674)
(1.78278 -0.610323 0 0.728168 0 0.939515)
(1.74648 -0.596472 0 0.710507 0 0.921333)
(1.71036 -0.58268 0 0.692953 0 0.903254)
(1.67466 -0.569036 0 0.67561 0 0.885392)
(1.63955 -0.555614 0 0.658573 0 0.867845)
(1.60518 -0.542471 0 0.641914 0 0.850696)
(1.57167 -0.529643 0 0.625682 0 0.83401)
(1.53912 -0.517153 0 0.609912 0 0.81784)
(1.50762 -0.505026 0 0.594629 0 0.802229)
(1.47724 -0.493281 0 0.579859 0 0.787212)
(1.44802 -0.481933 0 0.56562 0 0.772808)
(1.41997 -0.470989 0 0.551919 0 0.759022)
(1.39307 -0.460442 0 0.538755 0 0.745847)
(1.36729 -0.450279 0 0.526115 0 0.733264)
(1.34255 -0.440479 0 0.51398 0 0.721245)
(1.3188 -0.431013 0 0.502321 0 0.70975)
(1.29593 -0.421847 0 0.491102 0 0.698734)
(1.27386 -0.412942 0 0.480283 0 0.688147)
(1.25249 -0.404256 0 0.469817 0 0.677933)
(1.23172 -0.395746 0 0.459655 0 0.668038)
(1.21147 -0.387366 0 0.44974 0 0.658408)
(1.19176 -0.379094 0 0.440033 0 0.649029)
(1.17258 -0.370914 0 0.430485 0 0.639885)
(1.15446 -0.362981 0 0.421195 0 0.631182)
(1.13766 -0.355478 0 0.412253 0 0.62308)
(1.12473 -0.349551 0 0.404696 0 0.616689)
(1.1161 -0.345382 0 0.39891 0 0.612514)
(0.0452591 -0.0154434 0 0.0768684 0 0.0769238)
(0.204646 -0.0965241 0 0.196594 0 0.180891)
(0.363448 -0.163814 0 0.282876 0 0.256836)
(0.495926 -0.215393 0 0.35504 0 0.321913)
(0.617016 -0.264008 0 0.424276 0 0.383398)
(0.734444 -0.311248 0 0.490818 0 0.442956)
(0.846454 -0.355258 0 0.552031 0 0.499324)
(0.951933 -0.395809 0 0.607667 0 0.551982)
(1.05055 -0.433049 0 0.658047 0 0.600792)
(1.14266 -0.467304 0 0.703715 0 0.645919)
(1.22903 -0.498922 0 0.745255 0 0.687713)
(1.31115 -0.528508 0 0.783459 0 0.726859)
(1.38704 -0.555532 0 0.817859 0 0.762637)
(1.45587 -0.579669 0 0.848055 0 0.794735)
(1.51788 -0.60063 0 0.873201 0 0.823128)
(1.57331 -0.617826 0 0.891312 0 0.847754)
(1.62507 -0.630123 0 0.8953 0 0.869162)
(1.66184 -0.639007 0 0.900095 0 0.885438)
(1.68763 -0.645205 0 0.903889 0 0.897432)
(1.70523 -0.649177 0 0.906027 0 0.905926)
(1.7168 -0.651308 0 0.906356 0 0.911645)
(1.7243 -0.652028 0 0.905051 0 0.915341)
(1.72946 -0.651781 0 0.902458 0 0.917717)
(1.73362 -0.651004 0 0.89903 0 0.919391)
(1.73774 -0.65007 0 0.895235 0 0.920849)
(1.74242 -0.649258 0 0.891456 0 0.922436)
(1.74803 -0.648754 0 0.887955 0 0.924384)
(1.75487 -0.648672 0 0.884883 0 0.926852)
(1.76312 -0.649082 0 0.882334 0 0.929948)
(1.77286 -0.65002 0 0.880363 0 0.933726)
(1.7841 -0.651507 0 0.879021 0 0.938216)
(1.79687 -0.65358 0 0.878369 0 0.943454)
(1.81112 -0.656241 0 0.878416 0 0.949435)
(1.82675 -0.659463 0 0.879133 0 0.956114)
(1.84359 -0.663207 0 0.880475 0 0.963424)
(1.86142 -0.66741 0 0.882384 0 0.971275)
(1.87997 -0.67199 0 0.884778 0 0.979554)
(1.89895 -0.676853 0 0.887555 0 0.988137)
(1.91812 -0.681903 0 0.890606 0 0.9969)
(1.9372 -0.687044 0 0.893817 0 1.00572)
(1.95595 -0.692183 0 0.897079 0 1.01446)
(1.97412 -0.69723 0 0.900288 0 1.02301)
(1.99146 -0.702099 0 0.903341 0 1.03126)
(2.00777 -0.706708 0 0.906142 0 1.03908)
(2.02283 -0.710979 0 0.908599 0 1.04637)
(2.03647 -0.714841 0 0.910622 0 1.05304)
(2.04851 -0.718225 0 0.912132 0 1.059)
(2.0588 -0.721071 0 0.913052 0 1.06415)
(2.06722 -0.723321 0 0.913313 0 1.06844)
(2.07364 -0.724927 0 0.912854 0 1.07178)
(2.07797 -0.725844 0 0.91162 0 1.07413)
(2.08011 -0.726034 0 0.909563 0 1.07543)
(2.07999 -0.725462 0 0.906642 0 1.07563)
(2.07755 -0.724099 0 0.902822 0 1.07469)
(2.07273 -0.721918 0 0.898075 0 1.07259)
(2.0655 -0.7189 0 0.892377 0 1.0693)
(2.05583 -0.715028 0 0.885713 0 1.0648)
(2.04373 -0.710292 0 0.878075 0 1.05909)
(2.0292 -0.704691 0 0.869464 0 1.05217)
(2.01228 -0.698232 0 0.859889 0 1.04406)
(1.99304 -0.690928 0 0.849371 0 1.03478)
(1.97156 -0.682804 0 0.837941 0 1.02438)
(1.94795 -0.673896 0 0.82564 0 1.01291)
(1.92234 -0.664248 0 0.812522 0 1.00043)
(1.89489 -0.653911 0 0.798649 0 0.987014)
(1.86577 -0.642947 0 0.784091 0 0.972751)
(1.83517 -0.631423 0 0.768927 0 0.957734)
(1.8033 -0.619412 0 0.753241 0 0.942065)
(1.77037 -0.606993 0 0.737125 0 0.925854)
(1.73662 -0.594248 0 0.720672 0 0.909214)
(1.70229 -0.581265 0 0.703984 0 0.892265)
(1.66762 -0.568134 0 0.687161 0 0.875127)
(1.63284 -0.554946 0 0.670308 0 0.857922)
(1.59819 -0.541792 0 0.653527 0 0.840768)
(1.5639 -0.528759 0 0.636919 0 0.823779)
(1.53016 -0.515931 0 0.62058 0 0.807064)
(1.49717 -0.503382 0 0.604596 0 0.790719)
(1.46506 -0.491173 0 0.589043 0 0.774825)
(1.43396 -0.479348 0 0.573976 0 0.75945)
(1.40395 -0.467933 0 0.559433 0 0.744643)
(1.37511 -0.456942 0 0.545433 0 0.730439)
(1.34749 -0.446384 0 0.531989 0 0.716867)
(1.32112 -0.436265 0 0.519109 0 0.703941)
(1.29601 -0.426585 0 0.506795 0 0.691665)
(1.27213 -0.417336 0 0.495039 0 0.680033)
(1.24944 -0.408503 0 0.483828 0 0.669025)
(1.2279 -0.400062 0 0.473138 0 0.658614)
(1.20742 -0.391984 0 0.462941 0 0.648761)
(1.1879 -0.384234 0 0.4532 0 0.639423)
(1.16927 -0.376772 0 0.443875 0 0.630549)
(1.1514 -0.369558 0 0.434922 0 0.622085)
(1.13419 -0.362546 0 0.42629 0 0.613971)
(1.11755 -0.355692 0 0.417931 0 0.606153)
(1.10137 -0.348952 0 0.40979 0 0.598575)
(1.08567 -0.342305 0 0.401831 0 0.59122)
(1.07043 -0.335746 0 0.394017 0 0.584071)
(1.05611 -0.329408 0 0.386437 0 0.577304)
(1.04291 -0.323477 0 0.379196 0 0.571057)
(1.03299 -0.318923 0 0.373183 0 0.566272)
(1.02659 -0.315814 0 0.36869 0 0.563298)
(0.181461 -0.060006 0 0.158275 0 0.179146)
(0.885782 -0.374037 0 0.461205 0 0.461157)
(1.05225 -0.439337 0 0.555714 0 0.546326)
(1.22659 -0.498824 0 0.642138 0 0.627178)
(1.3669 -0.547822 0 0.713204 0 0.69449)
(1.48338 -0.589272 0 0.775135 0 0.752269)
(1.57987 -0.62334 0 0.827965 0 0.801455)
(1.65821 -0.65058 0 0.87159 0 0.842366)
(1.7216 -0.672219 0 0.907087 0 0.876015)
(1.77349 -0.689561 0 0.9359 0 0.903709)
(1.81633 -0.703609 0 0.959258 0 0.926519)
(1.85106 -0.71477 0 0.977815 0 0.944932)
(1.88033 -0.723922 0 0.99282 0 0.960182)
(1.90529 -0.731428 0 1.00489 0 0.972912)
(1.92643 -0.737248 0 1.01399 0 0.983436)
(1.94436 -0.7408 0 1.01843 0 0.991954)
(1.96425 -0.740982 0 1.01002 0 1.00047)
(1.97451 -0.739158 0 1.00302 0 1.00548)
(1.97701 -0.735706 0 0.995866 0 1.0074)
(1.97322 -0.730952 0 0.988165 0 1.00664)
(1.96462 -0.725152 0 0.979722 0 1.00371)
(1.95262 -0.71855 0 0.97051 0 0.999144)
(1.93859 -0.711424 0 0.960655 0 0.993472)
(1.9237 -0.704079 0 0.950417 0 0.987195)
(1.90882 -0.696803 0 0.940115 0 0.980738)
(1.89457 -0.689823 0 0.930038 0 0.974429)
(1.88144 -0.683298 0 0.920392 0 0.968518)
(1.8698 -0.677337 0 0.911309 0 0.963192)
(1.85993 -0.672023 0 0.902881 0 0.95859)
(1.852 -0.667408 0 0.89518 0 0.954804)
(1.84607 -0.663521 0 0.888264 0 0.951889)
(1.84214 -0.660374 0 0.882169 0 0.949873)
(1.84019 -0.65796 0 0.876899 0 0.948761)
(1.84014 -0.656256 0 0.872432 0 0.948529)
(1.84188 -0.655229 0 0.868735 0 0.949133)
(1.84522 -0.654828 0 0.865757 0 0.950502)
(1.84993 -0.654982 0 0.863429 0 0.952543)
(1.85576 -0.655608 0 0.861664 0 0.955153)
(1.86246 -0.65662 0 0.860365 0 0.958216)
(1.86977 -0.657927 0 0.859428 0 0.961615)
(1.87744 -0.65944 0 0.858749 0 0.965229)
(1.88519 -0.66107 0 0.858226 0 0.968935)
(1.89279 -0.662727 0 0.857756 0 0.972614)
(1.89998 -0.664327 0 0.85724 0 0.976148)
(1.90655 -0.665786 0 0.856579 0 0.979423)
(1.91226 -0.667022 0 0.855681 0 0.982331)
(1.91692 -0.667958 0 0.854455 0 0.984771)
(1.92033 -0.668522 0 0.852816 0 0.986647)
(1.92234 -0.668643 0 0.850686 0 0.98787)
(1.92279 -0.668258 0 0.84799 0 0.98836)
(1.92153 -0.667311 0 0.844664 0 0.988047)
(1.91847 -0.66575 0 0.840652 0 0.986865)
(1.91348 -0.663531 0 0.835903 0 0.984763)
(1.9065 -0.660618 0 0.830378 0 0.981694)
(1.89747 -0.656982 0 0.824046 0 0.977626)
(1.88634 -0.652601 0 0.816886 0 0.972533)
(1.8731 -0.647464 0 0.808885 0 0.966405)
(1.85776 -0.641567 0 0.800043 0 0.95924)
(1.84035 -0.634918 0 0.790369 0 0.951049)
(1.82093 -0.627532 0 0.779882 0 0.941856)
(1.79957 -0.619436 0 0.768613 0 0.931695)
(1.77637 -0.610664 0 0.756602 0 0.920615)
(1.75147 -0.601261 0 0.7439 0 0.908674)
(1.72501 -0.591278 0 0.730565 0 0.895939)
(1.69714 -0.580772 0 0.716664 0 0.882488)
(1.66805 -0.569808 0 0.702271 0 0.868407)
(1.63792 -0.558454 0 0.687464 0 0.853787)
(1.60695 -0.546781 0 0.672325 0 0.838727)
(1.57535 -0.534865 0 0.656941 0 0.823328)
(1.54333 -0.522783 0 0.6414 0 0.807697)
(1.5111 -0.510616 0 0.625792 0 0.791938)
(1.47889 -0.498442 0 0.610208 0 0.776162)
(1.44689 -0.486343 0 0.594739 0 0.760471)
(1.41531 -0.474395 0 0.579471 0 0.74497)
(1.38434 -0.462674 0 0.56449 0 0.729756)
(1.35415 -0.451247 0 0.549872 0 0.714917)
(1.32489 -0.440173 0 0.535687 0 0.700533)
(1.29668 -0.429502 0 0.521994 0 0.686671)
(1.2696 -0.419264 0 0.508832 0 0.673381)
(1.24372 -0.409477 0 0.496228 0 0.6607)
(1.21908 -0.400147 0 0.484191 0 0.64865)
(1.19571 -0.391272 0 0.472723 0 0.637245)
(1.1736 -0.382849 0 0.461821 0 0.62649)
(1.15275 -0.374868 0 0.451475 0 0.616377)
(1.13312 -0.367312 0 0.441669 0 0.606891)
(1.11466 -0.36016 0 0.432382 0 0.598006)
(1.09729 -0.353382 0 0.423585 0 0.58969)
(1.08092 -0.346946 0 0.415244 0 0.581901)
(1.06548 -0.340814 0 0.407321 0 0.574592)
(1.05084 -0.334945 0 0.399773 0 0.567713)
(1.03691 -0.329296 0 0.392555 0 0.561208)
(1.02358 -0.323822 0 0.385618 0 0.555018)
(1.01075 -0.318481 0 0.378915 0 0.54909)
(0.998316 -0.313232 0 0.372394 0 0.54337)
(0.986286 -0.308056 0 0.366024 0 0.537839)
(0.974629 -0.302951 0 0.359777 0 0.532478)
(0.96375 -0.298037 0 0.353731 0 0.527441)
(0.9538 -0.293493 0 0.348003 0 0.522843)
(0.946606 -0.290132 0 0.343342 0 0.519476)
(0.942196 -0.287939 0 0.339972 0 0.51756)
)
;
boundaryField
{
outlet
{
type zeroGradient;
}
inlet
{
type fixedValue;
value uniform (0.133333 0 0 0.133333 0 0.133333);
}
lowerWall
{
type kqRWallFunction;
value nonuniform List<symmTensor>
148
(
(0.205732 -0 -0 0.119059 0 0.158783)
(0.282327 -0.00695854 -0 0.109535 0 0.187468)
(0.351932 -0.0179115 -0 0.106212 0 0.215544)
(0.414145 -0.0272606 -0 0.107184 0 0.242572)
(0.468925 -0.0351166 -0 0.110858 0 0.268123)
(0.516415 -0.0416098 -0 0.116011 0 0.291794)
(0.556894 -0.0468712 -0 0.121756 0 0.313246)
(0.590786 -0.051041 -0 0.127486 0 0.332258)
(0.618629 -0.0542632 -0 0.132821 0 0.348735)
(0.641034 -0.056676 -0 0.137552 0 0.362695)
(0.658635 -0.0584064 -0 0.141583 0 0.374247)
(0.672059 -0.0595687 -0 0.144898 0 0.383564)
(0.681903 -0.0602637 -0 0.147528 0 0.390858)
(0.688719 -0.0605791 -0 0.149532 0 0.396359)
(0.693005 -0.0605896 -0 0.15098 0 0.4003)
(0.695201 -0.0603585 -0 0.151946 0 0.402904)
(0.695691 -0.0599384 -0 0.152504 0 0.40438)
(0.694804 -0.0593735 -0 0.152719 0 0.404916)
(0.692823 -0.0586998 -0 0.152653 0 0.404681)
(0.689983 -0.0579471 -0 0.152359 0 0.40382)
(0.686485 -0.0571395 -0 0.151883 0 0.402461)
(0.682494 -0.0562966 -0 0.151264 0 0.40071)
(0.678145 -0.0554341 -0 0.150536 0 0.39866)
(0.673552 -0.0545645 -0 0.149727 0 0.396388)
(0.668807 -0.0536979 -0 0.14886 0 0.393956)
(0.663984 -0.0528421 -0 0.147955 0 0.391418)
(0.659144 -0.0520033 -0 0.147027 0 0.388817)
(0.654334 -0.051186 -0 0.14609 0 0.386189)
(0.649592 -0.0503936 -0 0.145154 0 0.383563)
(0.644952 -0.0496303 -0 0.144227 0 0.380963)
(0.640427 -0.0488913 -0 0.143317 0 0.378403)
(0.636119 -0.0482128 -0 0.142462 0 0.375936)
(0.633189 -0.0476804 -0 0.142585 0 0.37401)
(0.00379602 0 0 0.0101719 -0 0.00993956)
(0.00779468 0 -0 0.0172243 -0 0.0178507)
(0.0139495 0 -0 0.0206173 -0 0.0248838)
(0.0218225 0 -0 0.0242331 -0 0.0323463)
(0.0295793 0 -0 0.027747 -0 0.0388359)
(0.0351161 0 -0 0.0318871 -0 0.0445159)
(0.0395535 -0 -0 0.0366297 -0 0.049736)
(0.0436991 -2.2321e-05 -0 0.0402474 -0 0.0535173)
(0.0459532 -9.15519e-05 -0 0.0438662 -0 0.0563056)
(0.0462852 -0.000165605 -0 0.0472291 -0 0.058103)
(0.0448039 -0.000247531 -0 0.0513986 -0 0.0595749)
(0.0413086 -0.000246755 -0 0.0541722 -0 0.0593773)
(0.0399756 -0.000381586 -0 0.061044 -0 0.0623235)
(0.0452591 -0.000408412 0 0.0768684 -0 0.0769238)
(0.181461 -0.000570885 0 0.158275 -0 0.179146)
(0.00379602 -0 -0 0.0101719 -0 0.00993956)
(0.00907906 -4.11105e-05 -0 0.0128867 -0 0.0160268)
(0.0127917 -0.000147177 -0 0.0144645 -0 0.0192142)
(0.0162677 -0.000247477 -0 0.0142797 -0 0.0210396)
(0.0189652 -0.000330762 -0 0.0135476 -0 0.0220523)
(0.0210236 -0.000396216 -0 0.0125891 -0 0.0225362)
(0.0225996 -0.000442872 -0 0.0115709 -0 0.0226694)
(0.0237988 -0.000471909 -0 0.0106067 -0 0.0225723)
(0.0246418 -0.000484319 -0 0.00972163 -0 0.0222796)
(0.025211 -0.000482733 -0 0.00891194 -0 0.0218351)
(0.0258685 -0.00047503 -0 0.00821811 -0 0.0214792)
(0.026615 -0.000461714 -0 0.00763217 -0 0.0212496)
(0.0272292 -0.000439254 -0 0.00713962 0 0.0210424)
(0.0277707 -0.000410724 -0 0.00675556 0 0.0208806)
(0.0283212 -0.000379733 -0 0.00649191 0 0.0208077)
(0.0289756 -0.000349618 -0 0.00635894 0 0.0208796)
(0.0298324 -0.0003222 -0 0.00636485 0 0.0211579)
(0.0309803 -0.000296958 -0 0.0065154 0 0.0217023)
(0.0324482 -0.000270294 -0 0.00681014 0 0.0225457)
(0.0342684 -0.000234545 -0 0.00725886 0 0.0237457)
(0.0365668 -0.000181992 -0 0.00793755 0 0.0254837)
(0.0399746 -9.16403e-05 -0 0.0090696 -0 0.0283878)
(0.046966 7.95705e-05 -0 0.0111544 -0 0.0343334)
(0.0577709 0.000423988 -0 0.0138425 0 0.042863)
(0.0715453 0.00107353 -0 0.0169851 0 0.0531396)
(0.0869811 0.00207058 -0 0.0204041 0 0.0641974)
(0.102874 0.00339411 -0 0.0239559 0 0.075289)
(0.118454 0.00496601 -0 0.0275554 0 0.0860084)
(0.133367 0.00668634 -0 0.0311605 0 0.0962107)
(0.147528 0.00845888 -0 0.034747 0 0.105894)
(0.160986 0.0102066 -0 0.0382965 0 0.115118)
(0.173838 0.0118766 -0 0.0417928 0 0.123959)
(0.186175 0.0134377 -0 0.0452196 0 0.132479)
(0.198018 0.0148737 -0 0.0485518 0 0.140691)
(0.209362 0.0161796 -0 0.0517685 0 0.14859)
(0.2202 0.0173583 -0 0.0548573 0 0.156173)
(0.23054 0.0184175 -0 0.0578175 0 0.163452)
(0.240427 0.0193677 -0 0.0606603 0 0.170462)
(0.249871 0.0202176 -0 0.0633949 0 0.17722)
(0.25887 0.0209736 -0 0.0660289 -0 0.183731)
(0.267408 0.0216407 -0 0.0685689 -0 0.190001)
(0.275452 0.0222224 -0 0.0710197 -0 0.196027)
(0.282953 0.0227211 -0 0.0733843 -0 0.201804)
(0.28983 0.0231378 -0 0.0756664 -0 0.207324)
(0.295972 0.0234724 -0 0.0778743 -0 0.212579)
(0.301636 0.0237466 -0 0.08007 -0 0.217681)
(0.307147 0.0239868 -0 0.0823121 -0 0.222719)
(0.31254 0.0241912 -0 0.0846183 -0 0.227722)
(0.317825 0.024362 -0 0.0869937 -0 0.232701)
(0.322968 0.0244967 -0 0.0894314 -0 0.237639)
(0.32794 0.0245928 -0 0.0919202 -0 0.242515)
(0.33272 0.0246476 -0 0.0944517 -0 0.247317)
(0.337298 0.0246586 -0 0.09702 -0 0.252032)
(0.341668 0.0246231 -0 0.0996211 -0 0.256654)
(0.345829 0.0245387 -0 0.102252 -0 0.261175)
(0.349782 0.024403 -0 0.104908 -0 0.265592)
(0.353532 0.0242135 -0 0.107589 -0 0.2699)
(0.357088 0.0239681 -0 0.11029 -0 0.274095)
(0.360458 0.0236644 -0 0.113008 -0 0.278176)
(0.363656 0.0233004 -0 0.115739 -0 0.28214)
(0.366695 0.0228742 -0 0.118479 -0 0.285987)
(0.369592 0.0223836 -0 0.121221 -0 0.289716)
(0.372367 0.021827 -0 0.123957 -0 0.293323)
(0.37504 0.0212027 -0 0.126675 -0 0.296807)
(0.377632 0.0205098 -0 0.129361 -0 0.300168)
(0.380171 0.0197476 -0 0.132001 -0 0.303405)
(0.382688 0.018916 -0 0.134578 -0 0.306525)
(0.385234 0.0180155 -0 0.137077 -0 0.309542)
(0.387924 0.0170473 -0 0.139472 -0 0.312504)
(0.391079 0.0160138 -0 0.1417 -0 0.31554)
(0.395904 0.0149183 -0 0.143552 -0 0.319122)
(0.403377 0.0137571 -0 0.145039 -0 0.323645)
(0.410301 0.0125123 -0 0.146771 -0 0.327851)
(0.416606 0.0111892 -0 0.148475 -0 0.331659)
(0.422567 0.00978357 -0 0.150084 -0 0.335209)
(0.428334 0.00828758 -0 0.15159 -0 0.338582)
(0.433858 0.00668408 -0 0.152976 -0 0.341738)
(0.438374 0.00493733 -0 0.154258 -0 0.344241)
(0.439174 0.00304772 -0 0.156192 -0 0.344823)
(0.431812 0.001342 -0 0.162887 -0 0.34219)
(0.434697 -0.000129521 -0 0.163486 -0 0.342867)
(0.440506 -0.00181022 -0 0.161952 -0 0.344754)
(0.445688 -0.00352765 -0 0.15919 -0 0.346129)
(0.448957 -0.00533984 -0 0.158046 -0 0.346813)
(0.451216 -0.00718539 -0 0.157164 -0 0.346962)
(0.452612 -0.00903878 -0 0.156243 -0 0.346583)
(0.453267 -0.0108835 -0 0.15517 -0 0.345714)
(0.453266 -0.0127061 -0 0.153905 -0 0.344399)
(0.452677 -0.0144961 -0 0.152446 -0 0.342678)
(0.451566 -0.0162454 -0 0.150805 -0 0.340592)
(0.449987 -0.0179472 -0 0.149003 -0 0.338185)
(0.448002 -0.0195983 -0 0.147064 -0 0.335497)
(0.445658 -0.0211933 -0 0.145019 -0 0.332571)
(0.443043 -0.0227414 -0 0.142901 -0 0.329466)
(0.440193 -0.0242253 -0 0.140764 -0 0.32623)
(0.43738 -0.0257231 -0 0.138668 -0 0.323027)
(0.434508 -0.027092 -0 0.136747 -0 0.319898)
(0.433121 -0.0289021 -0 0.135281 -0 0.317699)
(0.431474 -0.0299087 -0 0.134214 -0 0.315806)
(0.441863 -0.0343138 -0 0.137686 -0 0.32162)
)
;
}
upperWall
{
type kqRWallFunction;
value nonuniform List<symmTensor>
133
(
(0.153287 0.0723518 -0 0.126079 -0 0.139664)
(0.1751 0.0749822 -0 0.118906 -0 0.146688)
(0.195336 0.0773954 -0 0.112966 -0 0.153314)
(0.214186 0.079603 -0 0.108075 -0 0.159598)
(0.231802 0.0816541 -0 0.104077 -0 0.165587)
(0.24831 0.0835769 -0 0.10084 -0 0.171316)
(0.26381 0.0853808 -0 0.0982535 -0 0.176811)
(0.278387 0.0870724 -0 0.0962213 -0 0.182095)
(0.292113 0.0886603 -0 0.0946618 -0 0.187182)
(0.305051 0.0901522 -0 0.093504 -0 0.192086)
(0.317259 0.0915545 -0 0.0926868 -0 0.196819)
(0.328786 0.0928723 -0 0.0921573 -0 0.201388)
(0.339679 0.0941104 -0 0.0918701 -0 0.205801)
(0.349978 0.0952736 -0 0.0917857 -0 0.210063)
(0.359719 0.0963659 -0 0.0918704 -0 0.21418)
(0.368939 0.0973913 -0 0.0920951 -0 0.218157)
(0.377667 0.0983537 -0 0.0924347 -0 0.221997)
(0.385933 0.0992563 -0 0.092868 -0 0.225703)
(0.393764 0.100103 -0 0.0933764 -0 0.22928)
(0.401184 0.100896 -0 0.0939444 -0 0.23273)
(0.408218 0.101639 -0 0.0945586 -0 0.236056)
(0.414885 0.102334 -0 0.0952076 -0 0.239262)
(0.421207 0.102985 -0 0.0958819 -0 0.24235)
(0.427202 0.103593 -0 0.0965732 -0 0.245324)
(0.432889 0.104162 -0 0.0972747 -0 0.248186)
(0.438283 0.104693 -0 0.0979808 -0 0.25094)
(0.443401 0.105188 -0 0.0986865 -0 0.253588)
(0.448257 0.10565 -0 0.0993879 -0 0.256133)
(0.452866 0.106081 -0 0.100082 -0 0.25858)
(0.45724 0.106482 -0 0.100765 -0 0.26093)
(0.461391 0.106854 -0 0.101436 -0 0.263186)
(0.465334 0.107201 -0 0.102094 -0 0.265354)
(0.469105 0.107526 -0 0.102741 -0 0.26745)
(0.473782 0.107949 -0 0.103571 -0 0.270085)
(0.478347 0.108322 -0 0.104405 -0 0.27269)
(0.482768 0.10867 -0 0.105237 -0 0.275248)
(0.487043 0.108993 -0 0.106062 -0 0.277755)
(0.491169 0.109289 -0 0.10688 -0 0.280208)
(0.495143 0.109559 -0 0.107687 -0 0.282603)
(0.498965 0.109802 -0 0.10848 -0 0.284937)
(0.502629 0.110019 -0 0.109258 -0 0.287206)
(0.506136 0.110207 -0 0.110018 -0 0.289407)
(0.509482 0.110367 -0 0.110758 -0 0.291538)
(0.512664 0.1105 -0 0.111476 -0 0.293594)
(0.515682 0.110603 -0 0.11217 -0 0.295573)
(0.518533 0.110677 -0 0.112838 -0 0.297472)
(0.521214 0.110722 -0 0.113479 -0 0.299288)
(0.523725 0.110738 -0 0.11409 -0 0.301019)
(0.526064 0.110722 -0 0.114671 -0 0.302661)
(0.528228 0.110677 -0 0.115221 -0 0.304212)
(0.530216 0.1106 -0 0.115737 -0 0.305669)
(0.532027 0.110492 -0 0.116219 -0 0.307031)
(0.53366 0.110352 -0 0.116665 -0 0.308295)
(0.535112 0.11018 -0 0.117074 -0 0.309459)
(0.536382 0.109975 -0 0.117446 -0 0.31052)
(0.537469 0.109737 -0 0.11778 -0 0.311478)
(0.538371 0.109465 -0 0.118074 -0 0.312329)
(0.539087 0.109157 -0 0.118327 -0 0.313073)
(0.539615 0.108815 -0 0.11854 -0 0.313707)
(0.539954 0.108437 -0 0.11871 -0 0.314229)
(0.540102 0.108021 -0 0.118838 -0 0.314639)
(0.540056 0.107568 -0 0.118922 -0 0.314933)
(0.539815 0.107076 -0 0.118962 -0 0.315111)
(0.539377 0.106545 -0 0.118956 -0 0.31517)
(0.538738 0.105973 -0 0.118905 -0 0.31511)
(0.537897 0.105358 -0 0.118808 -0 0.314927)
(0.53685 0.104701 -0 0.118663 -0 0.31462)
(0.535594 0.103999 -0 0.118469 -0 0.314186)
(0.534125 0.103251 -0 0.118227 -0 0.313625)
(0.53244 0.102456 -0 0.117934 -0 0.312932)
(0.530533 0.101613 -0 0.117591 -0 0.312107)
(0.528401 0.100719 -0 0.117195 -0 0.311145)
(0.526038 0.0997744 -0 0.116747 -0 0.310044)
(0.523439 0.0987764 -0 0.116244 -0 0.308802)
(0.520599 0.0977238 -0 0.115687 -0 0.307415)
(0.517512 0.096615 -0 0.115073 -0 0.30588)
(0.51417 0.0954486 -0 0.114402 -0 0.304194)
(0.510569 0.0942231 -0 0.113672 -0 0.302352)
(0.506701 0.0929369 -0 0.112882 -0 0.300351)
(0.502559 0.0915888 -0 0.112031 -0 0.298187)
(0.498137 0.0901775 -0 0.111117 -0 0.295857)
(0.493428 0.0887017 -0 0.11014 -0 0.293356)
(0.488424 0.0871604 -0 0.109098 -0 0.29068)
(0.483119 0.0855527 -0 0.107989 -0 0.287825)
(0.477508 0.0838779 -0 0.106814 -0 0.284788)
(0.471583 0.0821357 -0 0.10557 -0 0.281565)
(0.465339 0.0803258 -0 0.104257 -0 0.278153)
(0.458774 0.0784485 -0 0.102874 -0 0.274548)
(0.451882 0.0765042 -0 0.101422 -0 0.270749)
(0.444662 0.074494 -0 0.0998992 -0 0.266753)
(0.437114 0.0724196 -0 0.0983067 -0 0.26256)
(0.42924 0.0702829 -0 0.0966453 -0 0.25817)
(0.421044 0.0680869 -0 0.0949164 -0 0.253585)
(0.412535 0.0658352 -0 0.093122 -0 0.248808)
(0.403722 0.0635323 -0 0.0912653 -0 0.243843)
(0.394623 0.0611837 -0 0.0893501 -0 0.2387)
(0.385257 0.0587961 -0 0.0873817 -0 0.233388)
(0.375654 0.0563774 -0 0.0853666 -0 0.227922)
(0.365846 0.0539367 -0 0.0833132 -0 0.22232)
(0.355877 0.0514847 -0 0.0812317 -0 0.216604)
(0.345801 0.0490337 -0 0.0791344 -0 0.210803)
(0.335681 0.0465973 -0 0.0770361 -0 0.204953)
(0.325594 0.044191 -0 0.0749546 -0 0.199095)
(0.315628 0.0418316 -0 0.0729104 -0 0.19328)
(0.305889 0.0395372 -0 0.0709275 -0 0.187567)
(0.296496 0.0373273 -0 0.0690329 -0 0.182024)
(0.287581 0.0352218 -0 0.0672573 -0 0.176728)
(0.279292 0.0332411 -0 0.065634 -0 0.171768)
(0.271782 0.0314051 -0 0.0641986 -0 0.167236)
(0.265214 0.029733 -0 0.0629881 -0 0.163232)
(0.259745 0.0282418 -0 0.0620391 -0 0.159858)
(0.25552 0.0269459 -0 0.0613858 -0 0.157209)
(0.252662 0.0258567 -0 0.0610573 -0 0.155372)
(0.251256 0.0249813 -0 0.0610745 -0 0.154415)
(0.251337 0.0243224 -0 0.0614473 -0 0.154379)
(0.252884 0.0238784 -0 0.0621716 -0 0.15527)
(0.255809 0.0236434 -0 0.0632276 -0 0.157054)
(0.259961 0.0236073 -0 0.0645794 -0 0.159658)
(0.265134 0.0237578 -0 0.0661757 -0 0.162966)
(0.27112 0.0240772 -0 0.0679657 -0 0.166856)
(0.279396 0.0246576 -0 0.0703117 -0 0.172076)
(0.289099 0.0254444 -0 0.0730067 -0 0.178216)
(0.299146 0.0263655 -0 0.0757814 -0 0.18469)
(0.308654 0.0273578 -0 0.0784073 -0 0.190968)
(0.316955 0.0283659 -0 0.0807054 -0 0.196616)
(0.323665 0.0293471 -0 0.0825648 -0 0.201351)
(0.328637 0.0302668 -0 0.0839349 -0 0.205031)
(0.331918 0.0311083 -0 0.0848193 -0 0.207638)
(0.333582 0.0318424 -0 0.08523 -0 0.209191)
(0.334048 0.0324999 -0 0.0852882 -0 0.20991)
(0.333004 0.0330175 -0 0.0848706 -0 0.209635)
(0.333004 0.0335262 -0 0.0847682 -0 0.209767)
(0.332588 0.034518 -0 0.0843456 -0 0.209521)
)
;
}
frontAndBack
{
type empty;
}
}
// ************************************************************************* //
| [
"brent.shambaugh@gmail.com"
] | brent.shambaugh@gmail.com | |
7699d23982f8f7b322f6bd421ac92d4727d6c1fa | 1c9d04a9352e6d86480f9e0947f930db042d8e80 | /src/plugins/ros2/navigator_thread.h | 1ff59cd62233a641e45af6a9f22e51340a1ee896 | [] | no_license | fawkesrobotics/fawkes | 2c9de0cdb1dfcc951806434fe08458de5a670c8a | ad8adc34f9c73ace1e6a6517624f7c7089f62832 | refs/heads/master | 2023-08-31T01:36:15.690865 | 2023-07-04T17:05:55 | 2023-07-04T17:05:55 | 1,030,824 | 62 | 26 | null | 2023-07-04T17:05:57 | 2010-10-28T04:22:55 | C++ | UTF-8 | C++ | false | false | 4,410 | h |
/***************************************************************************
* navigator_thread.h - Robotino ROS2 Navigator Thread
*
* Created: Sat June 09 15:13:27 2012
* Copyright 2012 Sebastian Reuter
****************************************************************************/
/* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Library General Public License for more details.
*
* Read the full text in the LICENSE.GPL file in the doc directory.
*/
#ifndef _ROS2_NAVIGATOR_THREAD_H_
#define _ROS2_NAVIGATOR_THREAD_H_
#include <aspect/blackboard.h>
#include <aspect/blocked_timing.h>
#include <aspect/clock.h>
#include <aspect/configurable.h>
#include <aspect/logging.h>
#include <aspect/tf.h>
#include <core/threading/thread.h>
#include <interfaces/NavigatorInterface.h>
#include <interfaces/Position3DInterface.h>
#include <plugins/ros2/aspect/ros2.h>
#include <geometry_msgs/msg/pose_stamped.hpp>
#include <nav2_msgs/action/navigate_to_pose.hpp>
#include <rclcpp/rclcpp.hpp>
#include <rclcpp_action/rclcpp_action.hpp>
//#include <tf2/types.h>
#include <tf/types.h>
#include <utils/math/angle.h>
#include <math.h>
#include <unistd.h>
namespace fawkes {
class NavigatorInterface;
}
class ROS2NavigatorThread : public fawkes::Thread,
public fawkes::ClockAspect,
// public fawkes::BlockedTimingAspect,
public fawkes::LoggingAspect,
public fawkes::BlackBoardAspect,
public fawkes::ConfigurableAspect,
public fawkes::ROS2Aspect,
public fawkes::TransformAspect
{
public:
ROS2NavigatorThread(std::string &cfg_prefix);
virtual void init();
virtual void finalize();
virtual void loop();
/** Stub to see name in backtrace for easier debugging. @see Thread::run() */
protected:
virtual void
run()
{
Thread::run();
}
private:
void send_goal();
void stop_goals();
void load_config();
// bool set_dynreconf_value(const std::string &path, const float value);
private:
using NavigateToPose = nav2_msgs::action::NavigateToPose;
using GoalHandleNav2 = rclcpp_action::ClientGoalHandle<NavigateToPose>;
typedef rclcpp_action::Client<NavigateToPose>::SharedPtr Nav2Client;
// rclcpp_action::Client<NavigateToPose>::SharedPtr client_ptr_;
void transform_to_fixed_frame();
fawkes::NavigatorInterface *nav_if_;
fawkes::Position3DInterface *pose_if_;
Nav2Client ac_;
NavigateToPose::Goal goal_;
std::shared_future<GoalHandleNav2::SharedPtr> future_goal_handle_;
bool connected_history_;
rclcpp::Clock ros_clock_;
rclcpp_action::ClientGoalHandle<NavigateToPose>::WrappedResult result_;
fawkes::Time *ac_init_checktime_;
std::string cfg_prefix_;
// // ROS2 dynamic reconfigure parts
// dynamic_reconfigure::ReconfigureRequest dynreconf_srv_req;
// dynamic_reconfigure::ReconfigureResponse dynreconf_srv_resp;
// dynamic_reconfigure::DoubleParameter dynreconf_double_param;
// dynamic_reconfigure::Config dynreconf_conf;
// std::string cfg_dynreconf_path_;
// std::string cfg_dynreconf_trans_vel_name_;
// std::string cfg_dynreconf_rot_vel_name_;
std::string cfg_fixed_frame_;
float cfg_ori_tolerance_;
float cfg_trans_tolerance_;
rclcpp::Parameter param_max_vel;
rclcpp::Parameter param_max_rot;
geometry_msgs::msg::PoseStamped base_position;
float goal_position_x;
float goal_position_y;
float goal_position_yaw;
float goal_tolerance_trans;
float goal_tolerance_yaw;
};
#endif /* ROS2_NAVIGATOR_THREAD_H__ */
| [
"viehmann@kbsg.rwth-aachen.de"
] | viehmann@kbsg.rwth-aachen.de |
e0969d4e00a7957848d023180d9823f10cca6d82 | c2d7badcc2490b88e91a634d79c687ab9374dbf1 | /cocos/2d/CCComponentContainer.h | 56221ce1db4e85628a8bcf16c0b05a79e3332780 | [] | no_license | SBKarr/stappler-cocos2d-x | 48217b18adc1f54e8d5e22b5c9e7f9977f626382 | 24389838ec7613ae25e0417c25682600133c4ec7 | refs/heads/master | 2020-07-05T09:37:37.156758 | 2017-03-09T16:27:37 | 2017-03-12T17:08:34 | 67,418,239 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,358 | h | /****************************************************************************
Copyright (c) 2013-2014 Chukong Technologies Inc.
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#ifndef __CC_FRAMEWORK_COMCONTAINER_H__
#define __CC_FRAMEWORK_COMCONTAINER_H__
#include "base/CCVector.h"
#include "math/Mat4.h"
#include <string>
#include <vector>
NS_CC_BEGIN
class Component;
class Node;
class Renderer;
class CC_DLL ComponentContainer
{
protected:
/**
* @js ctor
*/
ComponentContainer(Node *pNode);
public:
/**
* @js NA
* @lua NA
*/
virtual ~ComponentContainer(void);
virtual bool add(Component *com);
virtual bool remove(Component *com);
virtual void removeAll();
virtual void onVisit(Renderer *renderer, const Mat4& parentTransform, uint32_t parentFlags, const std::vector<int> &);
virtual void onEnter();
virtual void onEnterTransitionDidFinish();
virtual void onExitTransitionDidStart();
virtual void onExit();
virtual void onContentSizeDirty();
virtual void onTransformDirty();
virtual void onReorderChildDirty();
public:
bool isEmpty() const;
private:
Vector<Component *> _components;
Node *_owner;
friend class Node;
};
NS_CC_END
#endif // __FUNDATION__CCCOMPONENT_H__
| [
"sbkarr@stappler.org"
] | sbkarr@stappler.org |
4e174e00894b9142e7b14c157ad7e824094f5508 | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/CMake/CMake-gumtree/Kitware_CMake_old_new_new_log_456.cpp | 1f2fb319235e471b7b91ea231d4697619a9fcb89 | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 65 | cpp | YY_FATAL_ERROR( "cmFortran_yyset_column called with no buffer" ); | [
"993273596@qq.com"
] | 993273596@qq.com |
bd10c45de006eeecbf6138796d804fb2c73a41f0 | 605ab4d843af2959764d9fb78f626421e9ec1520 | /src/process/im_convolve_rank.cpp | 0f559d5344391bf5b050620fb8a30c1a8aa67733 | [
"MIT"
] | permissive | svn2github/imtoolkit-im | f9941a0338d943e5f2c05937b4d9f14405c07423 | aafc283f50ed9e3b1ee73e6ca09a7b9ccfafd31d | refs/heads/master | 2021-07-05T11:43:14.348372 | 2019-01-07T18:03:32 | 2019-01-07T18:03:32 | 103,318,180 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 27,726 | cpp | /** \file
* \brief Rank Convolution Operations
*
* See Copyright Notice in im_lib.h
*/
#include <im.h>
#include <im_util.h>
#include <im_math.h>
#include "im_process_counter.h"
#include "im_process_loc.h"
#include <stdlib.h>
#include <stdio.h>
#include <memory.h>
#include <string.h>
#include <math.h>
template <class T, class DT>
static int DoConvolveRankFunc(T *map, DT* new_map, int width, int height, int kw, int kh, T (*func)(T* value, int count, int center), int counter)
{
int tcount = IM_MAX_THREADS;
T* value = new T[kw*kh*tcount];
int kh2 = kh/2;
int kw2 = kw/2;
int kh1 = -kh2;
int kw1 = -kw2;
if (kh%2==0) kh2--; // if not odd decrease 1
if (kw%2==0) kw2--;
IM_INT_PROCESSING;
#ifdef _OPENMP
#pragma omp parallel for if (IM_OMP_MINHEIGHT(height))
#endif
for(int j = 0; j < height; j++)
{
#ifdef _OPENMP
#pragma omp flush (processing)
#endif
IM_BEGIN_PROCESSING;
int new_offset = j * width;
int toffset = IM_THREAD_NUM*(kw*kh);
for(int i = 0; i < width; i++)
{
int v = 0;
int c = 0;
for(int y = kh1; y <= kh2; y++)
{
if ((j + y < 0) || // pass the bottom border
(j + y >= height)) // pass the top border
continue;
int offset = (j + y) * width;
for(int x = kw1; x <= kw2; x++)
{
if ((i + x < 0) || // pass the left border
(i + x >= width)) // pass the right border
continue;
if (x == 0 && y == 0)
c = v;
value[toffset + v] = map[offset + (i + x)];
v++;
}
}
new_map[new_offset + i] = (DT)func(value + toffset, v, c);
}
IM_COUNT_PROCESSING;
#ifdef _OPENMP
#pragma omp flush (processing)
#endif
IM_END_PROCESSING;
}
delete[] value;
return processing;
}
static int compare_imFloat(const void *elem1, const void *elem2)
{
float* v1 = (float*)elem1;
float* v2 = (float*)elem2;
if (*v1 < *v2)
return -1;
if (*v1 > *v2)
return 1;
return 0;
}
static int compare_imDouble(const void *elem1, const void *elem2)
{
double* v1 = (double*)elem1;
double* v2 = (double*)elem2;
if (*v1 < *v2)
return -1;
if (*v1 > *v2)
return 1;
return 0;
}
static int compare_imInt(const void *elem1, const void *elem2)
{
int* v1 = (int*)elem1;
int* v2 = (int*)elem2;
if (*v1 < *v2)
return -1;
if (*v1 > *v2)
return 1;
return 0;
}
static int compare_imShort(const void *elem1, const void *elem2)
{
short* v1 = (short*)elem1;
short* v2 = (short*)elem2;
if (*v1 < *v2)
return -1;
if (*v1 > *v2)
return 1;
return 0;
}
static int compare_imUShort(const void *elem1, const void *elem2)
{
imushort* v1 = (imushort*)elem1;
imushort* v2 = (imushort*)elem2;
if (*v1 < *v2)
return -1;
if (*v1 > *v2)
return 1;
return 0;
}
static int compare_imByte(const void *elem1, const void *elem2)
{
imbyte* v1 = (imbyte*)elem1;
imbyte* v2 = (imbyte*)elem2;
if (*v1 < *v2)
return -1;
if (*v1 > *v2)
return 1;
return 0;
}
static imbyte median_op_byte(imbyte* value, int count, int center)
{
(void)center;
qsort(value, count, sizeof(imbyte), compare_imByte);
return value[count/2];
}
static short median_op_short(short* value, int count, int center)
{
(void)center;
qsort(value, count, sizeof(short), compare_imShort);
return value[count/2];
}
static imushort median_op_ushort(imushort* value, int count, int center)
{
(void)center;
qsort(value, count, sizeof(imushort), compare_imUShort);
return value[count/2];
}
static int median_op_int(int* value, int count, int center)
{
(void)center;
qsort(value, count, sizeof(int), compare_imInt);
return value[count/2];
}
static float median_op_float(float* value, int count, int center)
{
(void)center;
qsort(value, count, sizeof(float), compare_imFloat);
return value[count/2];
}
static double median_op_double(double* value, int count, int center)
{
(void)center;
qsort(value, count, sizeof(double), compare_imDouble);
return value[count / 2];
}
int imProcessMedianConvolve(const imImage* src_image, imImage* dst_image, int ks)
{
int i, ret = 0;
int counter;
counter = imProcessCounterBegin("MedianConvolve");
imCounterTotal(counter, src_image->depth*src_image->height, "Processing...");
for (i = 0; i < src_image->depth; i++)
{
switch(src_image->data_type)
{
case IM_BYTE:
ret = DoConvolveRankFunc((imbyte*)src_image->data[i], (imbyte*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, median_op_byte, counter);
break;
case IM_SHORT:
ret = DoConvolveRankFunc((short*)src_image->data[i], (short*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, median_op_short, counter);
break;
case IM_USHORT:
ret = DoConvolveRankFunc((imushort*)src_image->data[i], (imushort*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, median_op_ushort, counter);
break;
case IM_INT:
ret = DoConvolveRankFunc((int*)src_image->data[i], (int*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, median_op_int, counter);
break;
case IM_FLOAT:
ret = DoConvolveRankFunc((float*)src_image->data[i], (float*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, median_op_float, counter);
break;
case IM_DOUBLE:
ret = DoConvolveRankFunc((double*)src_image->data[i], (double*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, median_op_double, counter);
break;
}
if (!ret)
break;
}
imProcessCounterEnd(counter);
return ret;
}
static imbyte range_op_byte(imbyte* value, int count, int center)
{
imbyte min, max;
(void)center;
imMinMax(value, count, min, max);
return max-min;
}
static short range_op_short(short* value, int count, int center)
{
short min, max;
(void)center;
imMinMax(value, count, min, max);
return max-min;
}
static imushort range_op_ushort(imushort* value, int count, int center)
{
imushort min, max;
(void)center;
imMinMax(value, count, min, max);
return max-min;
}
static int range_op_int(int* value, int count, int center)
{
int min, max;
(void)center;
imMinMax(value, count, min, max);
return max-min;
}
static float range_op_float(float* value, int count, int center)
{
float min, max;
(void)center;
imMinMax(value, count, min, max);
return max-min;
}
static double range_op_double(double* value, int count, int center)
{
double min, max;
(void)center;
imMinMax(value, count, min, max);
return max - min;
}
int imProcessRangeConvolve(const imImage* src_image, imImage* dst_image, int ks)
{
int i, ret = 0;
int counter;
counter = imProcessCounterBegin("RangeConvolve");
imCounterTotal(counter, src_image->depth*src_image->height, "Processing...");
for (i = 0; i < src_image->depth; i++)
{
switch(src_image->data_type)
{
case IM_BYTE:
ret = DoConvolveRankFunc((imbyte*)src_image->data[i], (imbyte*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, range_op_byte, counter);
break;
case IM_SHORT:
ret = DoConvolveRankFunc((short*)src_image->data[i], (short*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, range_op_short, counter);
break;
case IM_USHORT:
ret = DoConvolveRankFunc((imushort*)src_image->data[i], (imushort*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, range_op_ushort, counter);
break;
case IM_INT:
ret = DoConvolveRankFunc((int*)src_image->data[i], (int*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, range_op_int, counter);
break;
case IM_FLOAT:
ret = DoConvolveRankFunc((float*)src_image->data[i], (float*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, range_op_float, counter);
break;
case IM_DOUBLE:
ret = DoConvolveRankFunc((double*)src_image->data[i], (double*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, range_op_double, counter);
break;
}
if (!ret)
break;
}
imProcessCounterEnd(counter);
return ret;
}
/*
Local variable threshold by the method of Bernsen.
Description:
If the difference between the largest and the smallest
pixel value within the 'dx'*'dy' window is greater than
or equal to 'cmin' (local contrast threshold), the average
of the two values is used as threshold.
Pixels in homogenous areas (difference below 'cmin')
are assumed to be below the threshold.
Reference:
Bernsen, J: "Dynamic thresholding of grey-level images"
Proc. of the 8th ICPR, Paris, Oct 1986, 1251-1255.
Author: Oivind Due Trier
Copyright 1990, Blab, UiO
Image processing lab, Department of Informatics
University of Oslo
*/
static int thresAux = 0;
static imbyte contrast_thres_op_byte(imbyte* value, int count, int center)
{
int c, t;
imbyte v = value[center], min, max;
imMinMax(value, count, min, max);
c = max-min;
if (c < thresAux)
return 0;
else
{
t = ((int)max + (int)min) / 2;
if (v >= t)
return 1;
else
return 0;
}
}
static imushort contrast_thres_op_ushort(imushort* value, int count, int center)
{
int c, t;
imushort v = value[center], min, max;
imMinMax(value, count, min, max);
c = max-min;
if (c < thresAux)
return 0;
else
{
t = ((int)max + (int)min) / 2;
if (v >= t)
return 1;
else
return 0;
}
}
static short contrast_thres_op_short(short* value, int count, int center)
{
int c, t;
short v = value[center], min, max;
imMinMax(value, count, min, max);
c = max-min;
if (c < thresAux)
return 0;
else
{
t = ((int)max + (int)min) / 2;
if (v >= t)
return 1;
else
return 0;
}
}
static int contrast_thres_op_int(int* value, int count, int center)
{
int c, t;
int v = value[center], min, max;
imMinMax(value, count, min, max);
c = max-min;
if (c < thresAux)
return 0;
else
{
t = ((int)max + (int)min) / 2;
if (v >= t)
return 1;
else
return 0;
}
}
int imProcessRangeContrastThreshold(const imImage* src_image, imImage* dst_image, int ks, int min_range)
{
int ret = 0;
int counter = imProcessCounterBegin("RangeContrastThreshold");
imCounterTotal(counter, src_image->depth*src_image->height, "Processing...");
thresAux = min_range;
switch(src_image->data_type)
{
case IM_BYTE:
ret = DoConvolveRankFunc((imbyte*)src_image->data[0], (imbyte*)dst_image->data[0],
src_image->width, src_image->height, ks, ks, contrast_thres_op_byte, counter);
break;
case IM_SHORT:
ret = DoConvolveRankFunc((short*)src_image->data[0], (imbyte*)dst_image->data[0],
src_image->width, src_image->height, ks, ks, contrast_thres_op_short, counter);
break;
case IM_USHORT:
ret = DoConvolveRankFunc((imushort*)src_image->data[0], (imbyte*)dst_image->data[0],
src_image->width, src_image->height, ks, ks, contrast_thres_op_ushort, counter);
break;
case IM_INT:
ret = DoConvolveRankFunc((int*)src_image->data[0], (imbyte*)dst_image->data[0],
src_image->width, src_image->height, ks, ks, contrast_thres_op_int, counter);
break;
}
imProcessCounterEnd(counter);
return ret;
}
static imbyte max_thres_op_byte(imbyte* value, int count, int center)
{
imbyte v = value[center], min, max;
if (v < thresAux)
return 0;
imMinMax(value, count, min, max);
if (v < max)
return 0;
return 1;
}
static short max_thres_op_short(short* value, int count, int center)
{
short v = value[center], min, max;
if (v < thresAux)
return 0;
imMinMax(value, count, min, max);
if (v < max)
return 0;
return 1;
}
static imushort max_thres_op_ushort(imushort* value, int count, int center)
{
imushort v = value[center], min, max;
if (v < thresAux)
return 0;
imMinMax(value, count, min, max);
if (v < max)
return 0;
return 1;
}
static int max_thres_op_int(int* value, int count, int center)
{
int v = value[center], min, max;
if (v < thresAux)
return 0;
imMinMax(value, count, min, max);
if (v < max)
return 0;
return 1;
}
int imProcessLocalMaxThreshold(const imImage* src_image, imImage* dst_image, int ks, int min_thres)
{
int ret = 0;
int counter = imProcessCounterBegin("LocalMaxThreshold");
imCounterTotal(counter, src_image->depth*src_image->height, "Processing...");
thresAux = min_thres;
switch(src_image->data_type)
{
case IM_BYTE:
ret = DoConvolveRankFunc((imbyte*)src_image->data[0], (imbyte*)dst_image->data[0],
src_image->width, src_image->height, ks, ks, max_thres_op_byte, counter);
break;
case IM_SHORT:
ret = DoConvolveRankFunc((short*)src_image->data[0], (imbyte*)dst_image->data[0],
src_image->width, src_image->height, ks, ks, max_thres_op_short, counter);
break;
case IM_USHORT:
ret = DoConvolveRankFunc((imushort*)src_image->data[0], (imbyte*)dst_image->data[0],
src_image->width, src_image->height, ks, ks, max_thres_op_ushort, counter);
break;
case IM_INT:
ret = DoConvolveRankFunc((int*)src_image->data[0], (imbyte*)dst_image->data[0],
src_image->width, src_image->height, ks, ks, max_thres_op_int, counter);
break;
}
imProcessCounterEnd(counter);
return ret;
}
static imbyte rank_closest_op_byte(imbyte* value, int count, int center)
{
imbyte v = value[center];
imbyte min, max;
imMinMax(value, count, min, max);
if (v - min < max - v)
return min;
else
return max;
}
static imushort rank_closest_op_ushort(imushort* value, int count, int center)
{
imushort v = value[center];
imushort min, max;
imMinMax(value, count, min, max);
if (v - min < max - v)
return min;
else
return max;
}
static short rank_closest_op_short(short* value, int count, int center)
{
short v = value[center];
short min, max;
imMinMax(value, count, min, max);
if (v - min < max - v)
return min;
else
return max;
}
static int rank_closest_op_int(int* value, int count, int center)
{
int v = value[center];
int min, max;
imMinMax(value, count, min, max);
if (v - min < max - v)
return min;
else
return max;
}
static float rank_closest_op_float(float* value, int count, int center)
{
float v = value[center];
float min, max;
imMinMax(value, count, min, max);
if (v - min < max - v)
return min;
else
return max;
}
static double rank_closest_op_double(double* value, int count, int center)
{
double v = value[center];
double min, max;
imMinMax(value, count, min, max);
if (v - min < max - v)
return min;
else
return max;
}
int imProcessRankClosestConvolve(const imImage* src_image, imImage* dst_image, int ks)
{
int i, ret = 0;
int counter;
counter = imProcessCounterBegin("RankClosestConvolve");
imCounterTotal(counter, src_image->depth*src_image->height, "Processing...");
for (i = 0; i < src_image->depth; i++)
{
switch(src_image->data_type)
{
case IM_BYTE:
ret = DoConvolveRankFunc((imbyte*)src_image->data[i], (imbyte*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_closest_op_byte, counter);
break;
case IM_SHORT:
ret = DoConvolveRankFunc((short*)src_image->data[i], (short*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_closest_op_short, counter);
break;
case IM_USHORT:
ret = DoConvolveRankFunc((imushort*)src_image->data[i], (imushort*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_closest_op_ushort, counter);
break;
case IM_INT:
ret = DoConvolveRankFunc((int*)src_image->data[i], (int*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_closest_op_int, counter);
break;
case IM_FLOAT:
ret = DoConvolveRankFunc((float*)src_image->data[i], (float*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_closest_op_float, counter);
break;
case IM_DOUBLE:
ret = DoConvolveRankFunc((double*)src_image->data[i], (double*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_closest_op_double, counter);
break;
}
if (!ret)
break;
}
imProcessCounterEnd(counter);
return ret;
}
static imbyte rank_max_op_byte(imbyte* value, int count, int center)
{
imbyte min, max;
(void)center;
imMinMax(value, count, min, max);
return max;
}
static imushort rank_max_op_ushort(imushort* value, int count, int center)
{
imushort min, max;
(void)center;
imMinMax(value, count, min, max);
return max;
}
static short rank_max_op_short(short* value, int count, int center)
{
short min, max;
(void)center;
imMinMax(value, count, min, max);
return max;
}
static int rank_max_op_int(int* value, int count, int center)
{
int min, max;
(void)center;
imMinMax(value, count, min, max);
return max;
}
static float rank_max_op_float(float* value, int count, int center)
{
float min, max;
(void)center;
imMinMax(value, count, min, max);
return max;
}
static double rank_max_op_double(double* value, int count, int center)
{
double min, max;
(void)center;
imMinMax(value, count, min, max);
return max;
}
int imProcessRankMaxConvolve(const imImage* src_image, imImage* dst_image, int ks)
{
int i, ret = 0;
int counter;
counter = imProcessCounterBegin("RankMaxConvolve");
imCounterTotal(counter, src_image->depth*src_image->height, "Processing...");
for (i = 0; i < src_image->depth; i++)
{
switch(src_image->data_type)
{
case IM_BYTE:
ret = DoConvolveRankFunc((imbyte*)src_image->data[i], (imbyte*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_max_op_byte, counter);
break;
case IM_SHORT:
ret = DoConvolveRankFunc((short*)src_image->data[i], (short*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_max_op_short, counter);
break;
case IM_USHORT:
ret = DoConvolveRankFunc((imushort*)src_image->data[i], (imushort*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_max_op_ushort, counter);
break;
case IM_INT:
ret = DoConvolveRankFunc((int*)src_image->data[i], (int*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_max_op_int, counter);
break;
case IM_FLOAT:
ret = DoConvolveRankFunc((float*)src_image->data[i], (float*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_max_op_float, counter);
break;
case IM_DOUBLE:
ret = DoConvolveRankFunc((double*)src_image->data[i], (double*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_max_op_double, counter);
break;
}
if (!ret)
break;
}
imProcessCounterEnd(counter);
return ret;
}
static imbyte rank_min_op_byte(imbyte* value, int count, int center)
{
imbyte min, max;
(void)center;
imMinMax(value, count, min, max);
return min;
}
static imushort rank_min_op_ushort(imushort* value, int count, int center)
{
imushort min, max;
(void)center;
imMinMax(value, count, min, max);
return min;
}
static short rank_min_op_short(short* value, int count, int center)
{
short min, max;
(void)center;
imMinMax(value, count, min, max);
return min;
}
static int rank_min_op_int(int* value, int count, int center)
{
int min, max;
(void)center;
imMinMax(value, count, min, max);
return min;
}
static float rank_min_op_float(float* value, int count, int center)
{
float min, max;
(void)center;
imMinMax(value, count, min, max);
return min;
}
static double rank_min_op_double(double* value, int count, int center)
{
double min, max;
(void)center;
imMinMax(value, count, min, max);
return min;
}
int imProcessRankMinConvolve(const imImage* src_image, imImage* dst_image, int ks)
{
int i, ret = 0;
int counter;
counter = imProcessCounterBegin("RankMinConvolve");
imCounterTotal(counter, src_image->depth*src_image->height, "Processing...");
for (i = 0; i < src_image->depth; i++)
{
switch(src_image->data_type)
{
case IM_BYTE:
ret = DoConvolveRankFunc((imbyte*)src_image->data[i], (imbyte*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_min_op_byte, counter);
break;
case IM_SHORT:
ret = DoConvolveRankFunc((short*)src_image->data[i], (short*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_min_op_short, counter);
break;
case IM_USHORT:
ret = DoConvolveRankFunc((imushort*)src_image->data[i], (imushort*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_min_op_ushort, counter);
break;
case IM_INT:
ret = DoConvolveRankFunc((int*)src_image->data[i], (int*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_min_op_int, counter);
break;
case IM_FLOAT:
ret = DoConvolveRankFunc((float*)src_image->data[i], (float*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_min_op_float, counter);
break;
case IM_DOUBLE:
ret = DoConvolveRankFunc((double*)src_image->data[i], (double*)dst_image->data[i],
src_image->width, src_image->height, ks, ks, rank_min_op_double, counter);
break;
}
if (!ret)
break;
}
imProcessCounterEnd(counter);
return ret;
}
| [
"scuri@af3c9e47-74de-4ca0-9433-524f997074d0"
] | scuri@af3c9e47-74de-4ca0-9433-524f997074d0 |
f4275bf998bef323747bdab8c99f3859bfac6c1c | ac41d2ccb549dc09ed34e5c0f4da403509abb5c3 | /lib/mtl4/boost/numeric/mtl/matrix/operators.hpp | aaf155b5377cd29154981f6a49ae8bddc0d22131 | [
"MIT",
"MTLL"
] | permissive | spraetor/amdis2 | c65b530dabd087d922d616bfaf9d53f4c8d5e3c4 | 53c45c81a65752a8fafbb54f9ae6724a86639dcd | refs/heads/master | 2020-12-24T15:51:03.069002 | 2016-03-06T14:42:53 | 2016-03-06T14:42:53 | 39,136,073 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,036 | hpp | // Software License for MTL
//
// Copyright (c) 2007 The Trustees of Indiana University.
// 2008 Dresden University of Technology and the Trustees of Indiana University.
// 2010 SimuNova UG (haftungsbeschränkt), www.simunova.com.
// All rights reserved.
// Authors: Peter Gottschling and Andrew Lumsdaine
//
// This file is part of the Matrix Template Library
//
// See also license.mtl.txt in the distribution.
#ifndef MTL_MATRIX_OPERATORS_INCLUDE
#define MTL_MATRIX_OPERATORS_INCLUDE
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/and.hpp>
#include <boost/numeric/mtl/utility/ashape.hpp>
#include <boost/numeric/mtl/utility/is_multi_vector_expr.hpp>
#include <boost/numeric/mtl/utility/static_assert.hpp>
#include <boost/numeric/mtl/matrix/all_mat_expr.hpp>
#include <boost/numeric/mtl/mtl_fwd.hpp>
namespace mtl { namespace matrix {
template <typename E1, typename E2>
inline mat_mat_plus_expr<E1, E2>
operator+ (const mat_expr<E1>& e1, const mat_expr<E2>& e2)
{
// do not add matrices with inconsistent value types
MTL_STATIC_ASSERT((boost::is_same<typename ashape::ashape<E1>::type,
typename ashape::ashape<E2>::type>::value), "Matrices have not consistent algebraic shape (i.e. nested types).");
return mat_mat_plus_expr<E1, E2>(static_cast<const E1&>(e1), static_cast<const E2&>(e2));
}
// if enabled it has priority over previous functions because that performs upcast
template <typename E1, typename E2>
typename boost::enable_if_c<mtl::traits::is_multi_vector_expr<E1>::value && mtl::traits::is_multi_vector_expr<E2>::value, mv_mv_plus_expr<E1, E2> >::type
inline operator+(const E1& e1, const E2& e2)
{
return mv_mv_plus_expr<E1, E2>(e1, e2);
}
// Specialization for multi_vector
// template <typename V1, typename V2>
// inline mv_mv_plus_expr<multi_vector<V1>, multi_vector<V2> >
// operator+(const multi_vector<V1>& m1, const multi_vector<V2>& m2)
// {
// return mv_mv_plus_expr<multi_vector<V1>, multi_vector<V2> >(m1, m2);
// }
#if 0
// Planned for future optimizations on sums of dense matrix expressions
template <typename E1, typename E2>
inline dmat_dmat_plus_expr<E1, E2>
operator+ (const dmat_expr<E1>& e1, const dmat_expr<E2>& e2)
{
// do not add matrices with inconsistent value types
MTL_STATIC_ASSERT((boost::is_same<typename ashape::ashape<E1>::type,
typename ashape::ashape<E2>::type>::value), "Matrices have not consistent algebraic shape (i.e. nested types).");
return dmat_dmat_plus_expr<E1, E2>(static_cast<const E1&>(e1), static_cast<const E2&>(e2));
}
#endif
template <typename E1, typename E2>
inline mat_mat_minus_expr<E1, E2>
operator- (const mat_expr<E1>& e1, const mat_expr<E2>& e2)
{
// do not add matrices with inconsistent value types
MTL_STATIC_ASSERT((boost::is_same<typename ashape::ashape<E1>::type,
typename ashape::ashape<E2>::type>::value), "Matrices have not consistent algebraic shape (i.e. nested types).");
return mat_mat_minus_expr<E1, E2>(static_cast<const E1&>(e1), static_cast<const E2&>(e2));
}
// if enabled it has priority over previous functions because that performs upcast
template <typename E1, typename E2>
typename boost::enable_if_c<mtl::traits::is_multi_vector_expr<E1>::value && mtl::traits::is_multi_vector_expr<E2>::value, mv_mv_minus_expr<E1, E2> >::type
inline operator-(const E1& e1, const E2& e2)
{
return mv_mv_minus_expr<E1, E2>(e1, e2);
}
template <typename E1, typename E2>
inline mat_mat_ele_times_expr<E1, E2>
ele_prod(const mat_expr<E1>& e1, const mat_expr<E2>& e2)
{
// do not multiply matrices element-wise with inconsistent value types
MTL_STATIC_ASSERT((boost::is_same<typename ashape::ashape<E1>::type,
typename ashape::ashape<E2>::type>::value), "Matrices do not have consistent algebraic shape (i.e. nested types).");
return mat_mat_ele_times_expr<E1, E2>(static_cast<const E1&>(e1), static_cast<const E2&>(e2));
}
}} // namespace mtl::matrix
#endif // MTL_MATRIX_OPERATORS_INCLUDE
| [
"simon.praetorius@tu-dresden.de"
] | simon.praetorius@tu-dresden.de |
85ea641036f247161babd9817c22cafdd0e124f5 | 23de84139576dca7e4d768e6e3d43efdaa0e9d4a | /Source/JHNET/NetworkModule/NetworkTool.cpp | 81af36f37cbdc851981e0314b4f3a3821b21b0ab | [] | no_license | LJH960101/FlockingGame | 0c8d1948cc9222252d1ef40440ff255fffe9cc53 | e9873d20b249c93bcf5a016323a17c9f4bc9c46a | refs/heads/master | 2020-05-26T03:04:55.492065 | 2019-05-26T06:40:00 | 2019-05-26T06:40:00 | 188,084,778 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,590 | cpp | #include "NetworkTool.h"
#include "Serializer.h"
#include <memory>
using namespace std;
using namespace NetworkTool;
using namespace MySerializer;
int NetworkTool::Send(SOCKET sock, const char * buf, int len, int flags)
{
shared_ptr<char[]> newBuf(new char[len + sizeof(int)]);
int intLen = IntSerialize(newBuf.get(), len);
memcpy(newBuf.get() + intLen, buf, len);
return SendWithoutLen(sock, newBuf.get(), len + intLen, flags);
}
int NetworkTool::SendWithoutLen(SOCKET sock, const char* buf, int len, int flags)
{
return send(sock, buf, len, flags);
}
int NetworkTool::SendTo(SOCKET sock, const char* buf, const int& len, sockaddr* addr, const int& addrLen)
{
shared_ptr<char[]> newBuf(new char[len + sizeof(int)]);
int intLen = IntSerialize(newBuf.get(), len);
memcpy(newBuf.get() + intLen, buf, len);
return SendToWithoutLen(sock, newBuf.get(), len + intLen, addr, addrLen, 0);
}
int NetworkTool::SendToWithoutLen(SOCKET sock, const char* buf, const int& len, sockaddr* addr, const int& addrLen, int flags)
{
return sendto(sock, buf, len, flags, addr, addrLen);
}
bool NetworkTool::IsBigEndian()
{
static bool onInit = false;
static bool isBigEndian = false;
if (!onInit) {
onInit = true;
unsigned int x = 0x76543210;
char *c = (char*)&x;
if (*c == 0x10)
{
isBigEndian = false;
}
else
{
isBigEndian = true;
}
}
return isBigEndian;
}
FString NetworkTool::UINT64ToFString(const UINT64 val)
{
return FString::Printf(TEXT("%llu"), val);
}
UINT64 NetworkTool::FStringToUINT64(const FString val)
{
return FCString::Strtoui64(*val, NULL, 10);
} | [
"ljh960101@gmail.com"
] | ljh960101@gmail.com |
67513628e011561712dfa165d2b252f866ca7731 | 022debae1ce006014899cf2db313845dca625d7a | /项目/格子机2.0/wine_grid2018_11_10/temp/1toast.cpp | 816979a93c9b73808c9ba0b521ef1574dc23179c | [] | no_license | isliulin/PythonDemoRepository | 5e3c73e4ba363e84ccd476d93d9eab33759ea665 | 7f0d4e34373ba9254dd1a03c7e3b25656ca1632f | refs/heads/master | 2023-03-18T16:25:43.666794 | 2019-03-15T17:20:13 | 2019-03-15T17:20:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 479 | cpp | #include "toast.h"
Toast::Toast(QWidget *parent) : QLabel(parent)
{
this->hide();
this->setWindowFlags(Qt::FramelessWindowHint|Qt::WindowStaysOnTopHint);
//this->setAttribute(Qt::WA_DeleteOnClose,true);
this->setAlignment(Qt::AlignCenter);
this->setObjectName("Toast");
// label->setScaledContents(true); //自动和文本一样的高度
// LabelName->setWordWrap(true);
// LabelName->setAlignment(Qt::AlignTop);
}
Toast *Toast::pToast = NULL;
| [
"2640340412@qq.com"
] | 2640340412@qq.com |
22c15c55056a1cb07e8ea0727bf30f22985464bf | 32cd83e08737002c3c7bc815c65f2c94b5ac6966 | /D02/ex02/Fixed.cpp | a7a1764032f582911f6a8abecde2de34cb0bc40c | [] | no_license | tirrorex/Cpp | 4d9be9f94bf24a0ecb5a825e77fd044b80e08327 | 8e0a02897d4ed5d3780714dad2491150862e2fba | refs/heads/master | 2021-01-20T19:53:11.418429 | 2016-05-27T14:57:21 | 2016-05-27T14:57:21 | 59,841,750 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,900 | cpp | #include "Fixed.hpp"
#include <iostream>
#include <string>
#include <cmath>
const int Fixed::_bit = 8;
Fixed::Fixed( void ) : _fixValue( 0 )
{
//std::cout << "Default Constructor called" << std::endl;
return;
}
Fixed::Fixed( int const n ) : _fixValue( n << _bit )
{
//std::cout << "Int Constructor called" << std::endl;
return;
}
Fixed::Fixed( float const n ) : _fixValue((int)roundf(n * (1 << _bit)))
{
//std::cout << "Float Constructor called" << std::endl;
return;
}
Fixed::Fixed( Fixed const & src )
{
//std::cout << "Copy Constructor called" << std::endl;
*this = src;
return;
}
Fixed::~Fixed( void )
{
//std::cout << "Destructor Called" << std::endl;
return;
}
int Fixed::getRawBits( void ) const
{
return this->_fixValue;
}
void Fixed::setRawBits( int const raw )
{
this->_fixValue = raw;
}
float Fixed::toFloat( void ) const
{
return (((float)this->_fixValue) / (1 << _bit));
}
int Fixed::toInt( void ) const
{
return this->_fixValue >> _bit;
}
bool Fixed::operator>( Fixed const &rhs )
{
return this->getRawBits() > rhs.getRawBits();
}
bool Fixed::operator<( Fixed const &rhs )
{
return this->getRawBits() < rhs.getRawBits();
}
bool Fixed::operator>=( Fixed const &rhs )
{
return this->getRawBits() >= rhs.getRawBits();
}
bool Fixed::operator<=( Fixed const &rhs )
{
return this->getRawBits() <= rhs.getRawBits();
}
bool Fixed::operator==( Fixed const &rhs )
{
return this->getRawBits() == rhs.getRawBits();
}
bool Fixed::operator!=( Fixed const &rhs )
{
return this->getRawBits() != rhs.getRawBits();
}
Fixed Fixed::operator+( Fixed const & rhs )
{
return Fixed( this->toFloat() + rhs.toFloat() );
}
Fixed Fixed::operator-( Fixed const & rhs )
{
return Fixed( this->toFloat() - rhs.toFloat() );
}
Fixed Fixed::operator*( Fixed const & rhs )
{
return Fixed( this->toFloat() * rhs.toFloat() );
}
Fixed Fixed::operator/( Fixed const & rhs )
{
return Fixed( this->toFloat() / rhs.toFloat() );
}
Fixed Fixed::operator++( void )
{
Fixed ret(*this);
this->_fixValue += 1;
return *this;
}
Fixed Fixed::operator--( void )
{
this->_fixValue -= 1;
return *this;
}
Fixed Fixed::operator++( int )
{
Fixed ret(*this);
this->_fixValue += 1;
return ret;
}
Fixed Fixed::operator--( int )
{
Fixed ret(*this);
this->_fixValue -= 1;
return ret;
}
Fixed & Fixed::min( Fixed & rhs1, Fixed & rhs2 )
{
return rhs1.getRawBits() > rhs2.getRawBits() ? rhs2: rhs1;
}
Fixed & Fixed::max( Fixed & rhs1, Fixed & rhs2 )
{
return rhs1.getRawBits() > rhs2.getRawBits() ? rhs1: rhs2;
}
const Fixed & Fixed::min( Fixed const & rhs1, Fixed const & rhs2 )
{
return rhs1.getRawBits() > rhs2.getRawBits() ? rhs2: rhs1;
}
const Fixed & Fixed::max( Fixed const & rhs1, Fixed const & rhs2 )
{
return rhs1.getRawBits() > rhs2.getRawBits() ? rhs1: rhs2;
}
std::ostream & operator<<( std::ostream & o, Fixed const & i )
{
o << i.toFloat();
return o;
} | [
"thibaut.noah@gmail.com"
] | thibaut.noah@gmail.com |
71abd807e170c8e7522e1493ca882dcf2140c1f7 | aa4bdcdf47e15ec43b073e602ca15e7e8dc916b0 | /treap.cpp | 79ea5d5295d0bff75960a0b54ee7f6610b774cec | [] | no_license | newpolaris/algorithm | dbd51d036f4f892702403200919efb872aa92ec6 | 70e7fdc96811da7cda681cb96d7b5041d7932c76 | refs/heads/master | 2021-01-12T17:16:36.359070 | 2019-11-24T17:29:34 | 2019-11-24T17:29:34 | 71,535,310 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,555 | cpp | #include <iostream>
#include <string>
#include <vector>
#include <random>
#include <memory>
#include "print_binary_tree.hpp"
using namespace std;
/*
* note : rand is fast enough
* speed up
* comment - just 2x fast http://stackoverflow.com/a/3747462
*
inline int fastrand() {
g_seed = (214013*g_seed+2531011);
return (g_seed>>16)&0x7FFF;
}
*/
typedef int KeyType;
// 트립의 한 노드를 저장한다.
struct Node {
// 이 노드의 우선 순위, 이 노드를 루트로 하는 서브트리의 크기
int priority, size;
// 노드에 저장된 원소
KeyType key;
Node *left, *right;
// 생성자에서 난수 우선 순위를 생성하고, size 와 left/right를 초기화 한다.
Node(KeyType key) : priority(rand()),
left(nullptr), right(nullptr),
key(move(key)), size(1) {}
~Node() {
delete left;
left = nullptr;
delete right;
right = nullptr;
}
void setLeft(Node* l) {
left = l;
calcSize();
}
void setRight(Node* r) {
right = r;
calcSize();
}
// element 갱신
void calcSize() {
size = 1;
if (left) size += left->size;
if (right) size += right->size;
}
};
typedef pair<Node*, Node*> NodePair;
// root 를 루트로 하는 트립을 key미만의 값과 이상의 값을 갖는
// 두개의 트립으로 분리한다
NodePair split(Node* root, KeyType key) {
if (!root) return { nullptr, nullptr };
// 이상(같은 키 포함) 일 경우 왼쪽을 쪼갠다
if (key <= root->key) {
auto pair = split(root->left, key);
root->setLeft(pair.second);
return { pair.first, root };
} else {
auto pair = split(root->right, key);
root->setRight(pair.first);
return { root, pair.second };
}
}
Node* insert(Node* root, Node* node) {
if (!root) return node;
// node가 루트를 대체해야 한다. 해당 서브 트리를 반으로 잘라
// 각각 자손으로 한다
if (root->priority < node->priority) {
auto pair = split(root, node->key);
node->setLeft(pair.first);
node->setRight(pair.second);
return node;
} else if (node->key < root->key) {
root->setLeft(insert(root->left, node));
// 같은 키 일 경우 오른쪽
} else {
root->setRight(insert(root->right, node));
}
return root;
}
// a 와 b가 두개의 트립이고, key 값이 max(a) < min(b) 일 떄 이 둘을 합친다.
Node* merge(Node* a, Node* b) {
if (!a) return b;
if (!b) return a;
// left rotate
if (a->priority < b->priority) {
b->setLeft(merge(a, b->left));
return b;
// right rotate
} else {
a->setRight(merge(a->right, b));
return a;
}
}
// root를 루트로 하는 트립에서 key를 지우고 결과 트립의 루트를 반환한다
Node* erase(Node* root, KeyType key) {
if (!root) return root;
if (root->key == key) {
auto node = merge(root->left, root->right);
root->left = nullptr;
root->right = nullptr;
delete root;
return node;
} else {
if (key < root->key)
root->setLeft(erase(root->left, key));
else
root->setRight(erase(root->right, key));
}
return root;
}
Node* kth(Node* root, int k) {
int leftSize = 0;
if (root->left != nullptr) leftSize = root->left->size;
if (k <= leftSize) return kth(root->left, k);
if (k == leftSize + 1) return root;
return kth(root->right, k - leftSize - 1);
}
// key 미만을 가지는 node 의 수를 반환한다
int countLessThan(Node* root, KeyType key) {
if (root == NULL) return 0;
if (root->key >= key)
return countLessThan(root->left, key);
int ls = (root->left ? root->left->size : 0);
return ls + 1 + countLessThan(root->right, key);
}
// print_binary_tree 를 위한 출력 stream
std::ostream& operator<<(std::ostream& strm, const Node& node) {
return strm << node.key << "," << node.size;
}
int main()
{
Node* root = nullptr;
root = insert(root, new Node(10));
root = insert(root, new Node(15));
root = insert(root, new Node(3));
print_ascii_tree(root);
root = erase(root, 3);
print_ascii_tree(root);
root = erase(root, 15);
print_ascii_tree(root);
root = erase(root, 10);
root = insert(root, new Node(10));
root = insert(root, new Node(1));
root = insert(root, new Node(10));
root = insert(root, new Node(1));
root = insert(root, new Node(10));
root = insert(root, new Node(1));
root = insert(root, new Node(10));
root = insert(root, new Node(10));
root = insert(root, new Node(10));
root = insert(root, new Node(10));
root = insert(root, new Node(1));
root = insert(root, new Node(1));
root = insert(root, new Node(1));
root = insert(root, new Node(1));
print_ascii_tree(root);
delete root;
root = nullptr;
return 0;
}
| [
"newpolaris@gmail.com"
] | newpolaris@gmail.com |
10837893bd5e94256749146986ea42cf452df956 | 21b3889b6a94b0a6ccf1677866c32d69c20b3452 | /MercutioEngine/meMessage.h | 6753b8da6c04655bed62fe2657425dd97dcb933e | [] | no_license | waskerdu/Mercutio-Engine | b38b7c2dc0fd61cae29bcc999a9de63403ce1de8 | 28e9c3022283f899535e9fb8d1eca3371345b23b | refs/heads/master | 2020-03-30T15:27:36.022721 | 2018-11-11T20:57:29 | 2018-11-11T20:57:29 | 151,364,283 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 231 | h | #pragma once
#include <string>
struct Message
{
std::string name = "";
float val = 0;
Message(){}
Message(std::string name) { this->name = name; }
Message(std::string name, float val) { this->name = name; this->val = val; }
}; | [
"rileywestonmiller@outlook.com"
] | rileywestonmiller@outlook.com |
aeb61a18bad2f2d6442dd36bf35957b3766a96dd | 2dc7792f8bbfe207f2b54f8cae08cbd29049c2ac | /RedneckEngine/Plane.h | b4b739166e8499227b67a5f10aa5dda56697cbc6 | [
"MIT"
] | permissive | TheHolyBell/RedneckEngine | 135ff9e8625668ef3ceec9f2fa23b45ef02937f1 | 3534b24de3ef5336bec9f7b04c31cbb4a5b8cc6e | refs/heads/master | 2022-06-26T00:52:07.620860 | 2020-05-02T16:59:50 | 2020-05-02T16:59:50 | 234,753,834 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,401 | h | #pragma once
#include <optional>
#include "Vertex.h"
#include "IndexedTriangleList.h"
#include <DirectXMath.h>
#include "Math.h"
#include <array>
class Plane
{
public:
static IndexedTriangleList MakeTesselatedTextured(Dvtx::VertexLayout layout, int divisions_x, int divisions_y)
{
namespace dx = DirectX;
assert(divisions_x >= 1);
assert(divisions_y >= 1);
constexpr float width = 2.0f;
constexpr float height = 2.0f;
const int nVertices_x = divisions_x + 1;
const int nVertices_y = divisions_y + 1;
Dvtx::VertexBuffer vb{ std::move(layout) };
{
const float side_x = width / 2.0f;
const float side_y = height / 2.0f;
const float divisionSize_x = width / float(divisions_x);
const float divisionSize_y = height / float(divisions_y);
const float divisionSize_x_tc = 1.0f / float(divisions_x);
const float divisionSize_y_tc = 1.0f / float(divisions_y);
for (int y = 0, i = 0; y < nVertices_y; y++)
{
const float y_pos = float(y) * divisionSize_y - 1.0f;
const float y_pos_tc = 1.0f - float(y) * divisionSize_y_tc;
for (int x = 0; x < nVertices_x; x++, i++)
{
const float x_pos = float(x) * divisionSize_x - 1.0f;
const float x_pos_tc = float(x) * divisionSize_x_tc;
vb.EmplaceBack(
dx::XMFLOAT3{ x_pos,y_pos,0.0f },
dx::XMFLOAT3{ 0.0f,0.0f,-1.0f },
dx::XMFLOAT2{ x_pos_tc,y_pos_tc }
);
}
}
}
std::vector<unsigned short> indices;
indices.reserve(Math::sq(divisions_x * divisions_y) * 6);
{
const auto vxy2i = [nVertices_x](size_t x, size_t y)
{
return (unsigned short)(y * nVertices_x + x);
};
for (size_t y = 0; y < divisions_y; y++)
{
for (size_t x = 0; x < divisions_x; x++)
{
const std::array<unsigned short, 4> indexArray =
{ vxy2i(x,y),vxy2i(x + 1,y),vxy2i(x,y + 1),vxy2i(x + 1,y + 1) };
indices.push_back(indexArray[0]);
indices.push_back(indexArray[2]);
indices.push_back(indexArray[1]);
indices.push_back(indexArray[1]);
indices.push_back(indexArray[2]);
indices.push_back(indexArray[3]);
}
}
}
return{ std::move(vb),std::move(indices) };
}
static IndexedTriangleList Make()
{
using Dvtx::VertexLayout;
VertexLayout vl;
vl.Append(VertexLayout::Position3D);
vl.Append(VertexLayout::Normal);
vl.Append(VertexLayout::Texture2D);
return MakeTesselatedTextured(std::move(vl), 1, 1);
}
}; | [
"kamalzubairow@gmail.com"
] | kamalzubairow@gmail.com |
15872a7a802d4a773324b89e8740d4663ae06609 | 9a3b9d80afd88e1fa9a24303877d6e130ce22702 | /src/Providers/UNIXProviders/EndpointInArea/UNIX_EndpointInArea_HPUX.hxx | 8d82a24fbf885c721fd223c41ecd23d37455d439 | [
"MIT"
] | permissive | brunolauze/openpegasus-providers | 3244b76d075bc66a77e4ed135893437a66dd769f | f24c56acab2c4c210a8d165bb499cd1b3a12f222 | refs/heads/master | 2020-04-17T04:27:14.970917 | 2015-01-04T22:08:09 | 2015-01-04T22:08:09 | 19,707,296 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,812 | hxx | //%LICENSE////////////////////////////////////////////////////////////////
//
// Licensed to The Open Group (TOG) under one or more contributor license
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
// this work for additional information regarding copyright ownership.
// Each contributor licenses this file to you under the OpenPegasus Open
// Source License; you may not use this file except in compliance with the
// License.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//////////////////////////////////////////////////////////////////////////
//
//%/////////////////////////////////////////////////////////////////////////
#ifdef PEGASUS_OS_HPUX
#ifndef __UNIX_ENDPOINTINAREA_PRIVATE_H
#define __UNIX_ENDPOINTINAREA_PRIVATE_H
#endif
#endif
| [
"brunolauze@msn.com"
] | brunolauze@msn.com |
44da2e331fdc7fdad863f63945ea45a9b84b5a19 | b2ac71ecae7b4b9a7d72b20c8582e79195e81e4a | /Classes/webview/CaeWebView.cpp | a2dc88ef31b311b254b6d5756be4f6b1eeb99278 | [] | no_license | liyonghelpme/jumpCode | 54a10e231f0c1bae08b4a1a82c31a43d77e83c1b | a38f186e2acb2c119701ee06d3e8b0d76a54d00b | refs/heads/master | 2021-01-02T09:38:29.371709 | 2013-06-12T10:14:36 | 2013-06-12T10:14:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 649 | cpp | #include "CaeWebView.h"
NS_CC_EXT_BEGIN
CaeWebView::CaeWebView(){
}
CaeWebView::~CaeWebView(){
}
void CaeWebView::webViewDidFinishLoad(){
}
void CaeWebView::closeWebView(){
this->removeFromParentAndCleanup(true);
#if(CC_TARGET_PLATFORM==CC_PLATFORM_IOS)
[impl closeWebView];
#elif(CC_TARGET_PLATFORM==CC_PLATFORM_ANDROID)
#endif
}
// only do normal set here
bool CaeWebView::init(){
if(!!CCLayer::init()){
return false;
}
#if(CC_TARGET_PLATFORM==CC_PLATFORM_IOS)
impl = [[CaeWebView_iosImpl alloc] init];
[impl addWebView:this withUrl:"http://www.baidu.com"];
#elif(CC_TARGET_PLATFORM==CC_PLATFORM_ANDROID)
#endif
}
NS_CC_EXT_END | [
"liyonghelpme@gmail.com"
] | liyonghelpme@gmail.com |
579ab65e4e4fb5048c67567ee5ebdb6e68f33a29 | 0ca4a1b70fecd20b240534b1a65b843d7f268fcb | /C++/DisplayPanel/weathersettings.h | 84a7687fa683155822cad79f01131406dffde17a | [] | no_license | Smart-controller/PC-Panel-Display | da1a87ceaca022d7613cd40cfebfcacb68d1be4d | dfd67219e08236381e35e82c8036ebcd9c0cee18 | refs/heads/master | 2021-01-21T15:37:22.107466 | 2015-06-14T06:49:00 | 2015-06-14T06:49:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 421 | h | #ifndef WEATHERSETTINGS_H
#define WEATHERSETTINGS_H
#include "inifunctions.h"
#include <QWidget>
namespace Ui {
class WeatherSettings;
}
class WeatherSettings : public QWidget
{
Q_OBJECT
public:
explicit WeatherSettings(QWidget *parent = 0);
~WeatherSettings();
IniFunctions ini;
private slots:
void on_DoneButton_clicked();
private:
Ui::WeatherSettings *ui;
};
#endif // WEATHERSETTINGS_H
| [
"danj.scripter@gmail.com"
] | danj.scripter@gmail.com |
c0de1c6a04e639f15c36ddcb1cf7930bff9cb84b | 8dc84558f0058d90dfc4955e905dab1b22d12c08 | /ios/chrome/browser/ui/overlays/overlay_queue_manager_observer.h | 58ef15048f9138a0a08f7ccf83646b6d3bf224cd | [
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause"
] | permissive | meniossin/src | 42a95cc6c4a9c71d43d62bc4311224ca1fd61e03 | 44f73f7e76119e5ab415d4593ac66485e65d700a | refs/heads/master | 2022-12-16T20:17:03.747113 | 2020-09-03T10:43:12 | 2020-09-03T10:43:12 | 263,710,168 | 1 | 0 | BSD-3-Clause | 2020-05-13T18:20:09 | 2020-05-13T18:20:08 | null | UTF-8 | C++ | false | false | 1,145 | h | // Copyright 2017 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.
#ifndef IOS_CHROME_BROWSER_UI_OVERLAYS_OVERLAY_QUEUE_MANAGER_OBSERVER_H_
#define IOS_CHROME_BROWSER_UI_OVERLAYS_OVERLAY_QUEUE_MANAGER_OBSERVER_H_
#include "base/macros.h"
class OverlayQueue;
class OverlayQueueManager;
// Observer class for OverlayQueueManager.
class OverlayQueueManagerObserver {
public:
OverlayQueueManagerObserver() = default;
virtual ~OverlayQueueManagerObserver() = default;
// Called when an OverlayQueueManager creates |queue|.
virtual void OverlayQueueManagerDidAddQueue(OverlayQueueManager* manager,
OverlayQueue* queue) {}
// Called when an OverlayQueueManager is about to remove |queue|.
virtual void OverlayQueueManagerWillRemoveQueue(OverlayQueueManager* manager,
OverlayQueue* queue) {}
private:
DISALLOW_COPY_AND_ASSIGN(OverlayQueueManagerObserver);
};
#endif // IOS_CHROME_BROWSER_UI_OVERLAYS_OVERLAY_QUEUE_MANAGER_OBSERVER_H_
| [
"arnaud@geometry.ee"
] | arnaud@geometry.ee |
d63739138d3d5ac1fd53d572ee56a2bc972e8d5e | 8584afff21c31c843f520bd28587a741e6ffd402 | /GoogleCodeJam/2008/Round1A/a.cpp | 5a5a0db46da866c72d4c3e60cae399f72cc5ffcc | [] | no_license | YuanzhongLi/CompetitiveProgramming | 237e900f1c906c16cbbe3dd09104a1b7ad53862b | f9a72d507d4dda082a344eb19de22f1011dcee5a | refs/heads/master | 2021-11-20T18:35:35.412146 | 2021-08-25T11:39:32 | 2021-08-25T11:39:32 | 249,442,987 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,759 | cpp | #include <bits/stdc++.h>
using namespace std;
#define rep(i,s,n) for (int i = (int)s; i < (int)n; i++)
#define ll long long
#define pb push_back
#define eb emplace_back
#define All(x) x.begin(), x.end()
#define Range(x, i, j) x.begin() + i, x.begin() + j
#define lbidx(x, y) lower_bound(x.begin(), x.end(), y) - x.begin()
#define ubidx(x, y) upper_bound(x.begin(), x.end(), y) - x.begin()
#define llbidx(x, y, z) lower_bound(x.begin(), x.end(), z) - lower_bound(x.begin(), x.end(), y) // 二要素間の距離
#define deg2rad(deg) ((((double)deg)/((double)360)*2*M_PI))
#define rad2deg(rad) ((((double)rad)/(double)2/M_PI)*(double)360)
#define Find(set, element) set.find(element) != set.end()
#define Decimal(x) printf("%.10f\n", x) // 小数点を10桁まで表示
// debug用
#define PrintVec(x) for (auto elementPrintVec: x) { cout << elementPrintVec << " "; } cout << endl;
typedef pair<int, int> PI;
typedef pair<ll, ll> PLL;
int POWINT(int x, int n) {
int ret = 1;
rep(i, 0, n) ret *= x;
return ret;
};
ll POWLL(int x, int n) {
ll ret = 1;
rep(i, 0, n) ret *= x;
return ret;
};
template<class T>
inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
};
template<class T>
inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
int n;
rep(t, 0, T) {
cin >> n;
vector<ll> a(n), b(n);
rep(i, 0, n) {
cin >> a[i];
}
rep(i, 0, n) {
cin >> b[i];
}
sort(All(a));
sort(All(b));
reverse(All(b));
ll ans = 0;
rep(i, 0, n) {
ans += (a[i] * b[i]);
}
printf("Case #%d: %lld\n", t+1, ans);
}
return 0;
};
| [
"liyuanzhongutokyos1@gmail.com"
] | liyuanzhongutokyos1@gmail.com |
fcdae6432bcec04670dd6c00aa07ef5661fb5118 | 77bcbea313082bdd089ec0f312891eb26ea93c0d | /hotheater1/constant/ellipse/polyMesh/owner | dbc3285eb46a08af9a4a0523e937a2efeec71df5 | [] | no_license | zachery-style/prolate_home | 5db0d4483a864eb6cd569e16613ff3e9bc439c72 | 86f5cfd83cc27333982c37dd085861f226985f10 | refs/heads/main | 2023-04-08T15:23:34.483706 | 2021-04-20T17:24:41 | 2021-04-20T17:24:41 | 359,894,523 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 99,170 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v2012 |
| \\ / A nd | Website: www.openfoam.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class labelList;
note "nPoints:8920 nCells:6041 nFaces:20943 nInternalFaces:17049";
location "constant/ellipse/polyMesh";
object owner;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
20943
(
0
0
0
0
0
1
1
1
1
1
2
2
2
2
2
2
3
3
3
3
3
4
4
4
4
4
5
5
5
5
5
5
6
6
6
6
6
7
7
7
7
7
7
8
8
8
8
8
8
9
9
9
9
10
10
10
10
10
10
11
11
11
11
11
11
12
12
12
12
12
12
13
13
13
13
13
13
14
14
14
14
14
15
15
15
16
16
16
16
17
17
17
17
17
17
18
18
18
19
19
19
19
19
19
20
20
20
20
20
20
20
20
20
21
21
21
21
21
21
22
22
22
22
22
22
22
22
22
22
22
22
23
23
23
23
23
23
23
23
23
24
24
24
24
24
24
25
25
25
25
25
25
26
26
26
26
26
26
27
27
27
27
27
27
28
28
28
28
28
28
29
29
29
29
29
29
29
29
29
29
29
29
30
30
30
30
30
30
31
31
31
31
31
31
32
32
32
32
32
32
33
33
33
34
34
34
34
34
34
35
35
35
35
35
35
36
36
36
36
36
36
36
36
36
37
37
37
37
37
38
38
38
38
38
38
39
39
39
39
39
39
40
40
40
40
40
40
41
41
41
41
41
41
41
41
41
41
41
41
42
42
42
43
43
43
43
43
43
43
43
43
43
43
43
43
43
43
44
44
44
44
44
44
45
45
45
45
45
45
46
46
46
46
46
46
47
47
47
47
47
47
47
47
47
47
47
47
48
48
48
48
48
48
49
49
49
49
49
49
50
50
50
50
50
50
51
51
51
51
51
51
51
51
51
51
51
51
52
52
52
52
52
52
53
53
53
53
53
53
53
53
53
53
53
53
53
53
53
54
54
54
55
55
55
55
55
55
55
55
55
55
55
55
56
56
56
56
56
56
56
56
56
57
57
57
57
57
57
58
58
58
58
58
58
59
59
59
59
59
59
59
59
59
59
59
59
59
59
59
60
60
60
61
61
61
62
62
62
63
63
63
63
64
64
64
64
64
64
64
64
64
64
64
64
65
65
65
65
65
65
66
66
66
66
66
66
66
66
66
66
66
66
66
66
66
67
67
67
67
67
67
68
68
68
68
68
68
69
69
69
69
69
70
70
70
70
70
70
71
71
71
71
71
71
72
72
72
72
72
72
73
73
73
73
73
73
73
73
73
73
73
73
73
73
73
74
74
74
74
74
74
75
75
75
75
75
75
76
76
76
76
76
76
77
77
77
77
77
77
77
77
77
78
78
78
78
78
78
79
79
79
79
79
79
80
80
80
80
80
80
81
81
81
81
81
82
82
82
82
82
82
83
83
83
83
83
83
84
84
84
84
84
84
85
85
85
85
85
85
86
86
86
86
86
86
87
87
87
87
87
87
88
88
88
88
88
88
89
89
89
89
89
89
89
89
89
90
90
90
90
90
91
91
91
91
91
91
91
91
91
91
91
91
92
92
92
92
92
92
93
93
93
93
93
93
94
94
94
94
94
94
94
94
94
94
94
94
94
94
94
95
95
95
95
95
95
95
95
95
96
96
96
96
96
96
97
97
97
97
97
97
98
98
98
98
98
98
99
99
99
99
99
99
99
99
99
100
100
100
100
100
100
101
101
101
101
101
101
101
101
101
102
102
102
102
102
103
103
103
103
103
103
103
103
103
104
104
104
104
104
104
105
105
105
105
105
105
106
106
106
106
106
106
106
106
106
106
106
106
107
107
107
107
107
107
107
107
107
107
107
107
107
107
107
108
108
108
108
108
108
109
109
109
109
109
109
110
110
110
110
110
110
111
111
111
111
111
112
112
112
112
112
112
113
113
113
113
113
113
114
114
114
114
115
115
115
115
115
115
116
116
116
116
116
116
116
116
116
116
116
116
116
116
116
117
117
117
117
117
117
118
118
118
118
118
118
119
119
119
119
119
119
119
119
119
120
120
120
120
120
120
120
120
120
120
120
120
121
121
121
121
121
121
122
122
122
122
122
122
123
123
123
123
123
123
123
123
123
124
124
124
124
124
124
124
124
124
124
124
124
125
125
125
125
125
126
126
126
126
126
126
126
126
126
126
126
126
127
127
127
127
127
127
127
127
127
128
128
128
128
128
128
128
128
128
128
128
128
129
129
129
129
130
130
130
130
130
131
131
131
131
131
131
131
131
131
132
132
132
132
132
132
132
132
132
133
133
133
133
133
133
134
134
134
134
134
134
135
135
135
135
135
135
135
135
135
136
136
136
136
136
136
136
136
136
137
137
137
137
137
137
138
138
138
138
138
138
139
139
139
139
139
139
139
139
139
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
141
141
141
141
141
141
142
142
142
142
142
142
143
143
143
143
143
143
143
143
143
144
144
144
144
144
144
145
145
145
145
145
145
146
146
146
146
146
146
147
147
147
147
147
147
148
148
148
148
148
149
149
149
149
149
149
150
150
150
150
150
151
151
151
151
152
152
152
152
152
153
153
153
154
154
154
154
155
155
155
155
155
156
156
156
156
157
157
157
157
157
158
158
158
158
159
159
159
160
160
160
160
161
161
161
162
162
162
162
162
163
163
164
164
164
165
165
165
165
166
166
166
166
167
167
167
167
168
168
168
169
169
169
169
169
170
170
171
171
171
172
172
172
172
173
173
173
173
174
174
174
175
175
175
176
176
176
176
176
176
177
177
177
177
177
177
178
178
178
178
178
179
179
179
179
179
180
180
180
180
180
180
181
181
182
182
183
183
183
183
184
184
184
184
184
185
185
185
185
185
185
186
186
186
187
187
187
187
188
188
188
189
189
189
189
190
190
190
190
191
191
191
191
192
192
192
192
192
193
193
193
193
194
194
195
195
195
195
195
196
196
196
197
197
197
198
198
198
198
199
199
199
200
200
200
201
201
201
201
201
202
202
203
203
203
204
204
204
205
205
205
206
206
206
206
206
207
207
207
208
208
208
209
209
210
210
210
210
210
211
211
212
212
213
213
213
213
213
214
214
214
214
214
215
215
215
215
215
215
216
216
216
216
216
216
217
217
217
217
217
217
217
217
217
217
217
217
217
217
217
218
218
219
219
219
219
219
220
220
220
220
221
221
221
221
221
221
222
222
222
222
222
222
223
223
223
223
223
223
223
223
223
223
223
223
223
223
223
224
224
224
225
225
225
226
226
226
226
226
227
227
227
227
227
227
227
227
227
227
227
227
228
228
228
228
228
228
228
229
229
229
229
229
229
229
230
230
230
230
230
230
230
231
231
231
232
232
232
233
233
233
233
233
234
234
234
234
235
235
235
235
235
235
235
235
235
235
235
236
236
236
236
236
236
237
237
237
237
237
237
237
237
237
237
237
238
238
238
239
239
239
240
240
240
240
240
241
241
241
241
241
241
242
242
242
242
242
242
242
243
243
243
243
243
243
243
244
244
244
244
244
244
244
245
245
245
246
246
246
246
247
247
247
247
247
248
248
248
248
248
248
248
248
248
248
248
248
248
249
249
249
249
249
249
249
250
250
250
250
250
250
250
250
250
250
250
251
251
251
251
251
251
251
252
252
252
253
253
253
254
254
254
254
254
255
255
255
255
255
255
256
256
256
256
256
256
256
257
257
257
257
257
257
257
258
258
258
258
258
258
258
259
259
260
260
260
260
260
261
261
261
261
261
262
262
262
262
262
263
263
263
263
264
264
264
264
265
265
265
266
266
266
266
266
266
267
267
267
267
268
268
268
268
268
269
269
269
270
271
271
271
272
272
272
273
273
273
273
274
274
275
275
275
275
275
275
275
276
276
276
276
276
276
276
277
277
277
277
277
277
277
278
278
278
278
278
279
279
279
279
279
280
280
280
280
280
281
281
281
281
281
282
282
282
282
282
282
282
283
283
283
283
283
283
283
283
283
283
284
284
284
284
284
284
284
285
285
285
285
285
286
286
286
286
286
287
287
287
287
287
288
288
288
288
288
289
289
289
289
289
289
290
290
290
290
290
290
291
291
291
291
291
291
291
292
292
292
293
293
293
293
294
294
294
294
295
295
295
295
295
296
296
296
296
296
296
296
296
296
296
296
296
296
296
297
297
297
297
297
298
298
298
298
298
298
298
298
298
298
298
299
299
299
299
299
300
300
300
300
300
301
301
301
301
301
301
302
302
302
302
302
302
303
303
303
303
303
303
303
304
304
304
305
305
305
305
306
306
306
306
307
307
307
307
307
308
308
308
308
308
308
308
308
308
309
309
309
309
309
309
310
310
310
310
310
310
310
310
310
310
311
311
311
312
312
312
312
313
313
313
313
314
314
314
314
314
315
315
315
315
315
315
315
315
315
315
316
316
316
316
316
317
317
317
317
317
317
317
317
317
317
317
318
318
318
318
319
319
319
319
319
320
320
320
320
320
320
321
321
321
321
321
321
322
322
322
322
322
322
322
323
323
323
324
324
324
324
325
325
325
325
326
326
326
326
326
327
327
327
327
327
327
328
328
328
328
328
328
328
329
329
329
329
329
329
329
329
329
329
330
330
330
330
331
331
331
331
332
332
332
332
332
333
333
333
333
333
334
334
334
335
335
335
336
336
337
337
337
337
338
338
338
338
339
339
339
340
340
340
340
341
341
341
342
342
342
343
343
343
343
344
344
344
345
345
345
346
346
347
347
347
347
348
348
349
349
349
350
350
350
350
351
351
352
352
352
353
353
353
354
354
354
355
356
356
356
357
357
357
358
358
358
359
359
359
360
360
360
361
361
362
362
363
363
363
363
364
364
365
365
366
366
366
367
368
368
368
369
369
369
369
370
370
370
371
371
371
372
372
372
373
373
373
374
374
374
375
375
375
375
376
376
377
377
377
377
378
378
379
379
379
379
380
381
381
382
382
382
383
383
384
384
384
384
384
385
386
386
387
387
387
387
387
387
388
388
388
388
388
389
389
389
389
390
390
391
392
392
392
393
393
393
393
393
394
394
394
394
394
395
395
395
396
396
398
398
399
399
399
399
399
400
400
401
401
401
401
402
404
404
405
405
405
405
405
406
406
406
406
407
407
408
408
409
410
410
410
410
411
411
411
411
412
413
414
415
415
415
415
416
416
416
417
417
417
418
418
418
418
419
419
419
420
420
421
421
421
421
422
422
422
423
423
423
424
424
424
425
425
425
425
426
426
427
427
428
428
428
429
429
430
430
431
431
431
431
432
432
433
433
434
434
434
434
435
435
436
436
437
437
437
438
438
439
439
439
440
440
440
441
442
442
442
443
443
443
443
444
444
444
445
445
446
446
446
446
447
447
448
448
449
449
449
450
450
451
451
452
452
452
453
453
453
453
454
454
454
454
455
455
455
456
456
456
456
457
457
458
458
458
458
459
459
459
459
460
460
460
460
460
461
461
462
462
462
463
463
464
464
465
465
465
465
466
466
466
468
468
468
468
468
468
469
469
470
470
470
470
470
471
471
471
471
471
472
472
473
473
473
473
473
473
474
474
475
475
475
475
475
476
476
476
476
477
477
477
477
477
478
478
478
479
479
479
479
479
480
480
480
480
480
481
481
481
481
481
481
482
483
483
483
483
483
484
484
484
484
485
485
485
486
486
486
486
487
487
487
488
488
488
488
488
489
489
489
489
490
490
490
491
491
491
492
492
492
493
493
493
494
494
494
494
494
495
495
495
495
495
495
495
495
495
495
495
495
495
495
496
496
496
496
496
496
497
497
497
498
498
498
498
498
499
499
499
499
499
500
500
500
500
501
501
502
502
502
502
503
503
503
503
504
504
504
505
505
505
505
506
506
506
506
507
507
508
508
509
509
509
510
510
510
510
510
510
510
510
510
511
511
511
511
511
512
512
512
512
512
512
512
512
512
512
513
513
513
513
513
513
514
514
514
515
515
515
515
516
516
516
516
517
517
517
517
517
518
518
518
518
519
519
519
520
520
520
521
521
521
521
521
522
522
522
522
523
523
523
524
524
524
525
525
525
526
526
526
526
526
526
526
526
526
527
527
527
527
527
528
528
528
528
528
528
528
528
528
528
529
529
529
529
529
529
530
530
531
531
531
532
532
533
533
533
534
534
534
534
535
535
535
535
536
536
536
536
536
537
537
537
537
537
538
538
538
538
539
539
539
539
540
540
540
540
541
541
541
541
542
542
543
543
544
544
544
545
545
545
545
545
545
545
545
545
546
546
546
546
546
547
547
547
547
547
547
547
547
547
547
547
547
547
548
548
548
548
548
549
550
550
550
550
551
551
551
552
552
552
552
552
553
553
553
554
554
554
554
554
554
554
554
554
554
554
554
554
554
555
555
555
555
555
556
556
556
556
556
556
556
556
556
556
556
557
557
557
558
558
558
559
559
559
559
559
560
560
560
560
560
560
561
561
561
561
561
561
561
562
562
562
562
562
562
562
563
563
563
563
563
563
563
564
564
564
565
565
565
566
566
566
566
566
567
567
567
567
567
567
568
568
568
568
568
568
568
568
568
568
569
569
569
569
569
569
569
570
570
570
570
570
570
570
570
570
570
571
571
572
572
572
573
573
573
574
574
574
574
574
575
575
575
576
576
576
576
576
577
577
577
578
578
578
578
578
579
579
579
580
580
580
580
580
580
580
580
580
580
580
581
581
581
581
581
582
582
582
582
582
582
582
582
582
582
582
583
583
583
584
584
584
585
585
585
585
585
586
586
586
586
586
586
587
587
587
587
587
587
587
588
588
588
588
588
588
588
589
589
589
589
589
589
589
590
590
590
591
591
591
592
592
592
592
592
592
593
593
593
593
593
593
593
593
593
593
593
593
593
594
594
594
594
594
594
594
594
594
594
595
595
595
595
595
595
596
596
596
597
597
597
597
597
598
598
598
598
598
599
599
599
599
599
599
600
600
600
601
601
601
601
601
602
602
602
603
603
603
603
603
603
603
603
603
603
603
604
604
604
604
604
605
605
605
605
605
605
605
605
605
605
605
606
606
606
607
607
607
608
608
608
608
608
609
609
609
609
609
609
610
610
610
610
610
610
610
611
611
611
611
611
611
611
612
612
612
612
612
612
612
613
613
613
614
614
614
614
614
614
614
614
614
615
615
615
615
615
616
616
616
616
616
616
616
616
616
616
616
616
616
617
617
617
617
617
617
618
618
618
619
619
620
620
620
620
620
621
621
621
621
621
621
622
622
622
623
623
623
623
623
624
624
624
625
625
625
625
625
625
625
625
625
625
625
626
626
626
626
626
627
627
627
627
627
627
627
627
627
627
627
627
627
627
628
628
628
629
629
629
630
630
630
630
630
630
631
631
631
631
631
631
631
631
631
631
631
631
631
632
632
632
632
632
632
632
632
632
632
632
632
632
633
633
633
633
633
633
634
634
634
635
635
635
636
636
636
636
636
637
637
637
637
637
638
638
638
638
639
640
640
640
641
641
641
641
641
642
642
642
642
642
643
643
643
643
643
643
644
644
644
645
645
645
645
645
646
646
646
646
646
647
647
647
647
647
647
648
648
648
649
649
650
650
650
651
651
651
652
652
652
652
652
653
653
653
654
654
654
654
654
655
655
655
656
656
657
657
658
659
659
659
659
659
659
660
660
660
661
661
661
662
662
662
662
662
663
663
664
664
664
664
664
665
665
665
665
665
666
666
666
666
666
666
666
666
666
666
666
666
666
666
666
667
667
667
668
668
668
668
668
668
668
668
668
668
668
668
668
668
668
669
669
669
669
669
670
670
670
670
670
670
670
670
670
670
670
670
671
671
671
671
671
671
671
671
671
671
671
671
671
672
672
672
673
673
673
673
673
673
673
673
673
673
674
674
674
675
675
675
676
676
676
676
676
677
677
678
678
678
678
678
679
679
679
679
679
680
680
680
681
681
681
681
681
681
682
682
682
682
683
683
683
683
684
684
684
684
684
684
685
685
685
686
686
686
686
686
686
687
687
687
688
688
688
689
689
689
689
689
689
689
689
689
689
689
689
689
689
690
690
690
691
691
691
691
691
691
691
691
691
691
691
691
691
691
692
692
692
692
692
693
693
693
693
693
693
693
694
694
694
694
694
694
695
695
695
695
695
696
696
696
697
697
697
698
698
698
698
699
699
699
700
700
700
701
701
701
701
702
702
702
702
703
703
703
703
703
703
704
704
705
705
705
705
705
706
706
706
706
706
707
707
707
707
707
707
708
708
708
708
708
708
708
708
708
709
709
709
709
709
709
709
709
709
709
709
709
710
710
710
711
711
711
711
711
711
711
711
711
711
711
711
712
712
712
713
713
713
713
713
713
714
714
714
715
715
715
715
716
716
716
716
717
717
717
717
717
717
718
718
718
719
719
719
719
719
720
720
720
720
720
721
721
721
721
721
722
722
722
722
722
722
722
722
722
722
722
722
722
722
722
723
723
724
724
724
724
724
724
724
724
725
725
725
726
726
726
726
726
727
727
727
728
728
728
729
729
729
730
730
730
731
731
731
731
732
732
732
732
732
732
733
733
733
734
734
734
734
734
735
735
735
735
735
735
735
735
735
735
735
735
736
736
736
737
737
737
737
737
737
737
737
737
737
738
738
738
739
739
739
739
739
739
739
740
740
740
740
740
741
741
741
741
741
741
741
742
742
742
742
743
743
743
743
743
743
744
744
744
744
744
745
745
745
745
746
746
746
746
746
746
746
746
746
746
746
746
746
746
747
747
747
747
747
747
747
748
748
748
748
748
748
749
749
750
750
750
751
751
751
751
752
752
753
753
753
753
754
754
754
754
755
755
755
755
755
755
756
756
756
756
756
756
757
757
757
758
758
758
758
758
758
758
759
759
759
760
760
760
760
760
760
760
761
761
761
761
761
761
761
761
761
761
761
761
761
761
762
762
762
763
763
763
764
764
764
764
764
764
764
764
764
764
764
764
765
765
765
766
766
766
766
766
766
767
767
767
767
767
768
768
768
768
768
768
768
769
769
769
769
769
770
770
771
771
771
772
772
772
772
772
773
773
773
773
773
774
774
774
774
774
774
775
775
775
775
776
776
776
776
776
776
776
776
776
776
776
776
776
777
777
777
777
778
778
778
778
778
778
779
779
779
780
780
780
780
780
781
781
781
781
781
782
782
782
782
782
782
783
783
783
784
784
784
784
785
785
785
785
785
785
786
786
786
787
787
787
787
787
788
788
788
788
788
789
789
789
789
789
789
790
790
790
790
791
791
791
791
792
792
792
792
792
792
792
793
793
793
793
793
793
794
794
794
794
794
794
794
794
794
794
794
794
794
794
795
795
795
795
795
796
796
797
797
797
798
798
798
798
798
799
799
799
799
799
800
800
800
800
800
800
801
801
801
802
802
802
802
803
803
803
804
804
804
804
804
804
805
805
805
806
806
806
807
807
807
807
807
808
808
808
808
808
809
809
809
809
809
809
809
809
809
809
809
809
809
810
810
810
811
811
811
811
812
812
812
812
812
812
812
812
812
812
813
813
813
813
814
814
814
814
814
814
814
814
814
814
814
814
815
815
815
815
815
815
815
815
815
816
816
816
816
817
817
817
818
818
818
818
818
818
819
819
819
819
819
819
820
820
820
820
820
820
820
820
820
820
820
820
820
820
820
821
821
821
821
822
822
822
823
823
823
823
823
823
824
824
824
824
824
825
825
825
825
825
826
827
827
827
828
828
828
829
829
829
829
829
830
830
831
831
832
832
833
833
833
833
833
834
834
834
835
835
835
835
835
835
835
835
835
835
835
835
835
835
835
836
836
836
837
837
837
837
837
837
837
838
838
838
838
838
839
839
839
839
839
840
840
840
840
840
840
840
840
840
840
840
840
840
840
841
841
841
841
841
841
841
841
841
841
841
842
842
843
843
843
843
843
843
843
843
843
844
844
844
845
845
845
845
845
846
846
846
846
846
846
846
846
846
846
846
846
846
847
847
847
847
847
847
848
848
848
849
849
850
850
850
850
850
851
851
851
852
852
853
853
853
853
853
854
854
854
854
855
855
855
855
855
855
856
856
856
856
857
857
857
857
858
858
858
858
858
858
859
859
859
859
860
860
860
861
861
861
861
861
861
861
861
861
862
862
862
863
863
863
863
863
863
863
864
864
864
865
865
865
865
865
865
865
865
865
865
865
865
865
866
866
866
866
866
867
867
867
867
867
867
867
867
867
867
868
868
868
868
869
869
869
869
870
870
870
870
870
870
871
871
871
872
872
872
872
872
873
873
873
873
874
874
874
874
874
874
875
875
875
875
876
876
876
876
877
877
877
877
877
877
878
878
878
879
879
879
880
880
880
880
880
880
880
880
880
880
880
880
880
880
881
881
881
881
881
882
882
882
883
883
883
883
883
883
884
884
884
884
885
885
885
885
886
886
886
886
886
887
887
887
887
888
888
888
889
889
889
889
889
889
890
890
890
891
891
891
891
891
891
891
892
892
892
893
893
893
893
893
893
893
893
893
893
893
893
893
894
894
894
894
894
895
895
895
895
895
895
895
895
895
895
896
896
896
896
896
896
896
896
896
896
896
896
897
897
897
897
897
897
898
898
898
898
898
899
899
899
899
899
899
899
900
900
900
900
900
900
901
901
901
901
901
901
901
902
902
902
902
902
902
903
903
904
904
905
905
905
906
906
907
907
907
907
907
908
908
908
909
909
909
909
909
910
910
910
910
910
910
911
911
911
911
911
911
911
911
911
911
911
911
912
912
912
913
913
913
914
914
914
914
914
914
915
915
915
915
916
916
916
916
916
916
917
917
917
918
918
918
918
918
918
919
919
919
919
920
920
920
920
920
920
920
920
920
921
921
921
921
921
922
922
922
922
922
922
922
922
922
922
922
922
922
923
923
923
924
925
925
925
926
926
926
926
926
927
927
927
927
928
928
928
928
928
928
929
929
929
930
930
930
930
930
930
931
931
931
931
932
932
932
933
933
933
933
933
933
934
934
934
934
934
934
934
934
934
934
934
934
935
935
936
936
936
937
937
937
937
938
938
938
938
939
939
939
939
939
939
940
940
940
941
941
941
941
941
942
942
942
942
942
943
943
943
943
943
943
944
944
944
944
945
945
945
945
946
946
946
946
947
947
947
948
948
948
948
948
949
949
949
949
949
950
950
950
950
950
950
951
951
951
951
952
952
952
952
952
952
952
952
952
952
952
952
953
953
953
953
954
954
954
954
954
954
954
954
954
954
954
954
954
955
955
955
955
955
955
956
956
956
956
956
956
957
958
958
958
959
959
959
959
959
960
960
960
960
960
961
961
961
961
961
961
962
963
963
963
963
964
964
964
964
965
965
965
966
966
966
967
967
967
967
968
968
968
968
968
969
969
969
970
970
970
970
970
970
970
970
970
970
970
971
971
971
971
971
971
971
971
971
971
971
972
972
972
972
973
973
973
973
973
973
973
973
973
973
973
973
973
973
973
973
973
974
974
974
975
975
975
975
975
976
976
976
976
977
977
977
978
978
979
979
979
979
980
980
980
980
980
981
981
981
982
982
982
982
982
983
983
983
983
983
984
984
984
985
985
986
986
986
986
986
987
988
988
989
990
991
992
992
992
992
992
993
993
994
994
994
995
995
995
995
995
996
997
998
998
998
998
998
999
999
999
999
1000
1000
1000
1000
1001
1001
1001
1001
1001
1001
1002
1002
1002
1002
1003
1003
1003
1003
1004
1004
1004
1004
1005
1005
1005
1005
1005
1005
1006
1006
1007
1007
1007
1008
1008
1008
1009
1009
1009
1010
1010
1010
1010
1010
1011
1011
1011
1012
1012
1012
1012
1012
1012
1012
1012
1012
1012
1012
1012
1012
1013
1013
1013
1013
1013
1013
1013
1013
1013
1013
1013
1013
1013
1014
1014
1014
1014
1014
1014
1014
1015
1015
1015
1015
1016
1016
1016
1016
1017
1017
1017
1017
1017
1018
1018
1018
1018
1019
1019
1019
1019
1019
1019
1019
1019
1019
1020
1020
1020
1020
1020
1020
1021
1021
1021
1022
1022
1022
1022
1023
1023
1023
1024
1025
1025
1025
1025
1025
1026
1026
1026
1026
1026
1026
1026
1026
1026
1026
1026
1026
1026
1027
1027
1027
1027
1028
1028
1028
1028
1028
1028
1028
1028
1028
1028
1028
1029
1029
1029
1029
1030
1030
1030
1030
1030
1030
1031
1031
1031
1031
1031
1031
1032
1032
1032
1032
1032
1032
1033
1033
1033
1033
1033
1033
1034
1034
1034
1035
1035
1035
1035
1035
1036
1036
1036
1036
1037
1037
1037
1037
1037
1038
1038
1038
1038
1039
1039
1039
1039
1039
1039
1039
1039
1039
1040
1040
1040
1040
1040
1040
1041
1041
1041
1042
1042
1042
1042
1042
1043
1043
1043
1044
1044
1044
1045
1045
1045
1045
1045
1046
1046
1046
1046
1046
1046
1046
1046
1046
1046
1047
1047
1047
1047
1047
1047
1047
1047
1047
1047
1047
1047
1047
1048
1048
1048
1048
1048
1049
1049
1049
1050
1050
1050
1051
1051
1051
1052
1052
1052
1052
1053
1053
1053
1053
1053
1053
1053
1053
1053
1054
1054
1054
1054
1054
1054
1055
1055
1055
1056
1056
1056
1056
1057
1058
1058
1058
1059
1059
1060
1060
1060
1061
1061
1062
1062
1063
1063
1063
1064
1064
1064
1064
1064
1064
1064
1064
1064
1064
1064
1065
1065
1065
1065
1066
1066
1066
1067
1067
1067
1067
1068
1068
1069
1069
1069
1069
1069
1070
1070
1070
1070
1071
1071
1071
1071
1072
1072
1073
1073
1074
1074
1075
1076
1076
1077
1077
1077
1078
1078
1079
1079
1080
1081
1081
1081
1082
1082
1082
1082
1082
1083
1083
1083
1083
1084
1084
1084
1084
1084
1085
1085
1085
1086
1086
1087
1087
1088
1088
1089
1089
1089
1089
1089
1089
1089
1089
1089
1089
1089
1089
1090
1090
1090
1090
1090
1090
1090
1090
1090
1091
1091
1091
1091
1091
1091
1092
1092
1092
1093
1093
1093
1094
1094
1094
1094
1095
1095
1095
1096
1096
1097
1097
1097
1097
1097
1098
1098
1098
1098
1098
1098
1098
1098
1098
1098
1099
1099
1099
1099
1100
1100
1100
1100
1100
1100
1100
1100
1100
1100
1101
1101
1101
1102
1102
1102
1102
1103
1103
1103
1103
1104
1104
1104
1104
1105
1105
1105
1105
1105
1106
1106
1106
1107
1107
1108
1108
1108
1109
1109
1109
1109
1109
1110
1110
1110
1110
1110
1110
1110
1110
1110
1110
1110
1110
1110
1111
1111
1111
1111
1112
1112
1112
1112
1112
1112
1113
1113
1113
1113
1114
1114
1114
1115
1115
1115
1115
1115
1115
1115
1115
1115
1115
1115
1115
1116
1116
1116
1116
1116
1116
1116
1116
1116
1116
1116
1116
1116
1116
1116
1117
1117
1117
1117
1117
1117
1118
1118
1118
1119
1119
1119
1120
1120
1120
1121
1121
1122
1122
1122
1123
1123
1123
1124
1124
1124
1125
1125
1125
1125
1126
1126
1126
1126
1127
1127
1127
1127
1127
1127
1128
1128
1128
1128
1129
1129
1129
1129
1130
1130
1130
1130
1132
1132
1132
1133
1133
1134
1135
1136
1136
1137
1137
1138
1138
1138
1139
1140
1140
1140
1140
1141
1141
1141
1142
1142
1143
1143
1143
1144
1144
1144
1145
1145
1146
1146
1146
1147
1147
1148
1148
1149
1149
1150
1150
1150
1151
1152
1152
1153
1153
1154
1155
1156
1157
1157
1157
1157
1158
1158
1159
1159
1160
1160
1160
1161
1162
1162
1163
1163
1163
1164
1164
1165
1165
1166
1166
1166
1167
1168
1168
1168
1168
1169
1169
1169
1170
1170
1170
1170
1170
1171
1171
1172
1172
1172
1173
1173
1173
1174
1174
1175
1175
1175
1175
1175
1176
1177
1177
1178
1178
1178
1178
1178
1179
1179
1179
1179
1180
1180
1181
1181
1181
1181
1183
1183
1184
1184
1185
1185
1187
1189
1189
1189
1190
1191
1191
1192
1193
1193
1193
1193
1193
1194
1194
1194
1194
1194
1195
1195
1196
1196
1196
1196
1196
1197
1197
1198
1198
1198
1199
1200
1200
1200
1200
1201
1201
1201
1201
1201
1202
1202
1202
1202
1203
1203
1204
1204
1206
1206
1206
1206
1206
1207
1207
1207
1207
1207
1208
1208
1208
1209
1209
1209
1210
1211
1211
1211
1211
1212
1212
1212
1212
1212
1213
1213
1214
1214
1215
1215
1216
1218
1218
1218
1219
1219
1220
1221
1221
1222
1223
1223
1224
1224
1224
1225
1226
1226
1227
1227
1228
1228
1229
1230
1230
1230
1231
1231
1231
1232
1233
1233
1234
1234
1235
1236
1237
1237
1237
1238
1238
1238
1238
1239
1239
1239
1240
1240
1241
1241
1242
1242
1242
1243
1243
1243
1243
1244
1244
1245
1245
1245
1246
1247
1247
1247
1247
1248
1248
1249
1249
1249
1249
1250
1250
1250
1250
1250
1251
1251
1252
1252
1252
1253
1253
1253
1254
1254
1255
1255
1255
1255
1256
1256
1256
1256
1257
1257
1258
1258
1259
1259
1259
1260
1260
1260
1261
1262
1262
1263
1263
1263
1263
1264
1265
1266
1266
1266
1266
1266
1267
1267
1267
1267
1268
1268
1268
1268
1269
1269
1269
1269
1270
1270
1271
1271
1272
1272
1273
1273
1273
1274
1274
1274
1275
1275
1275
1276
1276
1277
1280
1280
1280
1281
1281
1282
1282
1282
1282
1283
1283
1283
1283
1284
1284
1285
1285
1286
1286
1287
1287
1287
1287
1288
1288
1288
1289
1290
1290
1291
1291
1291
1292
1292
1292
1293
1294
1294
1295
1295
1295
1295
1296
1297
1298
1298
1298
1298
1298
1299
1299
1300
1300
1300
1300
1300
1301
1301
1301
1301
1301
1302
1302
1303
1304
1304
1304
1305
1305
1305
1306
1306
1306
1307
1307
1307
1308
1308
1309
1312
1312
1312
1313
1313
1313
1313
1314
1314
1314
1315
1315
1315
1316
1317
1319
1319
1320
1320
1320
1320
1321
1321
1322
1322
1322
1323
1323
1323
1325
1325
1326
1326
1327
1327
1327
1327
1328
1328
1329
1329
1329
1330
1330
1330
1332
1332
1333
1333
1333
1334
1334
1334
1335
1336
1336
1337
1337
1337
1337
1338
1339
1340
1340
1341
1341
1341
1341
1342
1342
1343
1343
1343
1344
1344
1344
1346
1346
1347
1347
1348
1348
1348
1349
1349
1350
1350
1350
1350
1351
1351
1351
1351
1352
1352
1353
1353
1354
1354
1354
1354
1355
1355
1355
1356
1356
1357
1357
1357
1357
1359
1359
1360
1361
1361
1361
1362
1362
1362
1363
1363
1363
1364
1364
1365
1368
1368
1368
1369
1369
1369
1369
1370
1370
1371
1371
1371
1372
1372
1372
1372
1373
1374
1374
1375
1375
1375
1375
1376
1376
1376
1376
1377
1377
1377
1378
1378
1378
1378
1379
1379
1379
1379
1380
1380
1381
1381
1382
1382
1382
1383
1383
1383
1383
1384
1384
1385
1385
1385
1386
1386
1386
1386
1387
1388
1388
1389
1389
1389
1389
1390
1391
1391
1392
1392
1393
1393
1393
1393
1394
1394
1395
1395
1395
1395
1396
1396
1396
1396
1397
1397
1398
1398
1399
1399
1399
1399
1400
1401
1402
1402
1403
1404
1404
1404
1405
1405
1405
1406
1407
1407
1408
1408
1408
1409
1410
1410
1410
1410
1411
1411
1411
1411
1412
1413
1413
1413
1414
1415
1416
1416
1416
1417
1417
1417
1417
1418
1418
1419
1419
1420
1420
1420
1421
1423
1423
1423
1424
1425
1426
1426
1427
1428
1428
1428
1429
1429
1430
1430
1430
1431
1431
1431
1431
1432
1432
1432
1433
1433
1434
1434
1436
1437
1437
1437
1439
1439
1440
1441
1441
1442
1442
1442
1442
1442
1443
1443
1444
1444
1445
1446
1446
1448
1448
1448
1449
1449
1449
1449
1449
1450
1451
1451
1452
1454
1455
1457
1457
1457
1459
1460
1460
1460
1460
1461
1461
1461
1461
1462
1462
1462
1463
1463
1463
1463
1464
1464
1464
1464
1465
1465
1466
1466
1467
1467
1467
1467
1468
1468
1468
1468
1469
1469
1469
1470
1470
1470
1470
1471
1471
1471
1471
1472
1472
1473
1473
1474
1474
1474
1475
1475
1475
1475
1476
1476
1477
1477
1477
1478
1478
1478
1478
1479
1480
1480
1481
1481
1481
1481
1482
1482
1482
1482
1483
1483
1483
1484
1484
1484
1484
1485
1485
1485
1485
1486
1486
1487
1487
1488
1488
1488
1488
1489
1489
1489
1489
1490
1490
1490
1491
1491
1492
1494
1495
1495
1495
1496
1496
1497
1497
1498
1498
1498
1498
1499
1499
1500
1500
1500
1501
1501
1501
1501
1502
1503
1503
1504
1504
1505
1505
1506
1506
1506
1507
1507
1507
1508
1509
1509
1510
1510
1510
1510
1511
1512
1513
1513
1513
1514
1514
1514
1514
1515
1515
1515
1516
1516
1516
1516
1517
1517
1517
1518
1519
1519
1520
1520
1520
1521
1521
1521
1521
1522
1522
1523
1523
1523
1524
1524
1524
1524
1525
1526
1526
1527
1527
1527
1527
1528
1528
1528
1529
1529
1529
1530
1530
1530
1530
1530
1532
1532
1533
1533
1534
1534
1534
1534
1535
1536
1537
1537
1538
1538
1538
1538
1539
1539
1540
1540
1540
1541
1541
1541
1543
1543
1544
1544
1544
1545
1545
1545
1547
1547
1548
1548
1548
1549
1549
1549
1550
1551
1551
1552
1552
1552
1552
1553
1554
1555
1555
1555
1555
1556
1556
1556
1556
1557
1557
1557
1558
1558
1558
1558
1559
1559
1559
1559
1560
1560
1561
1561
1562
1562
1562
1563
1563
1563
1563
1564
1564
1564
1565
1565
1565
1565
1566
1566
1566
1567
1568
1568
1569
1569
1569
1569
1570
1570
1570
1570
1571
1571
1571
1572
1572
1572
1572
1573
1573
1573
1573
1574
1574
1575
1575
1576
1576
1576
1577
1577
1577
1578
1579
1579
1580
1580
1580
1580
1581
1582
1583
1583
1583
1584
1584
1585
1585
1586
1586
1587
1587
1588
1589
1590
1591
1591
1591
1592
1592
1592
1593
1593
1594
1594
1594
1594
1595
1595
1595
1596
1596
1596
1596
1597
1597
1597
1598
1598
1598
1599
1599
1599
1600
1600
1600
1601
1601
1602
1602
1603
1603
1603
1604
1604
1605
1605
1605
1605
1606
1606
1606
1606
1607
1607
1607
1607
1608
1608
1609
1609
1609
1610
1610
1610
1611
1611
1612
1612
1612
1613
1613
1613
1614
1614
1614
1615
1615
1616
1616
1616
1616
1617
1618
1618
1619
1619
1619
1619
1620
1620
1620
1621
1621
1621
1621
1622
1622
1622
1623
1623
1624
1624
1624
1624
1625
1625
1625
1625
1625
1626
1626
1626
1627
1627
1628
1628
1628
1629
1629
1629
1629
1629
1630
1630
1630
1630
1631
1631
1631
1632
1632
1632
1633
1633
1633
1633
1633
1634
1634
1634
1635
1635
1635
1636
1636
1637
1637
1637
1637
1637
1638
1638
1638
1638
1638
1639
1639
1639
1639
1639
1640
1640
1640
1640
1641
1641
1641
1642
1642
1643
1643
1644
1644
1644
1644
1645
1645
1645
1646
1646
1646
1646
1646
1646
1647
1647
1647
1647
1648
1648
1648
1648
1649
1649
1650
1650
1650
1651
1651
1652
1652
1652
1652
1652
1653
1653
1653
1653
1653
1654
1654
1654
1654
1654
1655
1655
1655
1655
1656
1656
1656
1657
1657
1658
1658
1659
1659
1659
1659
1659
1660
1660
1660
1660
1661
1661
1661
1661
1662
1662
1662
1662
1663
1664
1664
1665
1665
1666
1666
1666
1666
1666
1667
1667
1667
1668
1668
1668
1668
1669
1669
1669
1670
1670
1671
1671
1671
1671
1671
1672
1672
1672
1672
1673
1673
1673
1673
1674
1674
1674
1674
1675
1675
1676
1676
1677
1677
1678
1678
1678
1679
1679
1679
1679
1679
1680
1680
1681
1681
1681
1682
1682
1682
1682
1683
1683
1683
1684
1684
1684
1685
1685
1685
1685
1685
1686
1686
1687
1687
1687
1687
1687
1688
1688
1688
1689
1689
1689
1690
1690
1690
1691
1691
1691
1691
1691
1692
1692
1693
1693
1694
1694
1694
1694
1695
1695
1695
1696
1696
1697
1697
1697
1698
1698
1698
1698
1699
1699
1700
1701
1701
1701
1702
1702
1702
1703
1703
1703
1704
1704
1704
1705
1705
1705
1705
1705
1705
1705
1705
1705
1705
1705
1705
1706
1706
1706
1706
1706
1706
1706
1706
1706
1706
1706
1706
1707
1707
1707
1707
1707
1708
1708
1708
1708
1708
1708
1708
1708
1708
1708
1708
1708
1709
1709
1709
1710
1710
1710
1710
1710
1711
1711
1712
1712
1712
1712
1712
1712
1712
1712
1712
1712
1712
1713
1713
1713
1713
1713
1714
1714
1714
1714
1714
1714
1714
1714
1715
1715
1716
1716
1716
1716
1716
1717
1717
1717
1718
1718
1718
1718
1718
1719
1719
1719
1719
1719
1719
1720
1720
1720
1721
1721
1721
1721
1722
1722
1722
1722
1723
1724
1724
1725
1725
1726
1726
1726
1726
1726
1726
1727
1727
1727
1727
1727
1728
1728
1728
1729
1729
1729
1730
1730
1730
1731
1731
1731
1732
1732
1733
1733
1733
1733
1733
1733
1733
1733
1734
1734
1735
1735
1735
1735
1735
1735
1735
1735
1736
1736
1737
1737
1737
1737
1737
1738
1738
1738
1739
1739
1739
1739
1739
1740
1740
1740
1740
1740
1740
1741
1741
1741
1741
1742
1742
1742
1742
1743
1743
1743
1743
1744
1744
1745
1745
1745
1746
1746
1747
1747
1747
1747
1747
1747
1747
1747
1748
1748
1748
1749
1749
1749
1749
1749
1749
1749
1749
1750
1750
1750
1751
1751
1751
1751
1751
1752
1752
1752
1752
1753
1753
1753
1753
1753
1754
1754
1754
1754
1754
1754
1755
1755
1755
1755
1756
1756
1756
1756
1757
1757
1757
1757
1758
1758
1759
1759
1759
1760
1760
1761
1761
1761
1761
1761
1762
1762
1763
1763
1763
1764
1764
1764
1764
1764
1764
1764
1764
1764
1764
1764
1765
1765
1765
1765
1765
1765
1766
1766
1766
1767
1767
1767
1768
1768
1768
1768
1768
1769
1769
1769
1770
1770
1770
1770
1770
1770
1770
1770
1771
1771
1771
1771
1771
1772
1772
1772
1773
1773
1773
1773
1774
1774
1774
1774
1775
1776
1776
1777
1777
1778
1778
1778
1778
1778
1779
1779
1779
1779
1780
1780
1780
1780
1781
1781
1781
1781
1782
1782
1783
1783
1784
1784
1785
1785
1785
1785
1786
1786
1786
1786
1786
1787
1787
1788
1788
1788
1789
1789
1789
1789
1790
1790
1791
1791
1792
1792
1792
1792
1792
1792
1792
1792
1793
1793
1793
1794
1794
1794
1794
1794
1795
1795
1796
1796
1796
1796
1796
1797
1797
1798
1798
1798
1798
1798
1798
1799
1799
1799
1800
1800
1800
1800
1800
1800
1800
1800
1801
1801
1801
1801
1802
1802
1802
1803
1803
1803
1803
1804
1804
1804
1804
1804
1805
1805
1805
1806
1806
1807
1807
1807
1807
1807
1807
1807
1807
1808
1808
1808
1809
1809
1809
1809
1809
1810
1810
1810
1811
1811
1811
1811
1811
1811
1812
1812
1812
1813
1813
1813
1813
1813
1813
1813
1813
1813
1813
1813
1814
1814
1814
1814
1814
1814
1815
1815
1815
1816
1816
1816
1817
1817
1817
1817
1817
1818
1818
1818
1819
1819
1819
1819
1819
1819
1819
1819
1819
1819
1819
1820
1820
1820
1820
1820
1821
1821
1821
1821
1822
1822
1822
1822
1823
1823
1823
1823
1825
1825
1825
1826
1826
1827
1827
1827
1827
1828
1828
1828
1829
1829
1830
1830
1830
1830
1830
1830
1830
1830
1831
1831
1831
1832
1832
1832
1832
1832
1833
1833
1833
1834
1834
1834
1834
1834
1834
1835
1835
1835
1836
1836
1836
1836
1837
1837
1838
1838
1838
1838
1839
1839
1839
1840
1840
1840
1840
1840
1841
1841
1841
1841
1841
1841
1841
1841
1841
1841
1841
1842
1842
1842
1842
1842
1843
1843
1843
1843
1843
1844
1844
1844
1845
1845
1845
1845
1845
1846
1846
1847
1847
1847
1847
1847
1847
1847
1847
1847
1847
1847
1847
1848
1848
1848
1848
1848
1848
1848
1848
1849
1849
1849
1850
1850
1850
1851
1851
1851
1851
1851
1851
1852
1852
1853
1853
1853
1853
1853
1853
1853
1853
1853
1853
1853
1854
1854
1854
1854
1854
1854
1855
1855
1855
1855
1855
1856
1856
1856
1856
1857
1857
1857
1857
1858
1858
1859
1859
1859
1860
1860
1861
1861
1861
1861
1862
1862
1863
1863
1863
1864
1864
1865
1865
1866
1866
1866
1866
1867
1867
1867
1867
1868
1868
1869
1869
1870
1870
1870
1871
1871
1871
1872
1872
1873
1873
1873
1873
1874
1874
1874
1874
1875
1875
1875
1876
1876
1877
1877
1877
1878
1878
1878
1879
1879
1880
1880
1880
1880
1880
1881
1881
1881
1882
1882
1882
1883
1883
1883
1883
1883
1883
1883
1883
1883
1884
1884
1884
1884
1884
1884
1884
1884
1884
1884
1884
1884
1885
1885
1885
1885
1885
1886
1886
1886
1886
1886
1887
1887
1888
1888
1888
1888
1888
1889
1889
1889
1889
1889
1890
1890
1890
1890
1890
1890
1890
1890
1890
1890
1891
1891
1891
1891
1891
1892
1892
1892
1892
1892
1892
1892
1893
1893
1893
1893
1893
1894
1894
1894
1894
1895
1895
1895
1895
1895
1896
1896
1896
1896
1897
1897
1898
1898
1899
1899
1900
1900
1900
1900
1900
1901
1901
1901
1902
1902
1902
1902
1902
1903
1903
1903
1904
1904
1904
1904
1904
1904
1904
1905
1905
1905
1906
1906
1906
1906
1906
1906
1906
1907
1907
1907
1907
1907
1907
1908
1908
1908
1908
1908
1909
1909
1909
1909
1910
1910
1910
1910
1911
1911
1911
1912
1912
1912
1913
1913
1914
1914
1915
1915
1915
1915
1915
1916
1916
1916
1917
1917
1917
1918
1918
1918
1918
1918
1918
1919
1919
1919
1919
1919
1919
1919
1919
1919
1919
1919
1919
1920
1920
1921
1921
1921
1921
1921
1922
1922
1922
1923
1923
1923
1923
1923
1924
1924
1924
1925
1925
1925
1925
1925
1925
1925
1926
1926
1926
1927
1927
1927
1927
1927
1927
1927
1928
1928
1928
1928
1928
1928
1929
1929
1929
1929
1929
1930
1930
1930
1930
1931
1931
1931
1931
1932
1932
1932
1933
1933
1933
1934
1934
1935
1935
1935
1935
1935
1936
1936
1936
1936
1936
1937
1937
1937
1938
1938
1938
1939
1939
1939
1940
1940
1941
1941
1942
1942
1942
1943
1943
1943
1943
1943
1943
1943
1943
1944
1944
1945
1945
1945
1945
1945
1946
1946
1947
1947
1947
1947
1947
1948
1948
1948
1949
1949
1949
1949
1949
1949
1949
1950
1950
1950
1951
1951
1951
1951
1951
1951
1951
1951
1951
1951
1952
1952
1952
1952
1952
1953
1953
1953
1954
1954
1954
1954
1954
1955
1955
1955
1955
1955
1956
1956
1956
1956
1957
1957
1957
1957
1958
1958
1959
1959
1959
1960
1960
1961
1961
1961
1961
1961
1962
1962
1962
1962
1963
1963
1963
1963
1963
1964
1964
1964
1964
1965
1965
1966
1966
1967
1967
1967
1968
1968
1968
1969
1969
1969
1969
1970
1970
1970
1970
1971
1971
1971
1971
1972
1972
1973
1973
1974
1974
1975
1975
1975
1975
1976
1976
1976
1976
1977
1977
1977
1978
1978
1978
1979
1979
1979
1980
1980
1980
1980
1980
1981
1981
1981
1981
1982
1982
1982
1982
1982
1983
1983
1983
1984
1984
1984
1984
1984
1984
1984
1985
1985
1985
1985
1986
1986
1986
1986
1986
1987
1987
1987
1988
1989
1989
1990
1990
1990
1990
1990
1991
1991
1991
1992
1992
1992
1992
1992
1992
1992
1992
1993
1993
1994
1994
1994
1994
1994
1994
1994
1994
1995
1995
1996
1996
1996
1996
1996
1997
1997
1997
1998
1998
1998
1998
1998
1998
1998
1998
1998
1998
1999
1999
1999
2000
2000
2000
2000
2000
2000
2000
2000
2000
2000
2001
2001
2001
2001
2001
2001
2001
2001
2002
2002
2002
2003
2003
2003
2003
2003
2003
2004
2004
2004
2004
2004
2005
2005
2005
2005
2006
2006
2006
2006
2007
2007
2007
2008
2008
2008
2009
2009
2010
2010
2010
2010
2010
2011
2011
2011
2011
2011
2012
2012
2012
2013
2013
2013
2014
2014
2015
2015
2015
2015
2015
2016
2016
2016
2017
2017
2017
2017
2017
2017
2017
2017
2018
2018
2019
2019
2019
2019
2019
2019
2019
2019
2020
2020
2020
2020
2020
2021
2021
2021
2022
2022
2022
2022
2023
2023
2024
2024
2024
2024
2024
2025
2025
2025
2025
2025
2026
2026
2026
2027
2027
2027
2028
2028
2029
2029
2029
2029
2029
2030
2030
2031
2031
2031
2031
2031
2031
2031
2031
2032
2032
2032
2032
2032
2033
2033
2033
2033
2033
2033
2033
2033
2033
2033
2034
2034
2034
2034
2035
2035
2035
2035
2035
2035
2036
2036
2037
2037
2037
2037
2037
2037
2037
2037
2037
2037
2038
2038
2038
2038
2038
2038
2039
2039
2039
2039
2039
2039
2039
2039
2039
2039
2039
2040
2040
2040
2040
2040
2040
2040
2040
2040
2040
2041
2041
2041
2042
2042
2042
2042
2042
2043
2043
2044
2044
2045
2045
2046
2046
2046
2047
2047
2047
2047
2048
2049
2049
2049
2049
2050
2050
2050
2051
2051
2051
2051
2051
2052
2052
2052
2053
2054
2054
2054
2054
2054
2054
2055
2055
2055
2055
2055
2056
2056
2056
2056
2056
2057
2057
2058
2058
2058
2059
2059
2060
2061
2061
2061
2061
2061
2061
2062
2062
2062
2062
2063
2063
2063
2063
2064
2064
2064
2064
2064
2065
2065
2066
2066
2066
2067
2067
2067
2068
2068
2068
2068
2068
2069
2069
2070
2070
2071
2071
2071
2072
2072
2072
2073
2073
2073
2074
2074
2074
2075
2075
2075
2075
2075
2076
2076
2076
2077
2077
2078
2078
2079
2079
2079
2079
2079
2080
2080
2080
2080
2081
2081
2081
2081
2081
2082
2082
2082
2083
2083
2084
2084
2085
2086
2086
2086
2087
2087
2087
2087
2087
2088
2088
2088
2089
2089
2090
2090
2091
2091
2091
2091
2092
2092
2092
2093
2094
2094
2094
2094
2095
2095
2095
2095
2095
2096
2096
2096
2097
2097
2097
2098
2099
2099
2100
2100
2100
2100
2101
2101
2101
2101
2102
2102
2102
2102
2102
2103
2103
2103
2103
2104
2104
2104
2105
2106
2106
2107
2107
2108
2108
2108
2109
2109
2110
2110
2110
2110
2110
2110
2111
2111
2111
2111
2112
2112
2112
2112
2113
2113
2113
2113
2114
2114
2115
2115
2115
2116
2117
2117
2117
2118
2118
2118
2118
2118
2119
2119
2119
2120
2121
2122
2122
2122
2122
2122
2123
2123
2123
2124
2124
2124
2125
2125
2126
2126
2126
2126
2126
2127
2127
2127
2127
2127
2128
2128
2128
2128
2129
2129
2129
2130
2131
2132
2132
2132
2133
2133
2133
2134
2134
2134
2135
2135
2136
2136
2137
2137
2138
2138
2139
2139
2139
2140
2140
2141
2141
2142
2142
2142
2142
2143
2143
2144
2144
2145
2145
2145
2146
2147
2147
2147
2148
2148
2149
2149
2149
2150
2150
2150
2151
2151
2151
2152
2152
2153
2153
2153
2153
2154
2154
2155
2155
2156
2156
2156
2156
2157
2157
2158
2158
2158
2159
2159
2159
2160
2161
2161
2162
2162
2163
2164
2165
2165
2166
2167
2167
2168
2168
2169
2169
2170
2170
2171
2171
2171
2172
2172
2173
2173
2174
2174
2174
2175
2175
2176
2176
2177
2177
2178
2179
2179
2179
2179
2180
2180
2181
2181
2181
2181
2182
2182
2183
2183
2183
2183
2184
2184
2184
2184
2185
2185
2185
2185
2186
2187
2188
2189
2189
2190
2190
2191
2191
2192
2192
2193
2193
2193
2194
2194
2195
2195
2195
2196
2196
2196
2197
2197
2198
2198
2198
2198
2200
2200
2201
2202
2202
2203
2203
2203
2203
2204
2205
2206
2206
2206
2207
2207
2207
2208
2208
2208
2208
2209
2209
2209
2210
2211
2212
2212
2212
2213
2213
2214
2214
2215
2215
2215
2216
2216
2217
2217
2217
2217
2218
2218
2219
2219
2220
2220
2221
2221
2221
2221
2221
2222
2222
2222
2222
2223
2223
2223
2223
2224
2225
2226
2226
2226
2227
2227
2227
2227
2228
2228
2228
2229
2229
2230
2230
2230
2230
2232
2232
2233
2234
2234
2235
2235
2235
2236
2236
2237
2237
2237
2238
2238
2240
2241
2241
2241
2242
2242
2242
2242
2243
2244
2244
2245
2245
2246
2246
2247
2247
2247
2247
2247
2248
2248
2249
2249
2249
2250
2250
2250
2251
2252
2253
2253
2254
2254
2254
2254
2255
2255
2256
2256
2257
2257
2257
2257
2259
2260
2261
2261
2261
2261
2262
2262
2262
2262
2263
2263
2263
2264
2264
2264
2264
2266
2266
2267
2268
2269
2270
2271
2271
2272
2272
2273
2273
2273
2274
2274
2275
2275
2276
2277
2277
2278
2278
2279
2279
2280
2280
2280
2280
2281
2281
2282
2282
2282
2283
2283
2283
2285
2285
2286
2286
2286
2286
2287
2287
2288
2288
2289
2289
2290
2290
2291
2291
2291
2291
2292
2293
2293
2294
2294
2295
2295
2296
2296
2297
2298
2299
2299
2300
2301
2301
2301
2302
2302
2302
2302
2303
2304
2304
2305
2305
2305
2305
2305
2306
2306
2306
2307
2307
2307
2308
2308
2308
2308
2309
2310
2310
2311
2311
2312
2312
2312
2313
2313
2313
2313
2314
2314
2314
2315
2315
2315
2316
2317
2319
2320
2321
2321
2321
2322
2323
2324
2324
2325
2325
2325
2326
2326
2326
2328
2329
2329
2330
2330
2331
2331
2333
2333
2334
2334
2334
2334
2335
2335
2335
2336
2337
2337
2338
2338
2339
2339
2339
2340
2340
2341
2342
2343
2343
2344
2345
2345
2346
2346
2346
2347
2347
2347
2347
2348
2349
2349
2350
2350
2351
2352
2352
2352
2352
2353
2353
2354
2355
2355
2355
2356
2356
2356
2356
2357
2358
2359
2359
2360
2360
2360
2361
2362
2363
2363
2363
2363
2364
2364
2365
2365
2366
2366
2367
2367
2368
2368
2368
2368
2369
2369
2370
2370
2370
2371
2371
2371
2372
2373
2373
2374
2374
2374
2374
2375
2376
2377
2378
2378
2378
2378
2379
2379
2379
2380
2381
2381
2382
2382
2382
2383
2383
2384
2384
2384
2385
2386
2386
2387
2387
2388
2389
2389
2389
2390
2391
2391
2392
2392
2392
2392
2393
2393
2393
2394
2394
2394
2394
2394
2395
2395
2395
2395
2396
2397
2398
2398
2399
2399
2400
2400
2400
2401
2402
2403
2403
2404
2404
2404
2405
2405
2405
2406
2406
2406
2407
2408
2408
2409
2410
2410
2410
2410
2411
2411
2412
2412
2413
2413
2414
2414
2414
2414
2415
2415
2415
2416
2416
2417
2418
2418
2419
2419
2419
2420
2420
2421
2421
2421
2421
2421
2422
2422
2423
2423
2424
2424
2424
2425
2426
2426
2427
2427
2428
2429
2429
2429
2430
2430
2432
2433
2433
2434
2434
2435
2435
2435
2435
2436
2436
2437
2437
2437
2438
2438
2438
2438
2438
2440
2441
2441
2442
2442
2442
2443
2443
2444
2444
2444
2445
2445
2445
2445
2447
2448
2450
2450
2451
2451
2452
2452
2452
2452
2453
2453
2454
2454
2454
2455
2457
2458
2458
2458
2459
2459
2460
2460
2460
2461
2461
2461
2462
2462
2462
2463
2463
2463
2463
2465
2466
2467
2467
2467
2467
2468
2468
2469
2469
2469
2470
2470
2470
2470
2472
2473
2473
2474
2474
2474
2475
2475
2475
2476
2476
2476
2477
2477
2477
2477
2479
2480
2481
2481
2481
2481
2482
2482
2483
2483
2483
2483
2484
2484
2484
2485
2487
2487
2488
2488
2488
2489
2489
2489
2490
2490
2491
2491
2491
2492
2492
2493
2493
2493
2494
2495
2495
2495
2496
2496
2496
2496
2497
2497
2498
2498
2498
2499
2499
2499
2499
2500
2501
2501
2502
2503
2504
2504
2504
2505
2505
2505
2506
2507
2508
2508
2508
2508
2509
2509
2509
2509
2510
2510
2510
2511
2512
2512
2512
2513
2513
2513
2514
2514
2515
2515
2515
2515
2515
2516
2517
2517
2518
2518
2518
2518
2519
2519
2520
2520
2520
2521
2521
2521
2522
2523
2523
2523
2523
2524
2524
2525
2525
2525
2525
2526
2526
2526
2527
2529
2529
2530
2530
2530
2530
2530
2531
2531
2531
2532
2532
2532
2533
2534
2535
2535
2536
2536
2536
2537
2537
2537
2538
2538
2538
2539
2539
2539
2539
2541
2542
2543
2543
2543
2543
2544
2544
2545
2545
2546
2546
2546
2548
2549
2550
2550
2550
2550
2550
2551
2551
2551
2552
2552
2552
2553
2553
2554
2554
2555
2556
2557
2557
2558
2558
2558
2558
2559
2559
2559
2560
2560
2561
2563
2564
2564
2564
2564
2565
2565
2565
2566
2566
2566
2567
2567
2567
2568
2569
2570
2571
2571
2571
2571
2572
2572
2573
2573
2573
2574
2574
2574
2574
2574
2576
2576
2577
2577
2578
2578
2579
2580
2580
2580
2580
2581
2581
2581
2582
2582
2582
2582
2582
2583
2583
2583
2583
2584
2585
2586
2586
2586
2587
2587
2588
2589
2589
2590
2590
2590
2591
2591
2591
2591
2592
2592
2592
2593
2594
2595
2595
2596
2596
2597
2597
2597
2597
2597
2598
2598
2599
2599
2600
2600
2600
2601
2601
2601
2601
2602
2602
2602
2603
2604
2605
2605
2605
2605
2606
2606
2607
2607
2607
2608
2608
2609
2611
2612
2612
2612
2612
2612
2613
2613
2613
2614
2614
2614
2615
2616
2617
2617
2618
2618
2618
2619
2619
2619
2620
2620
2620
2621
2621
2621
2621
2623
2624
2625
2625
2625
2625
2626
2626
2626
2627
2627
2627
2628
2628
2628
2629
2630
2631
2632
2632
2632
2632
2633
2633
2634
2634
2634
2635
2635
2636
2638
2639
2639
2639
2640
2640
2640
2641
2641
2641
2642
2642
2642
2642
2644
2645
2646
2646
2646
2646
2647
2648
2648
2648
2649
2650
2651
2651
2651
2651
2652
2652
2653
2653
2654
2654
2657
2658
2658
2659
2660
2660
2660
2660
2661
2661
2662
2662
2662
2662
2662
2663
2663
2663
2663
2664
2665
2666
2666
2667
2667
2669
2669
2669
2670
2671
2672
2672
2673
2673
2674
2674
2674
2674
2674
2675
2675
2676
2676
2677
2677
2677
2678
2678
2678
2678
2679
2679
2679
2680
2681
2682
2682
2682
2682
2683
2683
2684
2684
2684
2685
2685
2686
2688
2689
2689
2689
2689
2690
2690
2690
2691
2692
2692
2693
2693
2693
2694
2694
2694
2695
2695
2696
2696
2696
2696
2698
2699
2700
2700
2700
2700
2701
2701
2702
2702
2702
2703
2703
2704
2706
2707
2707
2707
2707
2708
2708
2709
2709
2709
2710
2710
2711
2713
2714
2714
2714
2714
2715
2715
2716
2716
2717
2717
2717
2717
2717
2719
2719
2720
2720
2721
2721
2722
2723
2723
2723
2723
2724
2724
2724
2724
2725
2725
2726
2727
2727
2727
2728
2728
2728
2728
2728
2729
2729
2729
2729
2730
2730
2730
2730
2730
2731
2731
2731
2731
2731
2732
2732
2733
2734
2734
2734
2735
2736
2736
2737
2738
2738
2739
2739
2740
2740
2740
2740
2740
2741
2741
2742
2742
2743
2743
2743
2743
2744
2745
2746
2746
2746
2746
2747
2747
2747
2748
2749
2749
2750
2750
2751
2751
2751
2752
2752
2752
2752
2753
2753
2754
2755
2755
2755
2755
2755
2756
2756
2756
2757
2757
2757
2757
2758
2758
2758
2759
2759
2760
2761
2761
2762
2762
2762
2762
2763
2763
2763
2764
2764
2765
2765
2765
2765
2767
2767
2768
2769
2769
2769
2769
2770
2770
2770
2770
2771
2771
2771
2771
2772
2772
2772
2773
2773
2774
2775
2776
2776
2776
2777
2777
2778
2779
2779
2779
2780
2780
2781
2782
2783
2783
2783
2783
2783
2784
2784
2784
2784
2785
2785
2785
2785
2786
2786
2786
2786
2787
2787
2788
2788
2789
2789
2790
2790
2790
2790
2790
2791
2791
2791
2792
2792
2792
2793
2793
2793
2793
2794
2795
2795
2796
2796
2797
2797
2797
2798
2798
2799
2799
2799
2799
2800
2800
2800
2800
2802
2803
2804
2804
2805
2805
2806
2806
2806
2810
2811
2811
2812
2812
2812
2813
2814
2814
2814
2814
2815
2815
2815
2816
2817
2817
2817
2818
2818
2818
2818
2819
2819
2819
2820
2820
2821
2821
2821
2821
2823
2823
2824
2825
2825
2825
2825
2826
2826
2827
2827
2828
2828
2828
2829
2829
2830
2830
2830
2830
2832
2833
2833
2833
2834
2834
2835
2835
2835
2836
2836
2836
2837
2839
2839
2840
2840
2840
2842
2843
2843
2844
2845
2847
2847
2847
2848
2848
2848
2849
2849
2849
2850
2850
2851
2852
2852
2852
2853
2853
2854
2854
2855
2855
2855
2855
2856
2856
2856
2857
2858
2858
2859
2859
2859
2859
2859
2860
2860
2861
2861
2861
2861
2862
2862
2862
2862
2863
2864
2865
2865
2865
2866
2866
2866
2867
2867
2868
2868
2868
2868
2869
2869
2869
2870
2871
2871
2872
2872
2873
2873
2874
2875
2875
2875
2876
2876
2876
2877
2878
2879
2879
2879
2880
2880
2881
2882
2882
2882
2882
2883
2883
2884
2885
2885
2886
2886
2887
2888
2888
2888
2889
2889
2889
2890
2891
2892
2892
2892
2893
2893
2893
2894
2894
2894
2895
2895
2895
2895
2895
2897
2897
2898
2898
2899
2899
2899
2899
2900
2901
2902
2902
2902
2902
2902
2903
2903
2903
2903
2904
2904
2904
2904
2905
2906
2907
2907
2907
2908
2908
2908
2909
2909
2910
2910
2911
2911
2911
2911
2912
2912
2913
2913
2913
2914
2914
2914
2914
2916
2917
2917
2918
2918
2919
2919
2919
2919
2920
2920
2921
2921
2921
2922
2922
2922
2922
2924
2925
2925
2926
2926
2926
2927
2927
2927
2927
2927
2928
2928
2929
2929
2930
2930
2931
2931
2931
2931
2931
2932
2932
2933
2933
2934
2934
2934
2936
2937
2937
2938
2938
2939
2939
2940
2940
2940
2940
2940
2941
2941
2942
2942
2942
2942
2943
2943
2943
2943
2944
2945
2946
2946
2946
2947
2947
2947
2948
2948
2948
2950
2950
2951
2951
2951
2951
2952
2952
2952
2953
2953
2953
2954
2954
2954
2954
2954
2956
2956
2957
2957
2958
2958
2959
2959
2959
2959
2960
2961
2962
2962
2962
2962
2963
2963
2964
2964
2964
2965
2965
2965
2966
2966
2966
2967
2968
2969
2969
2969
2970
2970
2970
2970
2971
2971
2972
2972
2972
2972
2974
2975
2975
2976
2976
2976
2976
2977
2977
2978
2978
2979
2979
2979
2981
2982
2983
2983
2983
2984
2985
2985
2985
2985
2985
2986
2986
2987
2987
2988
2988
2988
2990
2991
2991
2992
2992
2993
2993
2994
2994
2994
2994
2994
2995
2995
2996
2996
2996
2997
2997
2997
2998
2999
3000
3000
3001
3001
3001
3002
3002
3002
3004
3004
3005
3005
3005
3005
3006
3006
3006
3007
3007
3007
3008
3008
3008
3008
3008
3010
3010
3011
3011
3012
3012
3013
3013
3013
3013
3014
3015
3016
3016
3016
3017
3017
3017
3017
3018
3018
3018
3018
3019
3020
3020
3020
3021
3021
3022
3022
3023
3023
3023
3023
3024
3024
3024
3025
3025
3025
3025
3027
3028
3028
3029
3029
3029
3029
3030
3030
3031
3031
3031
3032
3032
3032
3032
3034
3035
3035
3036
3036
3036
3036
3036
3037
3037
3038
3038
3039
3039
3039
3040
3040
3040
3041
3041
3041
3042
3042
3042
3042
3044
3045
3046
3046
3047
3048
3048
3048
3048
3049
3049
3050
3050
3051
3051
3051
3053
3054
3055
3055
3055
3055
3055
3056
3056
3057
3057
3057
3058
3058
3058
3059
3060
3061
3061
3062
3062
3062
3063
3063
3063
3065
3065
3066
3066
3066
3066
3067
3067
3067
3068
3068
3068
3069
3069
3069
3069
3069
3071
3071
3072
3072
3073
3073
3074
3074
3074
3074
3076
3077
3077
3077
3078
3078
3078
3078
3078
3079
3079
3080
3080
3080
3081
3082
3083
3083
3084
3084
3084
3084
3084
3085
3085
3085
3086
3086
3086
3087
3088
3089
3089
3090
3090
3090
3090
3091
3091
3091
3092
3092
3093
3094
3094
3095
3095
3095
3096
3096
3096
3097
3097
3097
3098
3098
3098
3098
3100
3101
3102
3102
3102
3102
3103
3103
3103
3104
3104
3104
3104
3106
3106
3107
3108
3108
3108
3108
3109
3109
3110
3110
3110
3111
3111
3111
3113
3114
3115
3116
3116
3116
3117
3117
3117
3118
3118
3118
3119
3119
3119
3119
3121
3122
3123
3123
3123
3123
3124
3124
3125
3125
3125
3125
3126
3126
3127
3127
3127
3128
3128
3128
3129
3130
3130
3130
3130
3131
3131
3132
3132
3132
3133
3133
3133
3133
3135
3136
3136
3137
3137
3137
3137
3138
3138
3139
3139
3140
3140
3140
3142
3143
3144
3144
3145
3145
3145
3146
3146
3147
3147
3147
3148
3148
3149
3149
3150
3150
3150
3152
3153
3154
3154
3154
3155
3155
3155
3155
3156
3157
3158
3158
3158
3159
3159
3159
3160
3160
3160
3161
3161
3161
3162
3162
3163
3163
3163
3163
3163
3164
3164
3165
3165
3166
3166
3166
3167
3167
3168
3168
3168
3168
3168
3169
3169
3170
3170
3171
3171
3171
3172
3172
3172
3173
3173
3173
3174
3174
3174
3174
3176
3177
3178
3178
3178
3178
3178
3179
3179
3179
3180
3180
3180
3181
3181
3181
3181
3182
3183
3183
3184
3184
3185
3185
3185
3185
3186
3186
3187
3187
3187
3188
3188
3188
3188
3190
3191
3191
3192
3192
3192
3192
3193
3193
3193
3194
3194
3194
3194
3194
3195
3195
3195
3195
3196
3196
3197
3198
3198
3199
3199
3200
3200
3200
3201
3201
3202
3202
3204
3204
3204
3204
3204
3205
3205
3206
3206
3206
3207
3207
3207
3208
3209
3210
3210
3211
3211
3211
3211
3212
3212
3213
3213
3213
3214
3214
3214
3214
3216
3217
3217
3218
3218
3218
3218
3219
3219
3220
3220
3220
3221
3221
3221
3221
3223
3224
3224
3225
3225
3225
3226
3226
3226
3227
3227
3227
3228
3228
3228
3229
3229
3229
3229
3231
3232
3233
3233
3233
3233
3233
3234
3234
3234
3235
3235
3236
3236
3237
3237
3238
3238
3238
3238
3238
3238
3239
3239
3239
3240
3240
3240
3241
3241
3241
3242
3242
3243
3243
3244
3244
3245
3245
3245
3246
3246
3248
3248
3249
3249
3249
3249
3250
3250
3251
3251
3251
3252
3252
3252
3252
3255
3255
3256
3256
3256
3257
3258
3258
3258
3258
3258
3259
3259
3260
3260
3261
3261
3261
3261
3261
3262
3262
3263
3263
3263
3264
3264
3264
3265
3266
3267
3267
3268
3268
3268
3269
3269
3270
3270
3270
3270
3271
3271
3272
3272
3272
3273
3273
3273
3273
3275
3276
3276
3277
3277
3277
3277
3278
3278
3278
3279
3280
3280
3281
3281
3281
3281
3282
3282
3283
3283
3283
3284
3284
3284
3284
3286
3287
3287
3288
3288
3288
3289
3289
3289
3289
3289
3290
3290
3291
3291
3292
3293
3293
3294
3294
3295
3295
3295
3296
3296
3297
3297
3297
3297
3297
3298
3298
3298
3299
3299
3299
3299
3300
3300
3300
3301
3301
3302
3303
3303
3304
3304
3305
3305
3305
3307
3308
3308
3308
3309
3309
3309
3310
3310
3310
3311
3311
3311
3314
3315
3315
3315
3315
3315
3316
3316
3317
3317
3317
3318
3318
3318
3319
3320
3321
3321
3322
3322
3322
3323
3323
3324
3324
3324
3324
3325
3325
3326
3326
3326
3327
3327
3327
3327
3329
3330
3330
3331
3331
3331
3331
3332
3332
3332
3333
3334
3334
3335
3335
3335
3336
3336
3336
3336
3336
3337
3337
3338
3338
3339
3339
3339
3339
3340
3340
3340
3341
3341
3341
3341
3342
3342
3342
3342
3343
3344
3345
3345
3346
3346
3346
3346
3346
3347
3347
3347
3348
3348
3348
3349
3349
3349
3349
3350
3351
3351
3352
3352
3353
3353
3353
3353
3353
3354
3354
3355
3355
3355
3355
3356
3356
3356
3357
3358
3359
3359
3359
3360
3360
3360
3360
3361
3361
3361
3362
3362
3362
3362
3362
3363
3363
3363
3363
3364
3365
3366
3366
3367
3367
3368
3368
3368
3369
3371
3371
3371
3371
3371
3372
3372
3373
3373
3373
3374
3374
3374
3375
3376
3377
3377
3378
3378
3378
3379
3379
3380
3380
3380
3380
3381
3381
3382
3382
3382
3383
3383
3383
3383
3385
3386
3386
3387
3387
3387
3387
3388
3388
3388
3389
3390
3390
3391
3391
3391
3391
3392
3392
3393
3393
3393
3394
3394
3394
3394
3396
3397
3397
3398
3398
3398
3399
3399
3399
3399
3399
3400
3400
3401
3401
3402
3402
3402
3403
3403
3403
3404
3404
3404
3405
3405
3405
3405
3407
3408
3409
3409
3410
3411
3412
3412
3412
3412
3413
3413
3413
3414
3414
3414
3414
3416
3416
3417
3418
3418
3418
3418
3419
3420
3420
3420
3420
3421
3422
3422
3422
3423
3423
3423
3423
3423
3424
3424
3424
3425
3425
3425
3425
3426
3426
3426
3426
3427
3428
3429
3429
3429
3430
3431
3432
3432
3432
3432
3432
3433
3433
3434
3434
3434
3434
3435
3435
3435
3435
3437
3438
3438
3438
3439
3439
3439
3439
3440
3440
3441
3441
3442
3442
3443
3443
3444
3444
3444
3445
3445
3445
3446
3447
3447
3448
3448
3448
3448
3449
3449
3450
3450
3450
3451
3451
3451
3451
3453
3454
3454
3455
3456
3456
3457
3457
3457
3458
3459
3459
3460
3460
3460
3462
3463
3463
3463
3463
3463
3464
3464
3464
3465
3465
3466
3466
3466
3466
3467
3468
3468
3469
3469
3470
3470
3470
3471
3471
3472
3472
3473
3473
3473
3474
3474
3474
3475
3476
3477
3477
3478
3478
3478
3480
3481
3481
3482
3482
3482
3483
3484
3484
3484
3485
3485
3485
3485
3486
3487
3487
3488
3488
3488
3489
3490
3490
3492
3493
3493
3494
3494
3495
3495
3495
3495
3495
3496
3496
3497
3498
3498
3498
3499
3500
3500
3501
3501
3501
3501
3502
3503
3503
3504
3504
3504
3505
3505
3506
3507
3507
3508
3508
3508
3508
3509
3510
3511
3511
3511
3511
3512
3512
3512
3512
3513
3513
3514
3514
3514
3514
3515
3516
3516
3517
3518
3519
3519
3519
3519
3519
3520
3520
3521
3521
3521
3521
3522
3522
3522
3522
3523
3524
3525
3525
3525
3526
3526
3527
3527
3527
3529
3530
3530
3530
3531
3532
3532
3533
3533
3533
3534
3534
3535
3535
3535
3536
3536
3536
3536
3537
3537
3537
3537
3538
3538
3538
3539
3540
3542
3542
3542
3542
3542
3543
3543
3544
3544
3544
3545
3545
3545
3546
3547
3548
3548
3549
3549
3549
3549
3550
3550
3550
3551
3552
3553
3553
3554
3554
3554
3554
3555
3555
3555
3556
3556
3556
3556
3556
3558
3558
3559
3560
3560
3560
3561
3561
3561
3561
3562
3562
3563
3564
3564
3564
3564
3565
3565
3565
3566
3566
3566
3567
3567
3567
3568
3569
3570
3571
3571
3571
3571
3571
3572
3572
3572
3573
3573
3574
3574
3575
3575
3575
3575
3576
3576
3576
3576
3577
3578
3578
3578
3579
3579
3579
3579
3579
3579
3580
3580
3580
3581
3581
3582
3582
3582
3583
3583
3584
3584
3585
3586
3586
3588
3588
3588
3588
3588
3589
3589
3589
3589
3590
3590
3590
3591
3591
3591
3591
3592
3593
3593
3593
3594
3595
3596
3597
3598
3598
3599
3599
3599
3599
3600
3600
3601
3601
3601
3602
3603
3603
3603
3603
3604
3604
3605
3605
3606
3606
3606
3608
3609
3610
3610
3610
3610
3611
3611
3611
3611
3612
3612
3612
3613
3613
3613
3613
3614
3615
3615
3616
3617
3617
3617
3617
3618
3618
3619
3620
3621
3621
3621
3621
3621
3622
3622
3623
3623
3623
3624
3624
3624
3625
3626
3627
3627
3628
3628
3628
3629
3629
3629
3631
3631
3632
3632
3632
3632
3632
3633
3633
3634
3634
3635
3635
3635
3636
3637
3638
3639
3639
3641
3641
3641
3641
3642
3642
3642
3643
3643
3643
3644
3644
3644
3644
3646
3646
3647
3648
3649
3650
3650
3650
3650
3650
3651
3651
3652
3652
3652
3653
3653
3653
3654
3655
3656
3656
3657
3657
3657
3658
3659
3659
3660
3660
3660
3660
3661
3661
3662
3662
3662
3663
3663
3663
3663
3665
3666
3666
3667
3667
3667
3667
3668
3668
3668
3669
3669
3669
3669
3669
3671
3671
3672
3673
3673
3674
3674
3674
3675
3675
3675
3676
3676
3676
3677
3677
3677
3677
3679
3681
3681
3681
3681
3682
3682
3683
3684
3685
3685
3685
3685
3685
3686
3686
3687
3687
3687
3688
3688
3688
3689
3690
3691
3691
3692
3692
3692
3693
3693
3693
3695
3696
3696
3696
3696
3696
3697
3697
3698
3698
3699
3699
3699
3700
3701
3702
3703
3703
3705
3705
3705
3705
3706
3706
3706
3707
3707
3707
3708
3708
3708
3708
3710
3711
3713
3713
3713
3713
3714
3714
3715
3715
3716
3716
3716
3718
3719
3720
3720
3720
3720
3721
3721
3721
3722
3723
3723
3724
3724
3724
3724
3724
3725
3725
3725
3726
3726
3726
3727
3727
3727
3727
3728
3729
3729
3730
3730
3731
3731
3731
3731
3732
3732
3732
3733
3733
3733
3733
3733
3735
3735
3736
3736
3737
3739
3739
3739
3739
3740
3740
3741
3741
3742
3742
3742
3744
3745
3746
3746
3746
3746
3747
3747
3748
3748
3749
3749
3749
3751
3752
3753
3753
3753
3754
3754
3754
3754
3755
3755
3755
3755
3756
3757
3759
3759
3760
3761
3761
3762
3762
3762
3762
3763
3763
3764
3764
3764
3765
3766
3766
3766
3766
3767
3767
3768
3768
3769
3769
3769
3771
3772
3773
3773
3773
3773
3774
3774
3774
3774
3775
3775
3775
3775
3776
3776
3776
3777
3778
3778
3779
3780
3780
3780
3781
3781
3781
3783
3783
3784
3784
3784
3785
3785
3785
3787
3787
3788
3788
3788
3789
3789
3790
3791
3791
3791
3792
3792
3792
3792
3793
3793
3793
3794
3795
3795
3795
3796
3796
3796
3796
3797
3797
3798
3798
3798
3799
3799
3799
3799
3801
3802
3802
3803
3803
3803
3804
3804
3805
3805
3806
3806
3806
3807
3807
3808
3808
3808
3808
3809
3810
3811
3811
3811
3811
3811
3812
3812
3812
3812
3813
3813
3813
3814
3814
3814
3814
3815
3816
3816
3816
3817
3817
3818
3818
3818
3818
3818
3819
3819
3819
3819
3819
3820
3820
3820
3820
3821
3821
3821
3821
3822
3822
3823
3823
3823
3824
3824
3825
3825
3825
3826
3826
3826
3827
3827
3828
3828
3828
3828
3830
3831
3832
3834
3836
3836
3836
3836
3836
3837
3837
3838
3838
3838
3839
3839
3839
3840
3841
3842
3842
3843
3844
3844
3844
3844
3845
3845
3846
3846
3846
3847
3847
3847
3847
3849
3850
3850
3851
3851
3851
3851
3851
3852
3852
3852
3852
3853
3853
3853
3855
3855
3856
3857
3857
3857
3858
3858
3858
3859
3859
3859
3860
3860
3860
3862
3864
3864
3864
3864
3864
3865
3865
3866
3866
3867
3867
3867
3868
3869
3871
3871
3871
3871
3872
3872
3872
3872
3873
3874
3874
3874
3875
3875
3875
3875
3876
3877
3877
3877
3877
3878
3879
3879
3879
3880
3880
3880
3880
3880
3880
3881
3881
3881
3881
3882
3882
3882
3882
3883
3883
3883
3883
3884
3884
3885
3885
3885
3886
3886
3886
3887
3887
3888
3890
3890
3890
3890
3890
3891
3891
3892
3892
3892
3893
3893
3893
3894
3895
3896
3896
3897
3897
3897
3897
3898
3898
3898
3899
3900
3900
3901
3901
3901
3901
3902
3902
3902
3903
3903
3903
3903
3904
3904
3904
3904
3905
3906
3907
3907
3908
3908
3908
3908
3909
3909
3910
3910
3911
3911
3911
3911
3913
3914
3914
3915
3915
3916
3916
3917
3917
3917
3918
3918
3918
3919
3919
3919
3920
3920
3920
3920
3922
3923
3924
3924
3925
3925
3927
3928
3928
3928
3928
3929
3929
3930
3930
3931
3931
3931
3933
3935
3935
3935
3935
3936
3936
3937
3937
3938
3938
3938
3939
3940
3943
3944
3944
3944
3945
3945
3945
3946
3947
3947
3947
3947
3947
3948
3948
3948
3949
3949
3949
3949
3950
3950
3950
3951
3951
3952
3953
3953
3954
3954
3954
3954
3955
3955
3955
3956
3957
3957
3958
3958
3958
3958
3959
3959
3960
3960
3960
3961
3961
3961
3961
3963
3964
3964
3965
3965
3965
3966
3967
3967
3967
3967
3968
3968
3969
3969
3969
3970
3970
3970
3970
3972
3973
3973
3974
3974
3975
3975
3976
3976
3976
3977
3977
3977
3978
3978
3978
3979
3979
3979
3979
3981
3982
3983
3983
3983
3983
3983
3984
3984
3984
3985
3985
3985
3986
3986
3986
3987
3988
3988
3989
3989
3990
3990
3990
3990
3990
3991
3991
3991
3991
3991
3992
3992
3992
3992
3993
3993
3993
3993
3994
3994
3995
3995
3995
3996
3996
3997
3997
3997
3997
3998
3998
3999
3999
4000
4000
4000
4000
4000
4002
4002
4003
4003
4004
4006
4006
4006
4006
4006
4007
4007
4008
4008
4008
4009
4009
4009
4010
4011
4012
4012
4013
4013
4013
4013
4014
4014
4014
4015
4016
4017
4017
4017
4017
4018
4018
4019
4019
4019
4020
4020
4020
4020
4022
4023
4023
4024
4024
4024
4025
4026
4026
4026
4026
4027
4027
4028
4028
4028
4029
4029
4029
4029
4031
4032
4033
4034
4034
4034
4035
4035
4035
4036
4036
4036
4037
4037
4037
4039
4041
4041
4041
4041
4041
4042
4042
4042
4043
4043
4044
4044
4045
4045
4045
4045
4045
4045
4046
4046
4046
4047
4047
4048
4048
4048
4049
4049
4050
4050
4051
4052
4054
4054
4054
4054
4054
4054
4055
4055
4055
4055
4056
4056
4056
4056
4057
4057
4057
4058
4058
4058
4059
4059
4060
4061
4062
4064
4064
4064
4065
4065
4065
4065
4066
4066
4066
4066
4067
4070
4070
4070
4070
4070
4071
4071
4072
4072
4072
4073
4073
4073
4074
4075
4076
4076
4077
4077
4077
4078
4078
4079
4080
4080
4080
4081
4081
4083
4084
4084
4084
4085
4085
4085
4086
4087
4087
4087
4089
4089
4090
4090
4091
4092
4092
4093
4094
4094
4095
4095
4095
4095
4096
4096
4097
4097
4097
4097
4098
4098
4098
4098
4099
4100
4100
4100
4101
4101
4101
4102
4102
4102
4103
4104
4104
4105
4105
4105
4105
4106
4107
4108
4108
4108
4109
4109
4109
4110
4110
4110
4110
4110
4111
4111
4111
4112
4112
4113
4113
4114
4114
4114
4114
4114
4114
4115
4115
4115
4115
4115
4116
4116
4116
4116
4116
4117
4117
4118
4118
4118
4119
4119
4120
4120
4120
4121
4121
4121
4122
4122
4123
4123
4123
4124
4124
4124
4124
4124
4125
4125
4125
4125
4126
4126
4127
4127
4127
4128
4129
4129
4133
4134
4135
4135
4136
4137
4137
4137
4138
4139
4140
4140
4140
4141
4141
4141
4142
4142
4142
4143
4143
4143
4143
4145
4146
4147
4147
4148
4148
4148
4149
4149
4150
4150
4150
4150
4151
4151
4152
4152
4152
4153
4153
4153
4154
4156
4157
4157
4158
4158
4158
4159
4159
4159
4159
4160
4160
4161
4162
4163
4165
4166
4166
4166
4167
4167
4167
4168
4168
4168
4168
4170
4171
4172
4172
4172
4172
4172
4173
4173
4174
4174
4174
4175
4175
4175
4176
4177
4178
4178
4179
4179
4179
4179
4179
4180
4180
4181
4181
4181
4181
4182
4182
4182
4182
4183
4184
4185
4185
4185
4186
4186
4187
4187
4187
4188
4188
4188
4190
4190
4191
4191
4191
4192
4192
4192
4194
4194
4195
4195
4195
4196
4196
4196
4196
4196
4197
4197
4198
4198
4199
4199
4200
4200
4200
4200
4200
4201
4201
4202
4202
4202
4203
4203
4204
4206
4207
4207
4207
4207
4207
4208
4208
4208
4209
4209
4209
4209
4210
4210
4210
4210
4210
4211
4212
4213
4213
4213
4214
4214
4214
4214
4215
4215
4217
4218
4219
4219
4219
4219
4220
4220
4220
4220
4221
4222
4222
4222
4223
4224
4224
4225
4226
4226
4227
4228
4231
4231
4231
4231
4231
4232
4232
4233
4233
4233
4233
4234
4234
4234
4234
4235
4237
4237
4237
4238
4238
4238
4239
4240
4240
4240
4241
4242
4243
4243
4244
4244
4245
4245
4246
4246
4247
4247
4248
4248
4248
4249
4249
4249
4249
4249
4250
4250
4251
4251
4252
4252
4252
4252
4252
4252
4253
4253
4253
4254
4254
4254
4255
4255
4255
4256
4256
4257
4257
4258
4258
4259
4259
4259
4259
4260
4260
4260
4261
4261
4262
4262
4262
4262
4264
4264
4265
4266
4266
4266
4266
4267
4267
4267
4268
4268
4269
4269
4269
4269
4271
4271
4272
4273
4273
4273
4274
4274
4274
4274
4275
4275
4275
4276
4276
4276
4277
4278
4280
4280
4280
4280
4280
4281
4281
4282
4282
4283
4283
4283
4284
4285
4286
4287
4287
4287
4287
4288
4288
4288
4289
4290
4290
4291
4291
4291
4291
4292
4292
4292
4293
4293
4294
4294
4294
4294
4296
4296
4298
4298
4298
4299
4299
4299
4299
4300
4300
4301
4302
4302
4303
4303
4303
4304
4305
4305
4307
4308
4309
4309
4310
4311
4311
4311
4312
4313
4313
4313
4314
4315
4315
4315
4315
4316
4316
4316
4317
4317
4318
4318
4318
4318
4320
4320
4321
4322
4322
4322
4323
4323
4323
4323
4324
4324
4324
4324
4325
4326
4326
4326
4327
4327
4327
4327
4328
4328
4328
4329
4329
4329
4330
4330
4330
4331
4332
4334
4334
4334
4334
4334
4335
4335
4336
4336
4336
4337
4337
4337
4338
4339
4340
4340
4341
4341
4341
4341
4342
4342
4342
4343
4343
4343
4344
4344
4344
4344
4344
4346
4346
4347
4347
4348
4348
4348
4348
4348
4349
4349
4349
4350
4350
4350
4351
4351
4351
4352
4352
4352
4354
4354
4355
4355
4355
4356
4356
4356
4357
4358
4358
4359
4359
4359
4359
4360
4361
4362
4362
4362
4362
4362
4363
4363
4364
4364
4364
4365
4365
4365
4366
4367
4368
4368
4369
4369
4369
4369
4369
4370
4370
4370
4371
4371
4372
4373
4373
4374
4375
4375
4375
4376
4376
4376
4376
4377
4377
4377
4377
4378
4378
4378
4380
4380
4381
4382
4382
4382
4383
4383
4383
4383
4384
4384
4384
4384
4385
4386
4386
4388
4388
4388
4389
4390
4390
4392
4393
4393
4393
4394
4395
4395
4395
4395
4396
4396
4396
4397
4398
4398
4398
4399
4399
4400
4401
4401
4401
4401
4402
4402
4402
4403
4403
4403
4404
4404
4404
4404
4405
4406
4407
4407
4408
4408
4409
4409
4410
4410
4410
4410
4411
4412
4413
4413
4413
4414
4414
4414
4415
4415
4415
4416
4416
4416
4416
4416
4417
4417
4417
4418
4418
4419
4419
4420
4420
4420
4420
4421
4421
4421
4422
4422
4423
4423
4423
4424
4424
4425
4425
4427
4427
4427
4428
4428
4429
4429
4430
4430
4431
4431
4432
4432
4434
4434
4434
4434
4434
4435
4435
4435
4435
4435
4436
4436
4436
4436
4437
4437
4437
4437
4438
4438
4439
4439
4440
4440
4441
4441
4441
4442
4442
4443
4443
4443
4444
4444
4445
4445
4445
4446
4446
4446
4447
4448
4448
4449
4449
4450
4450
4450
4450
4451
4451
4451
4452
4453
4453
4454
4454
4454
4455
4455
4455
4455
4456
4456
4456
4457
4457
4458
4458
4459
4459
4460
4460
4461
4462
4462
4463
4463
4465
4467
4467
4467
4468
4468
4468
4469
4469
4470
4471
4472
4472
4473
4473
4473
4474
4474
4474
4475
4475
4475
4476
4477
4478
4479
4479
4479
4480
4480
4481
4481
4482
4483
4483
4483
4483
4483
4484
4484
4484
4485
4485
4485
4485
4486
4486
4487
4487
4488
4489
4490
4490
4490
4490
4491
4491
4491
4492
4492
4492
4492
4493
4493
4494
4496
4496
4497
4497
4497
4497
4498
4498
4498
4499
4499
4500
4500
4500
4501
4501
4502
4502
4502
4503
4504
4504
4506
4506
4507
4507
4507
4508
4508
4509
4510
4511
4511
4512
4512
4513
4514
4516
4516
4516
4516
4517
4517
4517
4518
4519
4519
4520
4520
4521
4521
4521
4522
4522
4522
4522
4523
4524
4525
4525
4526
4526
4526
4527
4527
4527
4528
4528
4528
4529
4529
4531
4532
4532
4532
4532
4533
4533
4534
4534
4535
4536
4537
4538
4538
4540
4540
4540
4541
4541
4541
4542
4542
4542
4543
4543
4544
4544
4544
4545
4545
4545
4546
4546
4547
4547
4547
4548
4548
4548
4549
4549
4549
4549
4550
4550
4551
4551
4551
4552
4552
4552
4553
4553
4554
4554
4555
4555
4555
4556
4557
4557
4557
4558
4558
4558
4558
4559
4559
4560
4560
4561
4563
4563
4564
4564
4564
4565
4566
4566
4568
4568
4569
4570
4572
4572
4573
4573
4573
4573
4574
4575
4575
4576
4576
4576
4577
4577
4578
4578
4578
4580
4581
4581
4581
4582
4582
4582
4583
4583
4583
4583
4584
4584
4585
4585
4586
4586
4586
4586
4587
4587
4587
4588
4589
4589
4589
4590
4590
4591
4592
4592
4592
4592
4593
4593
4593
4593
4594
4595
4595
4595
4596
4596
4597
4597
4597
4598
4598
4598
4599
4600
4601
4602
4603
4603
4603
4603
4603
4603
4604
4604
4604
4604
4604
4605
4605
4605
4605
4605
4606
4606
4607
4607
4607
4608
4609
4609
4609
4610
4610
4610
4611
4611
4612
4612
4612
4613
4613
4614
4614
4614
4614
4615
4616
4617
4618
4618
4618
4618
4619
4619
4619
4620
4621
4622
4622
4623
4623
4623
4623
4624
4624
4625
4625
4625
4625
4626
4626
4626
4628
4631
4632
4632
4632
4632
4633
4633
4634
4635
4635
4636
4636
4636
4637
4637
4638
4638
4638
4640
4641
4641
4641
4641
4641
4641
4642
4642
4642
4643
4643
4643
4644
4644
4645
4645
4646
4646
4647
4647
4648
4648
4648
4648
4648
4649
4649
4649
4650
4650
4651
4651
4652
4652
4652
4653
4653
4654
4654
4654
4654
4655
4655
4655
4655
4657
4657
4659
4659
4659
4661
4661
4662
4662
4662
4663
4663
4663
4663
4663
4664
4664
4665
4665
4666
4666
4667
4667
4667
4668
4668
4669
4669
4670
4670
4670
4670
4671
4671
4671
4672
4673
4673
4674
4674
4675
4675
4675
4676
4677
4677
4677
4678
4678
4679
4679
4680
4681
4681
4681
4681
4682
4682
4682
4683
4683
4684
4684
4686
4686
4687
4688
4688
4688
4688
4689
4689
4689
4689
4690
4690
4691
4691
4693
4693
4693
4694
4694
4694
4695
4696
4696
4697
4698
4698
4698
4698
4699
4699
4699
4699
4699
4700
4700
4700
4700
4701
4701
4701
4702
4702
4702
4703
4703
4703
4705
4707
4707
4707
4708
4708
4708
4709
4710
4710
4713
4715
4716
4716
4716
4716
4717
4717
4718
4718
4718
4719
4719
4720
4722
4723
4723
4723
4723
4723
4724
4724
4724
4724
4725
4725
4725
4726
4726
4726
4726
4727
4728
4728
4728
4729
4730
4730
4731
4732
4732
4732
4732
4733
4733
4733
4733
4734
4735
4735
4735
4736
4737
4738
4738
4738
4738
4738
4738
4739
4739
4739
4739
4740
4740
4740
4741
4741
4741
4741
4742
4742
4743
4743
4743
4744
4745
4745
4745
4745
4745
4745
4746
4746
4746
4747
4747
4747
4748
4748
4749
4749
4750
4750
4751
4752
4752
4752
4753
4753
4753
4753
4754
4754
4754
4754
4755
4758
4758
4758
4758
4758
4759
4759
4759
4760
4760
4761
4761
4762
4763
4765
4768
4768
4768
4769
4769
4770
4770
4770
4771
4771
4772
4775
4775
4776
4777
4778
4779
4779
4781
4783
4785
4786
4786
4787
4788
4788
4789
4790
4791
4792
4792
4795
4795
4795
4796
4796
4796
4797
4797
4798
4798
4798
4800
4802
4802
4802
4803
4803
4803
4804
4804
4804
4805
4805
4805
4805
4806
4806
4807
4808
4809
4809
4809
4810
4810
4810
4810
4811
4811
4812
4812
4812
4813
4813
4813
4813
4814
4815
4815
4816
4816
4816
4817
4817
4817
4817
4818
4818
4818
4818
4819
4819
4820
4820
4821
4821
4822
4822
4823
4823
4823
4823
4824
4824
4824
4825
4825
4826
4826
4827
4828
4830
4830
4831
4831
4832
4832
4833
4834
4835
4837
4837
4838
4838
4839
4840
4840
4841
4841
4844
4844
4845
4845
4846
4846
4847
4847
4848
4848
4849
4849
4849
4850
4850
4851
4851
4852
4852
4853
4853
4853
4854
4854
4855
4855
4855
4856
4856
4856
4857
4857
4857
4858
4858
4858
4859
4859
4860
4860
4861
4861
4861
4862
4862
4862
4863
4863
4863
4864
4864
4865
4865
4865
4865
4865
4866
4866
4867
4867
4867
4868
4868
4868
4869
4870
4871
4871
4872
4872
4873
4873
4874
4874
4874
4875
4875
4876
4876
4876
4877
4877
4877
4878
4878
4878
4879
4879
4880
4880
4881
4882
4882
4883
4883
4884
4884
4885
4886
4886
4887
4887
4888
4888
4889
4889
4890
4890
4891
4891
4891
4892
4892
4893
4893
4893
4894
4894
4895
4895
4896
4896
4900
4900
4901
4901
4902
4902
4903
4903
4904
4904
4905
4905
4905
4906
4906
4907
4907
4908
4908
4909
4909
4909
4909
4909
4909
4909
4910
4910
4911
4911
4912
4912
4913
4914
4914
4914
4914
4915
4915
4916
4916
4916
4917
4917
4918
4920
4921
4921
4921
4921
4922
4922
4923
4923
4923
4924
4924
4925
4927
4928
4928
4929
4929
4930
4930
4931
4931
4931
4931
4931
4932
4933
4933
4934
4935
4935
4936
4936
4937
4937
4938
4938
4939
4940
4940
4941
4942
4942
4942
4943
4943
4943
4944
4944
4944
4945
4945
4946
4947
4947
4948
4949
4949
4950
4950
4951
4951
4951
4952
4952
4953
4953
4954
4954
4955
4955
4956
4956
4957
4957
4958
4958
4959
4959
4960
4961
4961
4962
4963
4963
4963
4963
4964
4964
4964
4964
4965
4965
4965
4966
4966
4966
4966
4967
4968
4968
4969
4970
4970
4971
4971
4971
4972
4973
4973
4973
4974
4975
4975
4977
4977
4977
4978
4978
4979
4979
4980
4980
4980
4981
4981
4982
4982
4983
4984
4984
4985
4985
4986
4986
4987
4987
4988
4989
4989
4990
4991
4991
4992
4992
4993
4994
4994
4995
4996
4997
4997
4997
4997
4997
4997
4998
4998
4998
4999
4999
4999
5000
5000
5000
5001
5001
5002
5005
5005
5005
5005
5006
5006
5006
5006
5007
5007
5007
5008
5008
5009
5009
5010
5012
5012
5012
5013
5013
5014
5014
5015
5015
5019
5019
5019
5020
5020
5020
5021
5021
5022
5022
5022
5024
5026
5026
5026
5027
5027
5028
5028
5029
5029
5029
5030
5030
5031
5033
5033
5034
5034
5035
5036
5036
5036
5037
5037
5037
5038
5039
5040
5040
5040
5041
5041
5041
5042
5042
5043
5043
5043
5045
5047
5047
5047
5048
5048
5048
5049
5049
5049
5050
5050
5052
5054
5054
5054
5055
5055
5056
5056
5056
5057
5057
5057
5060
5061
5061
5061
5061
5062
5062
5063
5063
5063
5064
5064
5064
5064
5066
5067
5067
5068
5068
5068
5069
5069
5070
5070
5070
5071
5071
5071
5074
5075
5075
5075
5075
5076
5076
5077
5077
5077
5078
5078
5079
5081
5082
5082
5082
5083
5083
5084
5084
5084
5085
5085
5085
5088
5089
5089
5089
5089
5090
5090
5091
5091
5091
5092
5092
5093
5095
5096
5096
5096
5097
5097
5098
5098
5099
5099
5103
5103
5103
5104
5104
5105
5105
5106
5106
5110
5110
5110
5111
5111
5111
5111
5112
5112
5112
5113
5113
5113
5114
5115
5117
5117
5117
5118
5118
5118
5119
5120
5120
5121
5121
5121
5121
5122
5123
5124
5124
5125
5125
5125
5126
5126
5127
5127
5127
5128
5128
5130
5131
5131
5132
5132
5132
5133
5133
5134
5134
5134
5135
5135
5137
5138
5138
5139
5139
5140
5141
5141
5142
5142
5145
5145
5146
5146
5146
5147
5147
5148
5148
5148
5149
5149
5151
5152
5152
5152
5153
5153
5153
5154
5155
5155
5156
5156
5156
5156
5157
5158
5159
5159
5160
5160
5161
5162
5162
5163
5163
5166
5166
5167
5167
5167
5168
5168
5169
5169
5169
5170
5170
5172
5173
5173
5173
5174
5174
5174
5174
5175
5175
5176
5176
5176
5177
5177
5177
5177
5178
5179
5179
5180
5180
5181
5181
5181
5182
5183
5183
5184
5184
5184
5186
5187
5187
5187
5188
5188
5188
5188
5189
5189
5190
5190
5190
5191
5191
5191
5191
5192
5193
5193
5194
5194
5194
5195
5195
5195
5196
5197
5197
5198
5198
5198
5198
5199
5200
5201
5201
5201
5202
5202
5202
5203
5203
5203
5204
5204
5204
5204
5205
5205
5206
5207
5208
5208
5209
5209
5210
5211
5211
5212
5212
5215
5215
5216
5216
5216
5217
5218
5218
5219
5219
5219
5221
5222
5222
5222
5223
5223
5223
5224
5224
5224
5225
5225
5225
5225
5226
5226
5227
5228
5229
5229
5230
5230
5230
5230
5231
5231
5232
5232
5232
5233
5233
5233
5235
5235
5236
5236
5237
5237
5237
5237
5238
5238
5239
5239
5239
5240
5240
5240
5242
5242
5243
5243
5243
5244
5244
5244
5245
5246
5246
5247
5247
5247
5247
5248
5249
5250
5250
5251
5251
5251
5252
5252
5253
5253
5253
5254
5254
5256
5257
5257
5258
5258
5258
5259
5260
5260
5261
5261
5261
5263
5264
5264
5264
5265
5265
5265
5266
5266
5266
5267
5267
5267
5267
5268
5268
5269
5270
5271
5271
5272
5272
5272
5273
5274
5274
5275
5275
5275
5277
5278
5278
5279
5279
5279
5280
5281
5281
5282
5282
5282
5284
5285
5285
5286
5286
5287
5288
5288
5289
5289
5292
5292
5292
5293
5293
5294
5295
5295
5296
5296
5296
5297
5299
5299
5299
5300
5300
5300
5301
5301
5302
5302
5302
5304
5306
5306
5307
5307
5308
5308
5309
5310
5311
5313
5313
5314
5314
5315
5316
5316
5317
5317
5320
5320
5320
5320
5321
5321
5322
5322
5323
5323
5323
5325
5326
5327
5327
5327
5328
5328
5328
5329
5329
5330
5330
5330
5332
5334
5334
5334
5335
5335
5336
5336
5337
5337
5341
5341
5342
5342
5342
5343
5343
5344
5344
5344
5345
5345
5347
5348
5348
5349
5349
5350
5351
5351
5352
5352
5355
5355
5356
5356
5356
5357
5357
5358
5359
5359
5359
5360
5361
5362
5362
5362
5363
5363
5363
5364
5364
5364
5365
5365
5365
5365
5367
5368
5369
5369
5370
5370
5371
5372
5372
5373
5373
5376
5376
5377
5377
5377
5377
5378
5378
5379
5379
5379
5381
5382
5383
5383
5383
5384
5384
5385
5385
5386
5386
5390
5390
5390
5391
5391
5391
5392
5392
5393
5393
5393
5395
5397
5397
5397
5397
5398
5398
5399
5399
5399
5400
5400
5401
5403
5404
5404
5404
5405
5405
5406
5406
5407
5407
5411
5411
5411
5412
5412
5412
5413
5413
5414
5414
5414
5416
5418
5418
5418
5418
5419
5419
5420
5420
5421
5421
5421
5423
5424
5425
5425
5425
5426
5426
5426
5427
5427
5428
5428
5428
5430
5432
5432
5432
5433
5433
5434
5434
5435
5435
5439
5439
5439
5439
5440
5440
5441
5441
5442
5442
5442
5444
5445
5446
5446
5446
5447
5447
5448
5448
5449
5449
5453
5453
5453
5454
5454
5455
5455
5456
5456
5460
5460
5460
5461
5461
5462
5462
5463
5463
5467
5467
5467
5468
5468
5468
5469
5469
5470
5470
5470
5472
5474
5474
5474
5475
5475
5476
5476
5477
5477
5481
5481
5481
5482
5482
5483
5483
5484
5484
5488
5488
5489
5489
5490
5491
5491
5492
5492
5495
5495
5495
5496
5496
5497
5497
5497
5498
5498
5498
5501
5502
5502
5502
5503
5503
5504
5504
5505
5505
5509
5509
5509
5510
5510
5511
5511
5511
5512
5512
5512
5515
5516
5516
5517
5517
5517
5518
5518
5519
5519
5523
5523
5523
5524
5524
5525
5525
5525
5526
5526
5526
5529
5530
5530
5531
5531
5531
5532
5532
5533
5533
5537
5537
5537
5538
5538
5539
5539
5539
5540
5540
5540
5543
5544
5544
5544
5545
5545
5545
5546
5546
5546
5547
5547
5547
5547
5549
5550
5551
5551
5551
5551
5552
5552
5552
5553
5553
5553
5554
5554
5554
5555
5556
5557
5558
5558
5558
5558
5559
5559
5560
5560
5561
5561
5561
5563
5564
5565
5565
5565
5566
5566
5566
5567
5567
5567
5568
5568
5568
5568
5570
5571
5572
5572
5572
5573
5573
5574
5574
5575
5575
5579
5579
5579
5580
5580
5581
5581
5582
5582
5586
5586
5586
5587
5587
5588
5588
5588
5589
5589
5589
5592
5593
5593
5593
5594
5594
5595
5595
5595
5596
5596
5596
5599
5600
5600
5600
5601
5601
5601
5602
5602
5603
5603
5603
5605
5607
5607
5607
5608
5608
5609
5609
5610
5610
5614
5614
5614
5615
5615
5616
5616
5617
5617
5621
5621
5621
5622
5622
5623
5623
5623
5624
5624
5624
5627
5628
5628
5628
5629
5629
5630
5630
5631
5631
5635
5635
5635
5636
5636
5637
5637
5638
5638
5638
5639
5639
5640
5642
5642
5643
5643
5644
5645
5645
5646
5646
5649
5649
5649
5650
5650
5651
5651
5651
5652
5652
5652
5655
5656
5656
5656
5657
5657
5658
5658
5659
5659
5663
5663
5664
5664
5664
5665
5665
5666
5666
5666
5667
5667
5669
5670
5670
5671
5671
5672
5673
5673
5673
5674
5674
5674
5675
5676
5677
5677
5677
5678
5678
5679
5679
5680
5680
5684
5684
5684
5685
5685
5686
5686
5687
5687
5691
5691
5691
5692
5692
5693
5693
5694
5694
5698
5698
5698
5699
5699
5700
5700
5701
5701
5705
5705
5705
5706
5706
5707
5707
5708
5708
5712
5712
5712
5713
5713
5714
5714
5715
5715
5719
5719
5719
5720
5720
5721
5721
5722
5722
5726
5726
5726
5726
5727
5727
5728
5728
5728
5729
5729
5729
5729
5731
5732
5732
5733
5733
5733
5733
5734
5734
5734
5735
5735
5735
5736
5736
5736
5737
5738
5739
5740
5740
5740
5741
5741
5742
5742
5743
5743
5747
5747
5748
5748
5748
5749
5749
5750
5750
5750
5751
5751
5753
5754
5754
5755
5755
5755
5756
5757
5757
5758
5758
5758
5760
5761
5761
5761
5762
5762
5763
5763
5764
5764
5768
5768
5769
5769
5770
5771
5771
5772
5772
5775
5775
5775
5776
5776
5777
5777
5778
5778
5782
5782
5782
5783
5783
5784
5784
5785
5785
5789
5789
5789
5790
5790
5791
5791
5792
5792
5796
5796
5796
5797
5797
5798
5798
5799
5799
5803
5803
5803
5804
5804
5805
5805
5806
5806
5810
5810
5810
5811
5811
5812
5812
5813
5813
5817
5817
5818
5818
5819
5820
5820
5821
5821
5824
5824
5824
5825
5825
5826
5826
5827
5827
5831
5831
5831
5832
5832
5832
5833
5833
5834
5834
5834
5836
5838
5838
5838
5839
5839
5840
5840
5841
5841
5845
5845
5845
5846
5846
5847
5847
5848
5848
5852
5852
5852
5852
5853
5853
5854
5854
5854
5855
5855
5856
5858
5859
5859
5859
5860
5860
5861
5861
5861
5862
5862
5862
5865
5866
5866
5866
5867
5867
5868
5868
5869
5869
5873
5873
5873
5873
5874
5874
5875
5875
5875
5876
5876
5877
5879
5880
5880
5880
5881
5881
5882
5882
5882
5883
5883
5883
5886
5887
5887
5888
5888
5889
5889
5890
5891
5892
5894
5894
5894
5895
5895
5896
5896
5897
5897
5901
5901
5901
5902
5902
5903
5903
5904
5904
5904
5905
5905
5906
5908
5908
5909
5909
5910
5910
5911
5912
5913
5915
5915
5916
5916
5917
5918
5918
5919
5919
5922
5922
5922
5923
5923
5924
5924
5925
5925
5929
5929
5930
5930
5931
5931
5932
5933
5934
5936
5936
5936
5937
5937
5938
5938
5939
5939
5943
5943
5944
5944
5945
5946
5946
5947
5947
5950
5950
5950
5951
5951
5952
5952
5952
5953
5953
5953
5956
5957
5957
5957
5958
5958
5959
5959
5960
5960
5964
5964
5964
5965
5965
5966
5966
5967
5967
5971
5971
5972
5972
5973
5973
5974
5975
5976
5978
5978
5979
5979
5980
5980
5981
5982
5983
5985
5985
5986
5986
5987
5987
5988
5989
5990
5992
5992
5993
5993
5994
5994
5995
5996
5997
5999
5999
6000
6000
6001
6001
6002
6003
6004
6006
6006
6007
6007
6008
6008
6009
6010
6011
6013
6013
6014
6014
6015
6015
6016
6017
6018
6020
6020
6021
6021
6022
6022
6023
6024
6025
6027
6027
6028
6028
6029
6030
6030
6031
6032
6034
6034
6035
6035
6036
6037
6037
6038
6039
489
211
1593
1594
0
1
518
519
522
3
4
6
9
9
1634
571
590
1644
1647
1648
1667
1668
14
15
15
15
1683
16
16
18
18
18
1727
1728
1729
33
33
33
37
42
42
42
54
54
54
60
60
60
61
61
61
62
62
62
267
268
182
832
63
63
69
1936
1937
81
90
936
1986
2011
102
2025
962
2042
111
849
993
114
114
864
2072
125
892
2095
2096
129
129
130
924
1076
957
1121
148
1134
188
274
1021
1034
2132
2133
1041
1136
150
151
151
285
1144
152
153
153
153
154
154
155
202
1078
156
156
157
158
158
207
346
1106
1118
211
212
213
218
159
161
219
224
159
159
160
160
161
161
232
162
163
164
164
165
166
166
1155
167
168
168
168
169
170
171
171
172
173
173
174
174
175
175
175
378
379
182
383
384
181
181
181
181
394
395
182
182
186
186
186
406
407
411
412
188
188
189
189
190
191
192
193
194
194
194
195
196
197
198
198
299
200
300
199
200
201
202
202
203
314
1228
318
205
319
204
205
206
207
332
333
492
509
525
208
209
209
209
210
566
1245
469
211
211
212
212
218
218
1286
1288
220
232
259
259
259
1392
663
1393
377
1168
380
1171
1402
1403
806
1408
1415
821
1423
1425
1426
1428
265
265
267
270
271
270
270
849
1446
1453
1454
978
1455
1456
274
274
1545
334
334
1050
1585
335
336
336
339
337
338
1067
342
340
341
341
345
343
344
344
1093
346
346
1101
1102
349
347
348
348
348
1259
1260
1261
1291
1292
1293
502
503
351
504
1319
1152
1320
1154
1321
351
351
1326
350
1340
352
352
355
1342
355
353
354
354
355
358
356
357
361
359
360
360
364
362
363
367
365
365
366
370
368
369
373
371
372
376
374
375
377
380
378
378
380
382
382
385
383
383
385
385
390
391
389
390
391
391
396
397
395
396
397
397
400
403
404
403
403
404
405
407
407
409
409
409
410
412
412
414
414
414
417
415
416
420
418
419
423
421
422
426
424
425
429
427
428
428
432
430
431
436
1506
1507
1508
435
433
434
438
436
437
441
439
440
444
442
443
1537
1538
1539
448
1548
1549
1550
447
445
446
450
448
449
532
533
544
451
551
453
455
552
451
452
453
454
571
455
455
456
456
457
458
459
460
461
590
2164
462
462
463
463
463
466
601
464
465
466
466
608
2176
2177
467
467
467
613
622
623
628
629
639
469
660
2179
474
661
2181
469
667
2192
2193
471
472
472
472
474
677
2206
2214
2217
474
2241
482
482
2273
2277
485
485
487
490
487
491
487
489
2302
704
2329
501
500
1281
500
501
1299
501
1289
1303
2335
2345
2347
515
532
2360
2368
518
519
519
520
522
2377
2379
530
531
531
535
733
532
533
2415
2416
535
538
548
549
549
749
553
752
550
550
571
573
573
765
2514
2515
575
575
576
2531
2532
2572
2573
2574
2578
2587
2613
2614
2647
2648
619
619
619
2690
2715
2716
2717
2721
635
635
2736
638
638
639
639
2752
2777
2780
649
649
649
650
650
653
806
653
653
654
656
656
656
657
657
657
2845
658
658
658
661
677
2847
663
663
2899
680
677
2909
680
680
2948
2959
685
685
685
690
2964
3002
3013
704
3036
3063
3074
721
3085
3086
3091
3092
730
3115
733
733
738
3125
734
749
751
752
753
754
765
765
769
770
3202
3225
3234
3235
3246
777
3257
3258
3278
3289
783
3305
3332
3336
3354
3355
3356
795
796
3370
3388
3399
3410
801
803
803
806
3445
821
826
828
826
826
830
1180
830
830
831
1419
831
3471
831
832
832
1443
834
834
834
3527
849
852
852
854
864
3561
3572
3576
3597
859
864
860
860
860
3618
3629
3657
873
3682
3693
879
882
3721
882
882
3737
886
3759
887
892
888
888
888
903
904
905
905
906
908
908
909
919
923
923
923
3832
924
924
3843
927
3872
3876
3877
3898
3925
946
946
3955
953
3998
3999
4000
957
957
4014
962
962
4062
965
965
965
974
4090
4092
974
978
978
980
981
4132
1451
1452
984
985
985
985
987
987
988
989
990
989
989
993
4134
990
990
991
991
991
993
4163
996
996
997
997
997
4188
4192
1002
1002
4215
1006
1006
1006
4224
1009
1024
4245
1011
1011
1011
4253
4254
4255
1015
1016
1017
4288
1022
4299
4300
1024
1024
1029
4322
4324
4370
4371
4382
4384
4399
4408
1050
1061
4410
4413
4414
4417
4448
4451
4463
1057
1057
1059
1059
1061
1061
1062
1062
1065
1068
1068
1071
1072
1072
1072
1075
1075
1076
4522
1078
1079
1079
1079
1080
1080
1081
1085
1085
1088
1093
4554
4555
4558
4561
4569
1096
4581
4593
1105
4617
4619
1107
1107
1107
4630
4649
1113
1114
1114
1114
1119
1119
1120
1120
4689
1121
4705
4707
1124
1124
4733
1130
1130
4759
4763
4767
1131
1131
1131
4775
4776
1133
1133
1133
1134
1134
4783
1136
1135
1135
1135
1136
1137
1138
1139
1139
4413
4414
1584
4415
1142
1140
1141
1143
1143
4443
4445
1145
1144
1145
1468
4497
4499
4501
1148
1146
1147
1149
1149
1150
1151
1151
1151
1247
1248
1253
1254
1280
1281
1286
1154
1152
1152
1153
1347
1155
1348
1349
1156
1155
1156
1158
1158
1368
1157
1161
1159
1160
1164
1162
1163
1163
1167
1165
1165
1166
1173
1176
1168
1171
1169
1169
1173
1176
1174
1174
1176
1180
1180
1182
1182
1185
1185
1186
1186
1186
1187
1187
1188
1188
1188
1189
1189
1190
1190
1195
1190
1199
1191
1191
1192
1192
1192
1205
1195
1195
1199
1203
1205
1205
1206
1208
1208
1210
1210
1210
1211
1213
1213
1215
1215
1216
1216
1216
1217
1217
1217
1220
1218
1219
1222
1222
1474
1221
1225
1223
1223
1224
1497
1498
1499
1227
1226
1227
1514
1229
1229
1520
1228
1228
1232
1230
1231
1235
1233
1234
1234
1234
1235
1236
1236
1569
1236
1570
1236
1576
1577
1578
1593
2294
2295
2297
1598
1599
1601
2338
2339
2341
2345
1605
1606
1608
2377
2382
2383
2385
1237
1239
1238
1240
1241
1241
2489
1244
1242
1243
1246
1246
2495
1245
2189
2192
1248
1251
1254
1257
1281
1284
1289
1286
1287
1293
1288
1289
1299
1299
1303
1347
1391
1394
1690
1390
1390
1390
1391
1398
1391
2853
1392
1392
1397
1398
1401
1394
1398
1394
1393
1401
1402
1402
1406
1403
1403
1406
1404
1405
1406
1407
1407
1407
2887
1409
1408
1409
1409
1414
3440
1413
1414
1411
1412
1412
1414
1413
1415
1415
1424
3477
1418
1419
1419
1422
1422
1424
1424
3481
1423
1425
1425
1426
1427
1427
1427
1433
1435
1429
1433
1428
1429
1864
1435
1429
1433
1438
1439
1440
3500
1438
1438
1440
1439
1439
1441
1443
1445
1444
1444
1445
1445
1446
1447
1447
1447
3531
1448
1450
1450
1450
1452
1451
1452
1453
1453
1454
1454
1455
1455
4109
1456
1456
1458
1458
1458
1459
1459
4122
1459
4128
1491
1491
1493
1493
1496
1497
1495
1499
1495
1496
1497
1505
1507
1504
1508
1504
1505
1535
1537
1536
1534
1539
1535
1536
1536
1546
1547
1549
1544
1550
1545
1546
1583
1584
1584
4422
1585
1585
4429
1588
4431
1586
1587
1588
4448
4449
1589
1589
4456
4458
4461
4506
4508
4510
4540
4542
4544
1590
1590
4549
4551
4554
4555
4556
4585
4586
4590
4596
4598
4600
2212
2216
2221
2224
2225
1591
1591
1591
1592
1592
2248
2251
1593
1597
1596
2297
2319
2293
2322
1599
1601
2335
2350
2337
2353
1608
2379
2399
2381
2401
2406
2414
2407
2417
1612
1613
1613
1617
1617
1619
1619
1620
2453
1620
2468
2455
2472
1628
1628
1630
1630
1631
2430
1633
1635
2524
1636
1634
1634
2527
2533
1636
1645
2580
1645
2559
1644
2507
2584
1647
1649
1651
1648
1649
1651
1660
1661
1663
1663
2578
2648
2667
2650
2670
1666
1667
1667
1670
1668
2686
1670
1672
1673
1675
1678
1678
1678
1680
2653
1681
2702
1680
1682
1682
1684
1683
1683
2760
1685
1686
1686
1686
1689
2721
2777
2804
2807
2808
2812
2813
2816
2833
2780
2834
2837
2838
1690
1692
2853
1690
1693
1692
1693
2860
1692
1693
1701
1702
2887
1702
1702
1703
1703
2902
2908
2905
2906
1720
1720
1723
1723
1724
1728
1728
1729
1729
1732
1741
1744
3017
3019
1755
1758
1761
1762
1763
3079
1762
1763
1762
3088
1771
1772
1772
1775
1775
1776
1780
1781
1784
1787
1788
3147
1787
1785
1787
1790
1790
3180
1789
1790
3204
3205
3208
3209
3235
1805
1805
1805
3262
3265
3266
3279
1820
1821
1824
1824
1824
1827
1827
1828
3316
1828
3319
1837
1837
3348
1836
1837
1838
1838
1839
3372
1839
3375
1858
3432
3444
3433
3436
3379
3437
3446
1862
1862
3465
1861
3417
3491
1862
1864
1864
1867
1869
1871
1872
1873
1877
1877
1877
1878
3543
1878
3547
1896
1899
3650
3651
3654
3658
3655
1935
1937
1937
1939
3718
1954
1958
1964
1968
1968
1968
1969
1972
1973
3791
3794
1977
1975
1976
3836
3837
3840
3841
3866
3867
3870
1985
1985
1987
1988
1988
1988
2010
2012
2013
2023
3930
2021
2021
2022
3934
2023
2024
2026
2027
2043
2044
4070
2043
2044
2043
2044
2048
2045
2045
2045
2046
2046
2047
4051
2048
2048
3503
4136
4138
2049
2050
2050
2050
2053
2053
2053
3533
4148
4164
2057
2057
2057
2059
2060
2060
2069
2070
2069
3581
2070
4203
2069
2070
2071
2071
2071
2072
2072
2073
3606
4239
4236
2077
2078
2074
2074
2076
2076
2077
2078
2082
2082
2085
2085
2089
2090
2086
2086
2088
2088
2089
2090
4393
3721
4394
3723
4397
4400
2093
3748
4389
2091
2092
2092
3752
2093
2093
2094
2094
2096
2096
2098
2098
2098
2099
2099
2099
4486
4489
4518
2101
2101
2105
2105
4574
2107
2107
2107
2108
2108
2109
2109
2109
3941
4801
4631
4634
4695
4712
2113
2116
2116
2120
2121
2117
2117
2119
2119
2120
2120
4704
2121
2121
2124
2125
4768
2123
2123
2125
4719
2125
2129
2130
2131
2128
2130
2130
2131
2131
4775
4254
4255
4258
4282
4283
4286
2134
2132
2132
2133
2133
4364
4365
4786
4794
4368
4525
4610
4612
4616
4667
4671
4673
2403
2409
2426
2430
2431
2453
2136
2454
2455
2141
2461
2462
2464
2135
2137
2136
2138
2139
2140
2143
2141
2142
2144
2146
2145
2503
2524
2147
2147
2527
2531
2533
2148
2148
2538
2540
2151
2149
2150
2154
2152
2153
2157
2155
2156
2160
2158
2159
2161
2163
2162
2163
2164
2164
2559
2561
2166
2165
2166
2566
2166
2572
2573
2575
2606
2168
2607
2609
2613
2615
2173
2619
2620
2622
2169
2167
2168
2172
2170
2171
2171
2175
2173
2174
2174
2178
2176
2176
2177
2177
2647
2652
2653
2655
2683
2684
2686
2694
2695
2697
2701
2702
2704
2708
2709
2711
2715
2716
2718
2183
2186
2187
2180
2853
2180
2179
2186
2180
2182
2182
2860
2181
2187
2224
2182
2186
2187
2188
2195
2196
2199
2200
2204
2189
2191
2195
2190
2199
2192
2194
2193
2193
2195
2204
2205
2204
2255
2202
2202
2880
2881
2207
2214
2210
2206
2206
2210
2225
2211
2905
2209
2277
2909
2211
2207
2210
2211
2209
2284
2212
2212
2213
2213
2228
2231
2215
2214
2216
2216
2239
2218
2219
2220
2224
2225
2245
2254
2255
2258
2259
2244
2242
2243
2246
2245
2245
2246
2262
2265
2255
2259
2265
2269
2268
2268
2269
2269
2270
2270
2271
2271
2271
2935
2272
2272
2279
2272
2276
2282
2284
2275
2287
2276
2288
2274
2275
2276
2278
2282
2288
2277
2278
2289
2284
2287
2288
2289
2289
2292
2293
2291
2292
2293
2306
2295
2297
2303
2304
2301
2302
2303
2324
2327
2322
2323
2319
2320
2320
2323
2327
2328
2324
2326
2326
2328
2330
2332
2329
2329
2332
2333
2330
2331
2332
2333
2333
3026
2336
2337
2334
2341
2348
2345
2346
2347
2348
2355
2357
2353
2354
2350
2351
2351
2354
2357
2358
2355
2358
3050
2358
2359
2359
2362
2359
2365
2361
2360
2361
2373
2375
2407
2365
2366
2367
2369
2362
2365
2366
2369
2373
2369
2368
2375
2417
2377
2381
2378
2383
2385
2390
2391
2389
2390
2391
2393
2390
2393
2396
2401
2399
2400
2401
2402
2402
3105
2416
2420
2403
2406
2407
2408
2412
2419
2408
2408
2409
2412
2413
2453
2414
2417
2416
2419
2422
2468
2420
2425
2424
2424
2425
2436
2440
2430
2431
2433
2433
2434
2434
2443
2446
2436
2440
2443
2443
2444
2446
2449
2449
2449
3144
2468
2450
2470
3158
2472
2475
2450
2450
2478
2458
2458
2459
2462
2459
2475
2464
2478
2502
2508
2502
2502
2503
2504
2504
2507
2507
2513
2516
2508
2511
2510
2510
2513
2516
2514
2514
2516
2519
2520
2532
2522
2534
2519
2519
2544
3205
2518
3208
2522
2520
2521
2596
3213
3215
2533
2534
2572
2579
2589
2579
2578
2580
2584
2588
2587
2588
2588
2589
2589
2590
2592
2592
2594
3246
3247
2595
2598
2600
2614
2603
2616
2596
2599
2598
2599
2595
2596
2602
2604
2603
2604
2600
2602
2615
2616
2646
2647
2650
2650
2653
2655
2658
2658
2659
2659
2661
2664
2659
2661
2661
2664
2670
2667
2668
2668
2668
2669
2670
2671
2671
2672
2675
2677
2690
2680
2691
2673
2676
2675
2676
2672
2673
2679
2681
2680
2681
2677
2679
2689
2691
2692
2695
2697
2695
2715
2716
2723
2726
2722
2728
2722
2721
2733
2723
2726
2725
2725
2725
2733
2735
2735
2735
2737
3354
2736
2736
2738
2741
2744
2739
2742
2741
2742
2738
2739
2745
2744
2745
2744
2763
2745
3382
2746
2748
2749
2750
2750
2750
2763
2766
2754
2767
2751
2753
2754
2752
2754
2776
2776
2778
2777
2788
2779
2779
2781
2780
2795
2782
2782
2782
2798
2801
2802
2798
2798
2801
2807
2808
2809
2805
2807
2808
2809
2809
3410
2810
2810
3415
2813
3433
2811
2811
2811
3436
2826
3442
2818
2819
2822
2823
2829
2831
2812
2812
2813
2815
2825
2827
2829
2826
2828
2829
2831
2831
2833
2833
2838
2841
2842
2841
2842
3465
2841
2842
2844
3471
2844
2843
2844
3479
2845
2845
2846
2846
2860
2847
2847
2851
2864
2906
2849
2869
2851
2870
2850
2851
2848
2849
2850
2850
2923
2867
2870
2879
2879
2880
2881
2881
2884
2900
2886
2887
2888
2891
2901
3518
2892
2900
2901
2900
2901
2905
2906
2908
2908
2909
2910
2915
2918
2919
2926
2918
2921
2918
2923
2926
2928
2977
2929
2930
2930
2930
2949
2933
2935
2938
2938
2939
2939
2947
2949
2950
2958
2960
2961
2963
2963
2963
2971
2962
3019
2977
2964
2964
2968
2981
2967
2968
2965
2966
2967
2967
2967
3033
2983
2983
2984
2984
2987
2989
2992
2992
2993
2993
3001
3003
3004
3012
3014
3015
3016
3017
3019
3026
3021
3023
3021
3024
3021
3026
3029
3031
3033
3035
3038
3037
3038
3039
3037
3038
3046
3046
3046
3047
3047
3048
3050
3052
3054
3073
3075
3062
3064
3065
3073
3075
3076
3075
3086
3088
3092
3096
3097
3099
3087
3088
3090
3093
3092
3099
3102
3105
3107
3105
3107
3108
3112
3114
3115
3115
3116
3119
3121
3122
3124
3126
3124
3124
3131
3123
3126
3126
3138
3125
3129
3127
3128
3146
3144
3145
3147
3147
3149
3151
3153
3156
3157
3154
3157
3157
3160
3161
3166
3158
3159
3161
3165
3161
3162
3165
3205
3166
3170
3166
3167
3170
3171
3174
3176
3177
3186
3188
3190
3193
3203
3201
3199
3200
3203
3203
3202
3211
3213
3215
3217
3218
3220
3222
3224
3226
3225
3225
3231
3279
3232
3233
3236
3235
3254
3245
3247
3246
3248
3250
3252
3254
3254
3256
3259
3257
3257
3257
3268
3268
3269
3272
3269
3274
3277
3279
3280
3288
3290
3291
3292
3304
3292
3292
3293
3293
3293
3294
3295
3313
3304
3304
3306
3307
3307
3308
3311
3311
3313
3313
3314
3322
3322
3323
3326
3323
3328
3331
3333
3334
3335
3337
3338
3354
3356
3356
3358
3361
3364
3369
3367
3368
3369
3370
3370
3370
3378
3378
3379
3382
3379
3384
3387
3389
3390
3398
3400
3401
3409
3409
3409
3410
3411
3419
3412
3415
3417
3415
3417
3430
3418
3419
3419
3422
3426
3428
3430
3430
3431
3431
3436
3440
3441
3440
3441
3442
3444
3444
3446
3447
3455
3457
3458
3455
3459
3455
3455
3465
3471
3477
3479
3477
3480
3481
3479
3480
3480
3481
3485
3486
3491
3492
3489
3489
3490
3490
3491
3492
3493
3496
3494
3497
3496
3497
3493
3494
3497
3499
3502
3499
3498
3499
3513
3557
3500
3502
3500
3503
3505
3502
3503
3513
3505
3513
3518
3518
3526
3518
3526
3526
3528
3529
3529
3531
3531
3532
3532
3533
3541
3535
3538
3538
3540
3541
3541
3587
3551
3549
3552
3551
3551
3554
3560
3557
3559
3563
3557
3559
3559
3560
3562
3604
3563
3561
3563
3571
3573
3574
3575
3577
3578
3581
3585
3586
3586
3587
3587
3591
3594
3595
3595
3596
3596
3597
3597
3600
3600
3598
3651
3599
3655
3604
3606
3602
3608
3602
3601
3602
3612
3670
3617
3619
3620
3628
3630
3631
3634
3638
3639
3639
3640
3640
3644
3647
3648
3648
3649
3649
3658
3659
3660
3658
3659
3667
3670
3672
3670
3672
3672
3673
3674
3673
3673
3677
3721
3680
3680
3681
3683
3684
3692
3694
3695
3695
3698
3702
3703
3703
3704
3704
3708
3710
3711
3712
3712
3712
3714
3716
3718
3732
3734
3720
3722
3723
3734
3734
3736
3738
3737
3738
3738
3739
3741
3743
3745
3746
3748
3750
3752
3753
3757
3758
3757
3758
3758
3760
3759
3760
3760
3763
3761
3762
3767
3769
3765
3771
3765
3764
3765
3776
3782
3783
3782
3781
3782
3786
3787
3786
3785
3786
3790
3788
3789
3789
3791
3791
3794
3793
3796
3798
3800
3802
3803
3803
3805
3807
3804
3807
3810
3806
3807
3810
3814
3821
3826
3827
3827
3829
3833
3832
3833
3833
3835
3834
3835
3835
3844
3843
3843
3848
3850
3852
3854
3856
3854
3856
3856
3858
3860
3862
3863
3860
3863
3866
3870
3870
3871
3873
3874
3875
3876
3876
3879
3883
3887
3888
3889
3888
3889
3889
3897
3899
3900
3908
3915
3910
3912
3914
3910
3915
3915
3916
3916
3920
3923
3924
3924
3924
3926
3927
3926
3928
3930
3932
3934
3934
3935
3937
3941
3941
3942
3942
3942
3943
3943
3943
3944
3945
3954
3956
3957
3965
3965
3966
3966
3969
3973
3974
3974
3975
3975
3979
3982
3984
3986
3986
3988
3993
3998
3998
3999
3999
4001
4005
4004
4005
4005
4013
4015
4016
4016
4024
4024
4025
4025
4028
4032
4032
4033
4033
4033
4037
4039
4040
4037
4040
4041
4043
4044
4047
4051
4052
4052
4052
4053
4053
4060
4061
4061
4061
4063
4062
4062
4064
4068
4069
4068
4068
4069
4069
4078
4079
4080
4082
4079
4084
4086
4088
4084
4086
4086
4087
4087
4091
4090
4091
4091
4092
4092
4109
4113
4111
4113
4117
4117
4117
4119
4122
4122
4128
4130
4128
4131
4130
4131
4130
4131
4132
4132
4133
4133
4134
4134
4136
4136
4140
4135
4145
4138
4139
4140
4138
4139
4139
4140
4143
4145
4146
4163
4188
4189
4147
4149
4157
4148
4150
4155
4156
4157
4157
4158
4160
4160
4160
4162
4163
4163
4216
4164
4164
4165
4165
4169
4170
4167
4169
4171
4169
4170
4171
4168
4170
4171
4192
4245
4193
4186
4186
4186
4189
4193
4187
4189
4190
4191
4193
4194
4197
4254
4195
4198
4197
4197
4203
4205
4206
4212
4214
4216
4217
4216
4218
4218
4218
4219
4221
4222
4282
4223
4223
4224
4224
4225
4229
4230
4227
4227
4228
4228
4229
4230
4239
4241
4236
4238
4238
4239
4241
4241
4244
4244
4244
4245
4246
4255
4247
4248
4247
4247
4248
4250
4268
4251
4317
4261
4262
4265
4268
4269
4272
4275
4276
4279
4282
4286
4287
4288
4289
4290
4290
4293
4294
4297
4297
4298
4299
4301
4300
4300
4301
4306
4307
4304
4304
4305
4305
4306
4307
4308
4308
4312
4310
4312
4309
4310
4310
4311
4311
4312
4324
4408
4325
4313
4313
4314
4314
4317
4325
4321
4317
4318
4321
4322
4322
4323
4325
4333
4328
4330
4333
4370
4371
4373
4374
4373
4374
4376
4381
4382
4384
4385
4387
4385
4387
4391
4392
4389
4389
4390
4390
4391
4392
4393
4393
4394
4396
4400
4402
4400
4399
4407
4402
4409
4414
4409
4408
4411
4429
4411
4412
4412
4412
4437
4439
4449
4453
4451
4453
4456
4461
4464
4461
4465
4463
4463
4464
4466
4466
4470
4468
4469
4469
4470
4475
4476
4472
4472
4475
4476
4477
4477
4477
4482
4478
4478
4481
4482
4486
4489
4491
4493
4493
4493
4495
4495
4499
4501
4505
4504
4504
4505
4508
4508
4510
4514
4513
4513
4514
4515
4515
4515
4516
4516
4518
4518
4520
4521
4521
4523
4524
4524
4524
4525
4529
4528
4528
4530
4530
4530
4531
4531
4534
4534
4535
4535
4535
4536
4536
4539
4537
4538
4538
4539
4539
4542
4554
4558
4562
4561
4562
4562
4563
4563
4563
4565
4565
4566
4566
4567
4569
4570
4570
4571
4571
4571
4572
4572
4574
4575
4574
4575
4577
4579
4579
4580
4577
4578
4578
4580
4581
4584
4593
4594
4582
4585
4584
4583
4590
4594
4595
4598
4592
4600
4606
4606
4606
4608
4608
4616
4617
4617
4618
4619
4621
4621
4621
4622
4626
4627
4627
4627
4628
4628
4629
4629
4629
4630
4630
4634
4635
4631
4633
4633
4635
4637
4639
4639
4640
4637
4638
4638
4640
4649
4651
4660
4644
4650
4653
4648
4651
4658
4653
4655
4658
4658
4659
4660
4661
4660
4661
4662
4664
4664
4666
4674
4678
4678
4678
4680
4683
4684
4684
4684
4687
4689
4690
4692
4691
4692
4692
4693
4693
4693
4695
4695
4697
4697
4698
4698
4701
4704
4704
4706
4706
4705
4705
4708
4708
4708
4709
4710
4709
4711
4711
4711
4712
4712
4713
4713
4714
4714
4714
4715
4715
4719
4721
4716
4719
4721
4722
4726
4729
4730
4730
4730
4731
4731
4732
4734
4735
4736
4736
4736
4737
4737
4744
4748
4751
4752
4756
4757
4756
4756
4757
4757
4758
4760
4761
4762
4762
4762
4763
4763
4764
4765
4765
4765
4766
4766
4767
4767
4776
4768
4768
4771
4773
4774
4774
4775
4777
4776
4778
4778
4780
4779
4782
4781
4782
4782
4784
4784
4783
4784
4785
4789
4787
4785
4786
4788
4790
4789
4791
4793
4792
4794
4794
)
// ************************************************************************* //
| [
"zachery.style@mines.sdsmt.edu"
] | zachery.style@mines.sdsmt.edu | |
c6050c5010ea3bc80f290f5cd7f0da98dfa57a60 | ad3f34546afba57daf888798ad2d29db0361dcca | /T3000/HexFileParser.cpp | 2350ae23e18146b5d491c374010fce5e98e17594 | [
"MIT"
] | permissive | temcocontrols/T3000_Building_Automation_System | b7303be5d447cd8d40b1d2424b32b6c7683c2570 | 5fc9204df43aabfe57ccd1a5183b69940d525e2d | refs/heads/master | 2023-08-31T13:37:39.375528 | 2023-08-29T03:30:48 | 2023-08-29T03:30:48 | 6,994,906 | 66 | 62 | MIT | 2023-08-08T12:38:00 | 2012-12-04T05:29:25 | C++ | GB18030 | C++ | false | false | 12,831 | cpp | #include "StdAfx.h"
#include "HexFileParser.h"
#include "global_function.h"
CHexFileParser::CHexFileParser(void)
{
m_nHexFileType = HEXFILE_DATA;
m_IsRAM=FALSE;
}
CHexFileParser::~CHexFileParser(void)
{
}
void CHexFileParser::SetFileName(const CString& strFileName)
{
m_strFileName = strFileName;
}
//////////////////////////////////////////////////////////////////////////
// 返回int：实际的有效字节
int CHexFileParser::GetHexFileBuffer(char* pBuf, int nLen)
{
CFile hexFile; //the hex file
int nBufLen = 0;
if(hexFile.Open(m_strFileName, CFile::modeRead))
{
m_nHexFileType = GetHexFileType(hexFile);
BOOL bRet = TRUE;
if (m_nHexFileType == 0)
{
CString strTips = _T("Hex file verified okay.");//_T("The Hex File is Normal.");
nBufLen = ReadNormalHexFile(hexFile, pBuf, nLen);
}
else if(m_nHexFileType == 1)
{
CString strTips = _T("The hex file has a Extend Section Address Record(HEX86).");
nBufLen = ReadExtendHexFile(hexFile, pBuf, nLen);
}
else if (m_nHexFileType == 2)
{
CString strTips = _T("The hex file has a Extend Linear Addree Record(HEX86).");
nBufLen = ReadExtLinearHexFile(hexFile, pBuf, nLen);
}
}
if (m_IsRAM)
{
memcpy(&global_fileInfor,&pBuf[0x8200],sizeof(Bin_Info));
}
else
{
memcpy(&global_fileInfor,&pBuf[0x100],sizeof(Bin_Info));
}
if(strlen(global_fileInfor.product_name) > 200)
nBufLen = -1;
//return NO_VERSION_INFO;
char temocolog[6];
memcpy_s(temocolog,5,global_fileInfor.company,5);
temocolog[5] = 0;
CString Temco_logo;
MultiByteToWideChar( CP_ACP, 0, (char *)temocolog,
(int)strlen(temocolog)+1,
Temco_logo.GetBuffer(MAX_PATH), MAX_PATH );
Temco_logo.ReleaseBuffer();
Temco_logo.MakeUpper();
if(Temco_logo.CompareNoCase(_T("TEMCO")) != 0&&Temco_logo.Find(L"CO2")==-1)
{
//return NO_VERSION_INFO;
nBufLen = -1;
}
//return READ_SUCCESS;
return nBufLen;
}
BOOL CHexFileParser::Is_RAM_HEXType(){
return m_IsRAM;
}
// 读第7，8个字符，00为Normal，02为扩展，04为扩展线性
HEXFILE_FORMAT CHexFileParser::GetHexFileType(CFile& hexFile)
{
int nRet = 0;
char chBuf[64] = {0};
hexFile.Read(chBuf, 12);
if (chBuf[8] == '0')
{
}
else if (chBuf[8] == '2')
{
nRet = 1;
}
else if (chBuf[8] == '4')
{
nRet = 2;
}
// reset file pointer
hexFile.SeekToBegin();
return (HEXFILE_FORMAT)nRet;
}
////////////////////////////////////////////////////////////////////////////
// Parameter:
// 1, CFile& : hex file preference, to be read
// 2, char* : a memory pointer, has been allocate in heep, it's a valid memory space.
// 3, int : parameter 2, memory space's size.
// return:
// int : it's the truely length of the used buffer, also useful byte number after hex file been parsed.
int CHexFileParser::ReadNormalHexFile( CFile& hexFile, char* pBuf, int nBufLen)
{
ASSERT(nBufLen >= 0xFFFF);
//CString m_get_data_from_file;
int nBufCount = 0;
//*****************inspect the file*********************
unsigned int nLineNum=0;
char a[256];
ZeroMemory(a, 256);
//while(NULL!=ar.ReadString(m_get_data_from_file))//循环读取文件，直到文件结束
while(ReadLineFromFile(hexFile, a))
{//get a line from the file,check "crc" for total file
#ifdef _DEBUG
if (a[8] != '0')
{
int n = 0;
}
#endif
nLineNum++; //the line number that the wrong hex file;
unsigned char get_hex[128]={0}; //get hex data,it is get from the line char
UINT i = 0;
for( i=0;i<strlen(a); i++) //get a line//去掉第一个
{
a[i] = a[i+1];
}
int nLen = strlen(a)-2; // 减去回车换行符号
if(strlen(a)%2==0)
turn_hex_file_line_to_unsigned_char(a); // turn every char to int
else
{
wchar_t p_c_temp[74]={'\0'};
swprintf_s(p_c_temp,_T("Error: the hex file had error at %d line!"),nLineNum);
nBufCount = 0;
//close_com();
return 0;
}
turn_int_to_unsigned_char(a,nLen,get_hex); //turn to hex
if(get_hex[3]==1) //for to seektobegin() function,because to end of the file
break;
unsigned char uctemp2=0;
for(int j=0;j<(nLen/2);j++)
uctemp2+=get_hex[j];
if(uctemp2%256!=0)
{
wchar_t p_c_temp[74]={'\0'};
swprintf_s(p_c_temp,_T("Error: the hex file had error at %d line!"),nLineNum);
nBufCount = 0;
//close_com();
return 0;
}
if(get_hex[1]==0 && get_hex[2]==0)
get_hex[4]=255; //for the 0000 register to write 255
unsigned int ltemp;
ltemp=get_hex[1]*256+get_hex[2];
for(int j=0;j<get_hex[0];j++)
{
pBuf[ltemp+j]=get_hex[4+j];//get the data
}
if((UINT)nBufCount<(ltemp+get_hex[0]))
{
nBufCount=ltemp+get_hex[0]-1;
}
ZeroMemory(a, 256);
}//end while
hexFile.Close();//close the file
return nBufCount;
}
BOOL CHexFileParser::DoCRC( unsigned char* szBuf, int nLen)
{
unsigned char uctemp=0;
for(int j=0; j < nLen; j++)
uctemp+=szBuf[j];
if(uctemp%256!=0)
{
return FALSE;
}
return TRUE;
}
WORD CHexFileParser::GetHighAddrFromFile(const CString& strLine)
{
WORD dwTemp = 0;
char ch[128] = {0};
for (int i = 1; i < strLine.GetLength(); i++)
{
ch[i-1] = (char)strLine.GetAt(i);
}
turn_hex_file_line_to_unsigned_char(ch);
unsigned char szBuf[64] = {0};
turn_int_to_unsigned_char(ch, strLine.GetLength()-1, szBuf);
dwTemp = szBuf[4]*0x100 + szBuf[5];
if (dwTemp>=800)
{
dwTemp-=0x800;
m_IsRAM=TRUE;
}
return dwTemp;
}
BOOL CHexFileParser::ReadLineFromFile(CFile& file, char* pBuffer)
{
//当hex文件中每一行的文件超过了256个字符的时候，我们就认为这个hex文件出现了问题
int linecharnum=0;
char c;
int nRet = file.Read(&c, 1);
while(nRet != 0)
{
++linecharnum;
*pBuffer++ = c;
//TRACE(_T("\n%c"),c);
if (c == 0x0d) // 回车
{
file.Read(&c, 1); // 读一个换行
*pBuffer++ = c;
TRACE(_T("%s"),pBuffer);
return TRUE;
}
if (linecharnum<256)
{
file.Read(&c, 1);
}
else
{
return FALSE;
}
}
//TRACE(_T("%s"),pBuffer);
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
// Parameter:
// 1, CFile& : hex file preference, to be read
// 2, char* : a memory pointer, has been allocate in heep, it's a valid memory space.
// 3, int : parameter 2, memory space's size.
// return:
// int : it's the truely length of the used buffer, also useful byte number after hex file been parsed.
// 读扩展地址记录的hex file－最大512k地址空间
int CHexFileParser::ReadExtendHexFile(CFile& hexFile, char* pBuf, int nBufLen)
{
//MessageBox(NULL, _T("Sorry, don't suppot Extend Hex File. Please contact software developer."), _T("ISP"), MB_OK);
ASSERT(nBufLen >= 0xFFFF);
//CString m_get_data_from_file;
int nBufCount = 0;
//*****************inspect the file*********************
unsigned int nLineNum=0;
char a[256];
ZeroMemory(a, 256);
//while(NULL!=ar.ReadString(m_get_data_from_file))//循环读取文件，直到文件结束
while(ReadLineFromFile(hexFile, a))
{//get a line from the file,check "crc" for total file
#ifdef _DEBUG
if (a[8] != '0')
{
int n = 0;
}
#endif
nLineNum++; //the line number that the wrong hex file;
unsigned char get_hex[128]={0}; //get hex data,it is get from the line char
UINT i = 0;
for( i=0;i<strlen(a); i++) //get a line
{
a[i] = a[i+1];
}
int nLen = strlen(a)-2; // 减去回车换行符号
if(strlen(a)%2==0)
turn_hex_file_line_to_unsigned_char(a); // turn every char to int
else
{
wchar_t p_c_temp[74]={'\0'};
swprintf_s(p_c_temp,_T("Error: the hex file had error at %d line!"),nLineNum);
nBufCount = 0;
AfxMessageBox(p_c_temp);
//close_com();
return 0;
}
turn_int_to_unsigned_char(a,nLen,get_hex); //turn to hex
if(get_hex[3]==1) //for to seektobegin() function,because to end of the file
break;
unsigned char uctemp2=0;
for(int j=0;j<(nLen/2);j++)
uctemp2+=get_hex[j];
if(uctemp2%256!=0)
{
wchar_t p_c_temp[74]={'\0'};
nBufCount = 0;
swprintf_s(p_c_temp,_T("Error: the hex file had error at %d line!"),nLineNum);
AfxMessageBox(p_c_temp,MB_OK);
//close_com();
return 0;
}
if(get_hex[1]==0 && get_hex[2]==0)
get_hex[4]=255; //for the 0000 register to write 255
unsigned int ltemp;
ltemp=get_hex[1]*256+get_hex[2];
for(int j=0;j<get_hex[0];j++)
{
pBuf[ltemp+j]=get_hex[4+j];//get the data
}
if((UINT)nBufCount<(ltemp+get_hex[0]))
{
nBufCount=ltemp+get_hex[0]-1;
}
ZeroMemory(a, 256);
}//end while
hexFile.Close();//close the file
return nBufCount;
}
////////////////////////////////////////////////////////////////////////////
// Parameter:
// 1, CFile& : hex file preference, to be read
// 2, char* : a memory pointer, has been allocate in heep, it's a valid memory space.
// 3, int : specify parameter 2, memory space's size.
// return:
// int : it's the truely length of the used buffer, also useful byte number after hex file been parsed.
// 读扩展线性地址记录的hex file－最大32位的地址空间
BOOL CHexFileParser::ReadExtLinearHexFile(CFile& hexfile, char* pBuf, int nBufLen)
{
//CArchive ar(&m_hex_file,CArchive::load);
//ASSERT(nBufLen >= 0xFFFF);
/*if (pBuf)
{
delete[] pBuf;
pBuf = NULL;
}
pBuf = new char[c_nHexFileBufLen];*/
CString strGetData;
int nBufCount = 0;
//*****************inspect the file*********************
unsigned int nLineNumErr=0;
DWORD dwHiAddr = 0; // 高位地址
char a[256];
ZeroMemory(a, 256);
//while(NULL!=ar.ReadString(strGetData)) //循环读取文件，直到文件结束
while(ReadLineFromFile(hexfile, a))
{
// 取得高位地址，可能不止一处扩展
if( a[8] == '4')
{
CString strTemp(a);
dwHiAddr = GetHighAddrFromFile(strTemp);
dwHiAddr <<= 16;
if( nBufCount != 0)
{
m_szFlags.push_back(nBufCount);
}
// do CRC
continue;
}
//get a line from the file,check "crc" for total file
nLineNumErr++; //the line number that the wrong hex file;
unsigned char get_hex[128]={0};//get hex data,it is get from the line char
//the number is (i-1)
//int nLen = strGetData.GetLength();
for(UINT i=0; i<strlen(a); i++) // 去掉冒号
{
a[i]=a[i+1];
}
int nLen = strlen(a)-2; // 不算回车换行的长度
if(strlen(a)%2==0)
turn_hex_file_line_to_unsigned_char(a);//turn every char to int
else
{
wchar_t p_c_temp[74]={'\0'};
swprintf_s(p_c_temp,_T("Error: the hex file had error at %d line!"),nLineNumErr);
//AddStringToOutPuts(p_c_temp);
nBufCount = 0;
AfxMessageBox(p_c_temp);
//close_com();
goto END;
return 0;
}
turn_int_to_unsigned_char(a,nLen,get_hex);//turn to hex
if(get_hex[3]==1) //for to seektobegin() function,because to end of the file
break;
if(!DoCRC( get_hex, nLen/2))
{
wchar_t p_c_temp[74]={'\0'};
swprintf_s(p_c_temp,_T("Error: the hex file had error at %d line!"),nLineNumErr);
//AddStringToOutPuts(p_c_temp);
nBufCount = 0;
AfxMessageBox(p_c_temp, MB_OK);
//close_com();
goto END;
return 0;
}
// if(get_hex[1]==0 && get_hex[2]==0)
// get_hex[4]=255;//for the 0000 register to write 255
int temp;
char temp_buf[32];
if (nLineNumErr==9)
{
for (int i=0;i<32;i++)
{
temp_buf[i]=a[i+8];
}
for (int i=0;i<20;i++)
{
temp=temp_buf[2*i]*16+temp_buf[2*i+1];
m_DeviceInfor[i]=temp;
}
//m_softwareRev = (temp_buf[30] + temp_buf[31]*256)/10.0;
//m_ProductModel=m_DeviceInfor[0];
m_softwareRev= ((a[38]*16+a[39]) + (a[40]*16 + a[41])*256)/10.0;
m_ProductName.Empty();
for (int i=0;i<10;i++)
{
CString temp1;
temp1.Format(_T("%C"),m_DeviceInfor[5+i]);
m_ProductName = m_ProductName + temp1;
}
}
unsigned int ltemp;
ltemp=get_hex[1]*256+get_hex[2] + dwHiAddr;
// if (m_IsRAM)
// {
// ltemp-=0x00008000;
// }
for(int j=0;j<get_hex[0];j++)
pBuf[ltemp+j]=get_hex[4+j];//get the data
if((UINT)nBufCount<(ltemp+get_hex[0]))
nBufCount=ltemp+get_hex[0];
ZeroMemory(a, 256);
}//end while
m_szFlags.push_back(nBufCount);
END:
hexfile.Close();//close the file
return nBufCount;
//return 0 ;
}
CString CHexFileParser::Get_HexInfor(){
return m_ProductName+_T(" ")+m_ChipName;
}
HEXFILE_FORMAT CHexFileParser::GetHexFileFormatType()
{
return m_nHexFileType;
}
int CHexFileParser::GetExtendHexFileSectionFlag(vector<int>& szFlags)
{
ASSERT(m_szFlags.size() > 0);
szFlags.clear();
szFlags = m_szFlags;
return szFlags.size();
}
void CHexFileParser::Get_DeviceInfor(UINT &ProductModel,float &SoftwareVersion,CString &ProductName,CString &ChipName,UINT &Chipsize){
ProductModel=m_ProductModel;
SoftwareVersion=m_softwareRev;
ProductName=m_ProductName;
ChipName=m_ChipName;
Chipsize=m_ChipSize;
} | [
"Alex@temcocontrols.com"
] | Alex@temcocontrols.com |
bb8d3663aa01acb61b6f268ac47f9567ccb682cb | 8973dd51588517ac8755230820e97b8215cadc92 | /cores/Cosa/examples/Wireless/CosaWirelessDS18B20/CosaWirelessDS18B20.ino | e99786723051b50b5118ef8be755fe2d80aac951 | [
"BSD-3-Clause"
] | permissive | UECIDE/UECIDE_data | 3fa6b17113743de7bcb7d3cb8d430637efb494b6 | 96bf6b15910ec3794bd7c13e5274e5ac03379aa9 | refs/heads/master | 2016-09-06T17:38:44.223404 | 2014-02-15T00:48:46 | 2014-02-15T00:48:46 | 13,354,806 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,262 | ino | /**
* @file CosaWirelessDS18B20.ino
* @version 1.0
*
* @section License
* Copyright (C) 2013, Mikael Patel
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA
*
* @section Description
* Demonstration sending temperature readings from two 1-Wire DS18B20
* devices over the Wireless Interface and devices.
*
* @section Circuit
* Connect RF433/315 Transmitter Data to ATtiny85 D0, connect VCC
* GND. Connect 1-Wire digital thermometer to D3 with pullup resistor.
* The pullup resistor (4K7) may be connected to D4 to allow active power
* control. This sketch supports parasite powered DS18B20 devices.
* Connect the DS18B20 VCC to GND.
*
* @section Measurements
* Arduino Mini Pro 16 Mhz (Power LED removed).
* Power Idle Sampling Transmitting
* LiPo 3.9 V 40 uA 1.3 mA 6 mA (RF433).
* FTDI 5,1 V 190 uA 1.5 mA 10 mA (RF433).
*
* @section Note
* This sketch is designed to also run on an ATtiny85 running on the
* internal 8 MHz clock.
*
* This file is part of the Arduino Che Cosa project.
*/
#include "Cosa/Pins.hh"
#include "Cosa/OWI.hh"
#include "Cosa/OWI/Driver/DS18B20.hh"
#include "Cosa/Power.hh"
#include "Cosa/Watchdog.hh"
#include "Cosa/RTC.hh"
// Configuration; network and device addresses
#define NETWORK 0xC05A
#if defined(__ARDUINO_TINY__)
#define DEVICE 0x30
#else
#define DEVICE 0x31
#endif
// Select Wireless device driver
#define USE_CC1101
// #define USE_NRF24L01P
// #define USE_VWI
#if defined(USE_CC1101)
#include "Cosa/Wireless/Driver/CC1101.hh"
CC1101 rf(NETWORK, DEVICE);
#elif defined(USE_NRF24L01P)
#include "Cosa/Wireless/Driver/NRF24L01P.hh"
NRF24L01P rf(NETWORK, DEVICE);
#elif defined(USE_VWI)
#include "Cosa/Wireless/Driver/VWI.hh"
#include "Cosa/Wireless/Driver/VWI/Codec/VirtualWireCodec.hh"
VirtualWireCodec codec;
#define SPEED 4000
#if defined(__ARDUINO_TINY__)
VWI rf(NETWORK, DEVICE, SPEED, Board::D1, Board::D0, &codec);
#else
VWI rf(NETWORK, DEVICE, SPEED, Board::D7, Board::D8, &codec);
#endif
#endif
// Connect to one-wire device; Assuming there are two sensors
OWI owi(Board::D3);
DS18B20 indoors(&owi);
DS18B20 outdoors(&owi);
// Active pullup (pullup resistor connected to this pin)
OutputPin pw(Board::D4);
void setup()
{
// Set up watchdog for power down sleep mode
Watchdog::begin(128, SLEEP_MODE_PWR_DOWN);
RTC::begin();
// Start the wireless device and powerdown
rf.begin();
rf.powerdown();
// Connect to the temperature sensors
pw.on();
indoors.connect(0);
outdoors.connect(1);
pw.off();
// Put the hardware in power down
Power::all_disable();
}
// Message from the device; temperature and voltage reading
struct dt_msg_t {
uint8_t nr;
int16_t indoors;
int16_t outdoors;
uint16_t battery;
};
static const uint8_t DIGITAL_TEMP_TYPE = 0x02;
void loop()
{
// Message sequence number initialization
static uint8_t nr = 0;
// Make a conversion request and read the temperature (scratchpad)
pw.on();
DS18B20::convert_request(&owi, 12, true);
indoors.read_scratchpad();
outdoors.read_scratchpad();
pw.off();
// Turn on necessary hardware modules
Power::all_enable();
// Initiate the message with measurements
dt_msg_t msg;
msg.nr = nr++;
msg.indoors = indoors.get_temperature();
msg.outdoors = outdoors.get_temperature();
msg.battery = AnalogPin::bandgap(1100);
// Broadcast the message and power down after completion
rf.broadcast(DIGITAL_TEMP_TYPE, &msg, sizeof(msg));
rf.powerdown();
// Turn off hardware and deep sleep until next sample (period 5 s)
Power::all_disable();
SLEEP(5);
}
| [
"matt@majenko.co.uk"
] | matt@majenko.co.uk |
b7b454308f9df43d25525c4e6a5992189e0b3067 | a8b4d7b9c15cb242c78c34c4b7966f71f35ea9fb | /3rdparty/capo/noncopyable.hpp | cb70a11496ba4f6d5b8462899251fd01200caa00 | [
"MIT"
] | permissive | kipade/cpp-ipc | c8d112e14d0d61b49a14e9b843038f06f04a9905 | 2a2b626210d36e8b483b070523de8561b4d47355 | refs/heads/master | 2023-05-25T20:50:54.023769 | 2023-02-11T10:25:23 | 2023-02-25T08:30:11 | 249,610,111 | 0 | 0 | MIT | 2020-03-24T04:09:52 | 2020-03-24T04:09:51 | null | UTF-8 | C++ | false | false | 499 | hpp | /*
The Capo Library
Code covered by the MIT License
Author: mutouyun (http://orzz.org)
*/
#pragma once
namespace capo {
////////////////////////////////////////////////////////////////
class noncopyable
{
protected:
noncopyable(void) = default;
~noncopyable(void) = default;
public:
noncopyable(const noncopyable&) = delete;
noncopyable& operator=(const noncopyable&) = delete;
};
////////////////////////////////////////////////////////////////
} // namespace capo | [
"wood.zhang@dji.com"
] | wood.zhang@dji.com |
505adaa30c9575fe8c90a211b58a467c96840520 | ce6d35d356ba5696718abb41aa47da14b1e849a4 | /src/qmcDriver/qProbability.h | c7770e4ac9bd615b4c4ec2d6b05d17594a3874c7 | [] | no_license | lucaparisi91/qmc | 6a59993de84ce69ca52f255efebf2474d9891b22 | 238e51cdf0df367c78f5e315c52acb0350b6e184 | refs/heads/master | 2021-01-10T07:39:07.615316 | 2018-05-02T15:09:45 | 2018-05-02T15:09:45 | 47,068,205 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 953 | h | #include <vector>
#include <complex>
using namespace std;
template<class grad_t,class all_particles_t>
double Q_probability(grad_t & drift_force_new,grad_t & drift_force_old,all_particles_t & position,all_particles_t & position2,double delta_tau)
{
double q=0;
for(int i=0;i<drift_force_old.size();i++)
{
for(int j=0;j<drift_force_old[i].size();j++)
{
q=q+(drift_force_old[i][j] + drift_force_new[i][j])*(
(drift_force_old[i][j] - drift_force_new[i][j])*(1/2.)*delta_tau - (position[i][j].positionNoBC() - position2[i][j].positionNoBC())
);
}
}
return q;
}
double Q_probability(vector<complex<double> > &drift_force_new,vector<complex<double> > &drift_force_old,vector<double> &position,vector<double> &position2,double delta_tau);
double Q_probability(vector<double> &drift_force_new,vector<double> &drift_force_old,vector<double> &position,vector<double> &position2,double delta_tau);
| [
"luca.parisi91@mail.com"
] | luca.parisi91@mail.com |
ce61981b02abd4269d1646858d853d459f6a1061 | 462c18f5cd1a5e44175584be97e96642b0dc5b08 | /implementation/digitProblem.cpp | d382d9d1717cd7bef7e0f3ac4c39a253dace2501 | [] | no_license | ShrinathRaje/Data-Structures-and-Algorithms-Practice | 40d1153730eae623ff00cb09d7770b5800c01551 | 1bf61e38c1702a20455f0e7e841467c52fb3a7cc | refs/heads/master | 2021-07-06T08:29:35.672609 | 2020-08-24T17:47:35 | 2020-08-24T17:47:35 | 170,354,651 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 460 | cpp | /*
* Digit problem
* Date: 27th Nov 2019
* Author: Shrinath bhosale
* Problem statement: https://www.hackerearth.com/practice/basic-programming/implementation/basics-of-implementation/practice-problems/algorithm/digit-problem/
*/
#include<iostream>
using namespace std;
int main() {
string s;
int k;
cin >> s >> k;
int l = s.size();
for(int i=0, c = 0; i<l && c != k; ++i) {
if(s[i] != '9') {
s[i] = '9';
++c;
}
}
cout << s;
return 0;
}
| [
"Shrinathbhosale12@gmail.com"
] | Shrinathbhosale12@gmail.com |
0edd5768e9817dd5f737c6eb3512767f68e94cf6 | ac227cc22d5f5364e5d029a2cef83816a6954590 | /applications/physbam/physbam-lib/Public_Library/PhysBAM_Solids/PhysBAM_Solids/Fracture/VIRTUAL_NODE.h | f405e469f6417de5c19fec9d64e0fea62f9d4008 | [
"BSD-3-Clause"
] | permissive | schinmayee/nimbus | 597185bc8bac91a2480466cebc8b337f5d96bd2e | 170cd15e24a7a88243a6ea80aabadc0fc0e6e177 | refs/heads/master | 2020-03-11T11:42:39.262834 | 2018-04-18T01:28:23 | 2018-04-18T01:28:23 | 129,976,755 | 0 | 0 | BSD-3-Clause | 2018-04-17T23:33:23 | 2018-04-17T23:33:23 | null | UTF-8 | C++ | false | false | 1,033 | h | //#####################################################################
// Copyright 2003-2006, Zhaosheng Bao, Ron Fedkiw, Geoffrey Irving, Neil Molino, Eftychios Sifakis.
// This file is part of PhysBAM whose distribution is governed by the license contained in the accompanying file PHYSBAM_COPYRIGHT.txt.
//#####################################################################
// Class VIRTUAL_NODE
//#####################################################################
#ifndef __VIRTUAL_NODE__
#define __VIRTUAL_NODE__
#include <PhysBAM_Tools/Arrays/ARRAY.h>
namespace PhysBAM{
class VIRTUAL_NODE
{
public:
int index;
int corresponding_real_node;
ARRAY<int> recipients;
VIRTUAL_NODE()
{}
VIRTUAL_NODE(const int corresponding_real_node_input)
:index(0),corresponding_real_node(corresponding_real_node_input)
{}
bool Is_Received_By(const int node) const
{return recipients.Contains(node);}
//#####################################################################
};
}
#endif
| [
"quhang@stanford.edu"
] | quhang@stanford.edu |
43bb10e4ee9f3d80ed5712ccc58181be3d5b9a75 | 582aa70acb599c63734caec165f0151acbe6925a | /TratamentoClassesAbstratas/circulo.cpp | 73035b1a940f1bb2648a09236193d802cd76edec | [] | no_license | Silvabrunu/DCA1201 | 903db0981b45c9db79a4d6d4cb79afacfc883411 | be9b4946e73cdbf225ca0271e1521cdb5a497359 | refs/heads/master | 2020-03-28T11:47:48.322187 | 2018-12-12T02:52:26 | 2018-12-12T02:52:26 | 148,247,496 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,458 | cpp | #include "circulo.h"
#include "screen.h"
#include<iostream>
using namespace std;
Circulo::Circulo(int _x0, int _y0, int _raio, bool _fillmode,char _brush){
x0 = _x0;
y0 = _y0;
raio = _raio;
fillmode = _fillmode;
brush = _brush;
}
void Circulo::draw(Screen &t){
//Altera o caracter de desenho
t.setBrush(brush);
int x = 0;
int y = raio;
int d = 1 - raio;
while(y > x){
//Desenha os pontos no 2 octante e nos octantes restantes
t.setPixel(x0 + x, y0 + y);
t.setPixel(x0 + y, y0 + x);
t.setPixel(x0 - y, y0 + x);
t.setPixel(x0 - x, y0 + y);
t.setPixel(x0 - x, y0 - y);
t.setPixel(x0 - y, y0 - x);
t.setPixel(x0 + y, y0 - x);
t.setPixel(x0 + x, y0 - y);
//Verifica se o circulo é preenchido e o desenha totalmente preenchido
if(fillmode == 1){
for (int i = x0 - x; i <= x0 + x; i++)
{
t.setPixel(i, y0 + y);
t.setPixel(i, y0 - y);
}
for (int i = x0 - y; i <= x0 + y; i++)
{
t.setPixel(i, y0 + x);
t.setPixel(i, y0 - x);
}
}
if(d < 0){
d = d + 2*x + 3;
x = x + 1;
}
else{
d = d + 2*(x-y) + 5;
x = x + 1;
y = y - 1;
}
}
}
| [
"bss.santos.bruno@gmail.com"
] | bss.santos.bruno@gmail.com |
2a27bea0568808b419e5b0d6e8ff84d8a6bdd125 | a1dce8306153cc1bedf55e03e41a894328201c81 | /src/SDK/RH_PhysicsPickup_parameters.hpp | bc1d1bfc676174e49b4a684268c99a4c183cbffb | [] | no_license | zanzo420/SDK-RadicalHeights | 97848bebd47baaa799e6a82546727fb9f829d7f1 | 0eeacd1418b2ee45c1522babed684baf4daf79a9 | refs/heads/master | 2020-03-29T22:22:00.257774 | 2018-04-20T14:11:36 | 2018-04-20T14:11:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 501 | hpp | #pragma once
// Radical Heights (ALPHA-1-201356) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "RH_PhysicsPickup_classes.hpp"
namespace SDK
{
//---------------------------------------------------------------------------
//Parameters
//---------------------------------------------------------------------------
// Function PhysicsPickup.PhysicsPickup_C.UserConstructionScript
struct APhysicsPickup_C_UserConstructionScript_Params
{
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"aeonlucid@outlook.com"
] | aeonlucid@outlook.com |
45abd790375460a909767c29fd9b9e71f68a5b42 | 2cf838b54b556987cfc49f42935f8aa7563ea1f4 | /aws-cpp-sdk-securityhub/include/aws/securityhub/model/AwsS3ObjectDetails.h | bfcc471ee83445d0bf18a20f2c7d27c67d380d53 | [
"MIT",
"Apache-2.0",
"JSON"
] | permissive | QPC-database/aws-sdk-cpp | d11e9f0ff6958c64e793c87a49f1e034813dac32 | 9f83105f7e07fe04380232981ab073c247d6fc85 | refs/heads/main | 2023-06-14T17:41:04.817304 | 2021-07-09T20:28:20 | 2021-07-09T20:28:20 | 384,714,703 | 1 | 0 | Apache-2.0 | 2021-07-10T14:16:41 | 2021-07-10T14:16:41 | null | UTF-8 | C++ | false | false | 14,631 | h | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#pragma once
#include <aws/securityhub/SecurityHub_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>
namespace Aws
{
namespace Utils
{
namespace Json
{
class JsonValue;
class JsonView;
} // namespace Json
} // namespace Utils
namespace SecurityHub
{
namespace Model
{
/**
* <p>Details about an Amazon S3 object.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/securityhub-2018-10-26/AwsS3ObjectDetails">AWS
* API Reference</a></p>
*/
class AWS_SECURITYHUB_API AwsS3ObjectDetails
{
public:
AwsS3ObjectDetails();
AwsS3ObjectDetails(Aws::Utils::Json::JsonView jsonValue);
AwsS3ObjectDetails& operator=(Aws::Utils::Json::JsonView jsonValue);
Aws::Utils::Json::JsonValue Jsonize() const;
/**
* <p>Indicates when the object was last modified.</p> <p>Uses the
* <code>date-time</code> format specified in <a
* href="https://tools.ietf.org/html/rfc3339#section-5.6">RFC 3339 section 5.6,
* Internet Date/Time Format</a>. The value cannot contain spaces. For example,
* <code>2020-03-22T13:22:13.933Z</code>.</p>
*/
inline const Aws::String& GetLastModified() const{ return m_lastModified; }
/**
* <p>Indicates when the object was last modified.</p> <p>Uses the
* <code>date-time</code> format specified in <a
* href="https://tools.ietf.org/html/rfc3339#section-5.6">RFC 3339 section 5.6,
* Internet Date/Time Format</a>. The value cannot contain spaces. For example,
* <code>2020-03-22T13:22:13.933Z</code>.</p>
*/
inline bool LastModifiedHasBeenSet() const { return m_lastModifiedHasBeenSet; }
/**
* <p>Indicates when the object was last modified.</p> <p>Uses the
* <code>date-time</code> format specified in <a
* href="https://tools.ietf.org/html/rfc3339#section-5.6">RFC 3339 section 5.6,
* Internet Date/Time Format</a>. The value cannot contain spaces. For example,
* <code>2020-03-22T13:22:13.933Z</code>.</p>
*/
inline void SetLastModified(const Aws::String& value) { m_lastModifiedHasBeenSet = true; m_lastModified = value; }
/**
* <p>Indicates when the object was last modified.</p> <p>Uses the
* <code>date-time</code> format specified in <a
* href="https://tools.ietf.org/html/rfc3339#section-5.6">RFC 3339 section 5.6,
* Internet Date/Time Format</a>. The value cannot contain spaces. For example,
* <code>2020-03-22T13:22:13.933Z</code>.</p>
*/
inline void SetLastModified(Aws::String&& value) { m_lastModifiedHasBeenSet = true; m_lastModified = std::move(value); }
/**
* <p>Indicates when the object was last modified.</p> <p>Uses the
* <code>date-time</code> format specified in <a
* href="https://tools.ietf.org/html/rfc3339#section-5.6">RFC 3339 section 5.6,
* Internet Date/Time Format</a>. The value cannot contain spaces. For example,
* <code>2020-03-22T13:22:13.933Z</code>.</p>
*/
inline void SetLastModified(const char* value) { m_lastModifiedHasBeenSet = true; m_lastModified.assign(value); }
/**
* <p>Indicates when the object was last modified.</p> <p>Uses the
* <code>date-time</code> format specified in <a
* href="https://tools.ietf.org/html/rfc3339#section-5.6">RFC 3339 section 5.6,
* Internet Date/Time Format</a>. The value cannot contain spaces. For example,
* <code>2020-03-22T13:22:13.933Z</code>.</p>
*/
inline AwsS3ObjectDetails& WithLastModified(const Aws::String& value) { SetLastModified(value); return *this;}
/**
* <p>Indicates when the object was last modified.</p> <p>Uses the
* <code>date-time</code> format specified in <a
* href="https://tools.ietf.org/html/rfc3339#section-5.6">RFC 3339 section 5.6,
* Internet Date/Time Format</a>. The value cannot contain spaces. For example,
* <code>2020-03-22T13:22:13.933Z</code>.</p>
*/
inline AwsS3ObjectDetails& WithLastModified(Aws::String&& value) { SetLastModified(std::move(value)); return *this;}
/**
* <p>Indicates when the object was last modified.</p> <p>Uses the
* <code>date-time</code> format specified in <a
* href="https://tools.ietf.org/html/rfc3339#section-5.6">RFC 3339 section 5.6,
* Internet Date/Time Format</a>. The value cannot contain spaces. For example,
* <code>2020-03-22T13:22:13.933Z</code>.</p>
*/
inline AwsS3ObjectDetails& WithLastModified(const char* value) { SetLastModified(value); return *this;}
/**
* <p>The opaque identifier assigned by a web server to a specific version of a
* resource found at a URL.</p>
*/
inline const Aws::String& GetETag() const{ return m_eTag; }
/**
* <p>The opaque identifier assigned by a web server to a specific version of a
* resource found at a URL.</p>
*/
inline bool ETagHasBeenSet() const { return m_eTagHasBeenSet; }
/**
* <p>The opaque identifier assigned by a web server to a specific version of a
* resource found at a URL.</p>
*/
inline void SetETag(const Aws::String& value) { m_eTagHasBeenSet = true; m_eTag = value; }
/**
* <p>The opaque identifier assigned by a web server to a specific version of a
* resource found at a URL.</p>
*/
inline void SetETag(Aws::String&& value) { m_eTagHasBeenSet = true; m_eTag = std::move(value); }
/**
* <p>The opaque identifier assigned by a web server to a specific version of a
* resource found at a URL.</p>
*/
inline void SetETag(const char* value) { m_eTagHasBeenSet = true; m_eTag.assign(value); }
/**
* <p>The opaque identifier assigned by a web server to a specific version of a
* resource found at a URL.</p>
*/
inline AwsS3ObjectDetails& WithETag(const Aws::String& value) { SetETag(value); return *this;}
/**
* <p>The opaque identifier assigned by a web server to a specific version of a
* resource found at a URL.</p>
*/
inline AwsS3ObjectDetails& WithETag(Aws::String&& value) { SetETag(std::move(value)); return *this;}
/**
* <p>The opaque identifier assigned by a web server to a specific version of a
* resource found at a URL.</p>
*/
inline AwsS3ObjectDetails& WithETag(const char* value) { SetETag(value); return *this;}
/**
* <p>The version of the object.</p>
*/
inline const Aws::String& GetVersionId() const{ return m_versionId; }
/**
* <p>The version of the object.</p>
*/
inline bool VersionIdHasBeenSet() const { return m_versionIdHasBeenSet; }
/**
* <p>The version of the object.</p>
*/
inline void SetVersionId(const Aws::String& value) { m_versionIdHasBeenSet = true; m_versionId = value; }
/**
* <p>The version of the object.</p>
*/
inline void SetVersionId(Aws::String&& value) { m_versionIdHasBeenSet = true; m_versionId = std::move(value); }
/**
* <p>The version of the object.</p>
*/
inline void SetVersionId(const char* value) { m_versionIdHasBeenSet = true; m_versionId.assign(value); }
/**
* <p>The version of the object.</p>
*/
inline AwsS3ObjectDetails& WithVersionId(const Aws::String& value) { SetVersionId(value); return *this;}
/**
* <p>The version of the object.</p>
*/
inline AwsS3ObjectDetails& WithVersionId(Aws::String&& value) { SetVersionId(std::move(value)); return *this;}
/**
* <p>The version of the object.</p>
*/
inline AwsS3ObjectDetails& WithVersionId(const char* value) { SetVersionId(value); return *this;}
/**
* <p>A standard MIME type describing the format of the object data.</p>
*/
inline const Aws::String& GetContentType() const{ return m_contentType; }
/**
* <p>A standard MIME type describing the format of the object data.</p>
*/
inline bool ContentTypeHasBeenSet() const { return m_contentTypeHasBeenSet; }
/**
* <p>A standard MIME type describing the format of the object data.</p>
*/
inline void SetContentType(const Aws::String& value) { m_contentTypeHasBeenSet = true; m_contentType = value; }
/**
* <p>A standard MIME type describing the format of the object data.</p>
*/
inline void SetContentType(Aws::String&& value) { m_contentTypeHasBeenSet = true; m_contentType = std::move(value); }
/**
* <p>A standard MIME type describing the format of the object data.</p>
*/
inline void SetContentType(const char* value) { m_contentTypeHasBeenSet = true; m_contentType.assign(value); }
/**
* <p>A standard MIME type describing the format of the object data.</p>
*/
inline AwsS3ObjectDetails& WithContentType(const Aws::String& value) { SetContentType(value); return *this;}
/**
* <p>A standard MIME type describing the format of the object data.</p>
*/
inline AwsS3ObjectDetails& WithContentType(Aws::String&& value) { SetContentType(std::move(value)); return *this;}
/**
* <p>A standard MIME type describing the format of the object data.</p>
*/
inline AwsS3ObjectDetails& WithContentType(const char* value) { SetContentType(value); return *this;}
/**
* <p>If the object is stored using server-side encryption, the value of the
* server-side encryption algorithm used when storing this object in Amazon S3.</p>
*/
inline const Aws::String& GetServerSideEncryption() const{ return m_serverSideEncryption; }
/**
* <p>If the object is stored using server-side encryption, the value of the
* server-side encryption algorithm used when storing this object in Amazon S3.</p>
*/
inline bool ServerSideEncryptionHasBeenSet() const { return m_serverSideEncryptionHasBeenSet; }
/**
* <p>If the object is stored using server-side encryption, the value of the
* server-side encryption algorithm used when storing this object in Amazon S3.</p>
*/
inline void SetServerSideEncryption(const Aws::String& value) { m_serverSideEncryptionHasBeenSet = true; m_serverSideEncryption = value; }
/**
* <p>If the object is stored using server-side encryption, the value of the
* server-side encryption algorithm used when storing this object in Amazon S3.</p>
*/
inline void SetServerSideEncryption(Aws::String&& value) { m_serverSideEncryptionHasBeenSet = true; m_serverSideEncryption = std::move(value); }
/**
* <p>If the object is stored using server-side encryption, the value of the
* server-side encryption algorithm used when storing this object in Amazon S3.</p>
*/
inline void SetServerSideEncryption(const char* value) { m_serverSideEncryptionHasBeenSet = true; m_serverSideEncryption.assign(value); }
/**
* <p>If the object is stored using server-side encryption, the value of the
* server-side encryption algorithm used when storing this object in Amazon S3.</p>
*/
inline AwsS3ObjectDetails& WithServerSideEncryption(const Aws::String& value) { SetServerSideEncryption(value); return *this;}
/**
* <p>If the object is stored using server-side encryption, the value of the
* server-side encryption algorithm used when storing this object in Amazon S3.</p>
*/
inline AwsS3ObjectDetails& WithServerSideEncryption(Aws::String&& value) { SetServerSideEncryption(std::move(value)); return *this;}
/**
* <p>If the object is stored using server-side encryption, the value of the
* server-side encryption algorithm used when storing this object in Amazon S3.</p>
*/
inline AwsS3ObjectDetails& WithServerSideEncryption(const char* value) { SetServerSideEncryption(value); return *this;}
/**
* <p>The identifier of the AWS Key Management Service (AWS KMS) symmetric customer
* managed customer master key (CMK) that was used for the object.</p>
*/
inline const Aws::String& GetSSEKMSKeyId() const{ return m_sSEKMSKeyId; }
/**
* <p>The identifier of the AWS Key Management Service (AWS KMS) symmetric customer
* managed customer master key (CMK) that was used for the object.</p>
*/
inline bool SSEKMSKeyIdHasBeenSet() const { return m_sSEKMSKeyIdHasBeenSet; }
/**
* <p>The identifier of the AWS Key Management Service (AWS KMS) symmetric customer
* managed customer master key (CMK) that was used for the object.</p>
*/
inline void SetSSEKMSKeyId(const Aws::String& value) { m_sSEKMSKeyIdHasBeenSet = true; m_sSEKMSKeyId = value; }
/**
* <p>The identifier of the AWS Key Management Service (AWS KMS) symmetric customer
* managed customer master key (CMK) that was used for the object.</p>
*/
inline void SetSSEKMSKeyId(Aws::String&& value) { m_sSEKMSKeyIdHasBeenSet = true; m_sSEKMSKeyId = std::move(value); }
/**
* <p>The identifier of the AWS Key Management Service (AWS KMS) symmetric customer
* managed customer master key (CMK) that was used for the object.</p>
*/
inline void SetSSEKMSKeyId(const char* value) { m_sSEKMSKeyIdHasBeenSet = true; m_sSEKMSKeyId.assign(value); }
/**
* <p>The identifier of the AWS Key Management Service (AWS KMS) symmetric customer
* managed customer master key (CMK) that was used for the object.</p>
*/
inline AwsS3ObjectDetails& WithSSEKMSKeyId(const Aws::String& value) { SetSSEKMSKeyId(value); return *this;}
/**
* <p>The identifier of the AWS Key Management Service (AWS KMS) symmetric customer
* managed customer master key (CMK) that was used for the object.</p>
*/
inline AwsS3ObjectDetails& WithSSEKMSKeyId(Aws::String&& value) { SetSSEKMSKeyId(std::move(value)); return *this;}
/**
* <p>The identifier of the AWS Key Management Service (AWS KMS) symmetric customer
* managed customer master key (CMK) that was used for the object.</p>
*/
inline AwsS3ObjectDetails& WithSSEKMSKeyId(const char* value) { SetSSEKMSKeyId(value); return *this;}
private:
Aws::String m_lastModified;
bool m_lastModifiedHasBeenSet;
Aws::String m_eTag;
bool m_eTagHasBeenSet;
Aws::String m_versionId;
bool m_versionIdHasBeenSet;
Aws::String m_contentType;
bool m_contentTypeHasBeenSet;
Aws::String m_serverSideEncryption;
bool m_serverSideEncryptionHasBeenSet;
Aws::String m_sSEKMSKeyId;
bool m_sSEKMSKeyIdHasBeenSet;
};
} // namespace Model
} // namespace SecurityHub
} // namespace Aws
| [
"aws-sdk-cpp-automation@github.com"
] | aws-sdk-cpp-automation@github.com |
6ee35452f550a1eaf7fb0de59f3ad1a26a025ce5 | 7e791eccdc4d41ba225a90b3918ba48e356fdd78 | /chromium/src/chrome/browser/engagement/site_engagement_metrics.cc | 2020022bbceeb1ff45c9fecaf25fd905ff81ca88 | [
"BSD-3-Clause"
] | permissive | WiViClass/cef-3.2623 | 4e22b763a75e90d10ebf9aa3ea9a48a3d9ccd885 | 17fe881e9e481ef368d9f26e903e00a6b7bdc018 | refs/heads/master | 2021-01-25T04:38:14.941623 | 2017-06-09T07:37:43 | 2017-06-09T07:37:43 | 93,824,379 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,161 | cc | // Copyright 2015 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/engagement/site_engagement_metrics.h"
#include "base/metrics/histogram_macros.h"
const char SiteEngagementMetrics::kTotalEngagementHistogram[] =
"SiteEngagementService.TotalEngagement";
const char SiteEngagementMetrics::kTotalOriginsHistogram[] =
"SiteEngagementService.OriginsEngaged";
const char SiteEngagementMetrics::kMeanEngagementHistogram[] =
"SiteEngagementService.MeanEngagement";
const char SiteEngagementMetrics::kMedianEngagementHistogram[] =
"SiteEngagementService.MedianEngagement";
const char SiteEngagementMetrics::kEngagementScoreHistogram[] =
"SiteEngagementService.EngagementScore";
const char SiteEngagementMetrics::kOriginsWithMaxEngagementHistogram[] =
"SiteEngagementService.OriginsWithMaxEngagement";
const char SiteEngagementMetrics::kOriginsWithMaxDailyEngagementHistogram[] =
"SiteEngagementService.OriginsWithMaxDailyEngagement";
const char SiteEngagementMetrics::kPercentOriginsWithMaxEngagementHistogram[] =
"SiteEngagementService.PercentOriginsWithMaxEngagement";
const char SiteEngagementMetrics::kEngagementTypeHistogram[] =
"SiteEngagementService.EngagementType";
const char SiteEngagementMetrics::kDaysSinceLastShortcutLaunchHistogram[] =
"SiteEngagementService.DaysSinceLastShortcutLaunch";
void SiteEngagementMetrics::RecordTotalSiteEngagement(
double total_engagement) {
UMA_HISTOGRAM_COUNTS_10000(kTotalEngagementHistogram, total_engagement);
}
void SiteEngagementMetrics::RecordTotalOriginsEngaged(int num_origins) {
UMA_HISTOGRAM_COUNTS_10000(kTotalOriginsHistogram, num_origins);
}
void SiteEngagementMetrics::RecordMeanEngagement(double mean_engagement) {
UMA_HISTOGRAM_COUNTS_100(kMeanEngagementHistogram, mean_engagement);
}
void SiteEngagementMetrics::RecordMedianEngagement(double median_engagement) {
UMA_HISTOGRAM_COUNTS_100(kMedianEngagementHistogram, median_engagement);
}
void SiteEngagementMetrics::RecordEngagementScores(
std::map<GURL, double> score_map) {
for (const auto& value: score_map) {
UMA_HISTOGRAM_COUNTS_100(kEngagementScoreHistogram, value.second);
}
}
void SiteEngagementMetrics::RecordOriginsWithMaxEngagement(int total_origins) {
UMA_HISTOGRAM_COUNTS_100(kOriginsWithMaxEngagementHistogram, total_origins);
}
void SiteEngagementMetrics::RecordOriginsWithMaxDailyEngagement(
int total_origins) {
UMA_HISTOGRAM_COUNTS_100(kOriginsWithMaxDailyEngagementHistogram,
total_origins);
}
void SiteEngagementMetrics::RecordPercentOriginsWithMaxEngagement(
double percentage) {
UMA_HISTOGRAM_COUNTS_100(kPercentOriginsWithMaxEngagementHistogram,
percentage);
}
void SiteEngagementMetrics::RecordEngagement(EngagementType type) {
UMA_HISTOGRAM_ENUMERATION(kEngagementTypeHistogram, type, ENGAGEMENT_LAST);
}
void SiteEngagementMetrics::RecordDaysSinceLastShortcutLaunch(int days) {
UMA_HISTOGRAM_COUNTS_100(kDaysSinceLastShortcutLaunchHistogram, days);
}
| [
"1480868058@qq.com"
] | 1480868058@qq.com |
74a777ccd496970c1ce7c4b83b2c0484d89edf34 | 9a1315cc4083ce84b605e0c4af8b07a391f74d0c | /libcef/browser/download_manager_delegate.h | 272dc4f6472adfad87b1935da3c5fc759c69f547 | [] | no_license | hernad/cef3_3 | 7fcc198a3b05d73a0c03a47f4e46be45af432528 | 57f67842c121dca0a1e94d44a95c23225653d967 | refs/heads/master | 2016-09-02T04:35:44.082958 | 2012-12-25T08:59:01 | 2012-12-25T08:59:01 | 7,317,503 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,756 | h | // 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.
#ifndef CEF_LIBCEF_BROWSER_DOWNLOAD_MANAGER_DELEGATE_H_
#define CEF_LIBCEF_BROWSER_DOWNLOAD_MANAGER_DELEGATE_H_
#pragma once
#include <set>
#include "base/compiler_specific.h"
#include "base/memory/weak_ptr.h"
#include "content/public/browser/download_item.h"
#include "content/public/browser/download_manager.h"
#include "content/public/browser/download_manager_delegate.h"
class CefDownloadManagerDelegate
: public content::DownloadItem::Observer,
public content::DownloadManager::Observer,
public content::DownloadManagerDelegate {
public:
explicit CefDownloadManagerDelegate(content::DownloadManager* manager);
~CefDownloadManagerDelegate();
private:
// DownloadItem::Observer methods.
virtual void OnDownloadUpdated(content::DownloadItem* download) OVERRIDE;
virtual void OnDownloadDestroyed(content::DownloadItem* download) OVERRIDE;
// DownloadManager::Observer methods.
virtual void OnDownloadCreated(content::DownloadManager* manager,
content::DownloadItem* item) OVERRIDE;
virtual void ManagerGoingDown(content::DownloadManager* manager) OVERRIDE;
// DownloadManagerDelegate methods.
virtual bool DetermineDownloadTarget(
content::DownloadItem* item,
const content::DownloadTargetCallback& callback) OVERRIDE;
content::DownloadManager* manager_;
base::WeakPtrFactory<content::DownloadManager> manager_ptr_factory_;
std::set<content::DownloadItem*> observing_;
DISALLOW_COPY_AND_ASSIGN(CefDownloadManagerDelegate);
};
#endif // CEF_LIBCEF_BROWSER_DOWNLOAD_MANAGER_DELEGATE_H_
| [
"hernad@bring.out.ba"
] | hernad@bring.out.ba |
62d7de7d49db1a0340215a88df46e43eb0eeccd4 | 65dbef8d4b81ce04ac3a8c9e3a3da91a07313688 | /C・C++/独習C++新版/ch03/check_4.cpp | 6a6d4f7ab6b8b1fd38343e93ec425bd46cd4eff6 | [] | no_license | iinuma0710/programming_study | 2c0b9526327cdb98b4c3da7e5cb19125db5f1299 | e1eefb062487f32c982c1fed4b4c3739b90fbb37 | refs/heads/main | 2023-04-18T23:03:49.819678 | 2021-04-03T03:02:40 | 2021-04-03T03:02:40 | 311,096,491 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 207 | cpp | #include <iostream>
class A
{
int private_val = 77;
friend void show(const A& a);
};
void show(const A& a)
{
std::cout << a.private_val << std::endl;
}
int main()
{
A aa;
show(aa);
} | [
"iinuma0710@gmail.com"
] | iinuma0710@gmail.com |
7c9f9ea25e4c7e945c96f04cf3044bffc189fdc4 | 669951b6fc45543581f452a75831eaae77c3627c | /1114E.cpp | 19c4628f41b3f6914332f9bfa8a94d04d8e6501e | [] | no_license | atharva-sarage/Codeforces-Competitive-Programming | 4c0d65cb7f892ba8fa9fc58e539d1b50d0d7a9cb | c718f0693e905e97fbb48eb05981eeddafde108e | refs/heads/master | 2020-06-10T01:12:17.336028 | 2019-06-24T16:43:32 | 2019-06-24T16:43:32 | 193,542,627 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,301 | cpp | /**************************
* Author-Atharva Sarage *
* IIT HYDERABAD *
**************************/
#include<bits/stdc++.h>
#warning Check Max_Limit,Overflows
using namespace std;
# define ff first
# define ss second
# define pb push_back
# define mod 1000000007
# define mx 100005
# define ll long long
# define db double
# define inf 1e9
# define IOS ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
mt19937 rng64(chrono::steady_clock::now().time_since_epoch().count());
ll query1(ll x)
{
cout<<">"<<" "<<x<<endl;
ll ans;
cin>>ans;
return ans;
}
ll query2(ll x)
{
cout<<"?"<<" "<<x<<endl;
ll ans;
cin>>ans;
return ans;
}
int main()
{
srand(rand());
IOS;
ll n;
cin>>n;
ll low=0;
ll high=inf;
ll mid;
while(high>=low)
{
mid=low+(high-low)/2;
if(query1(mid))
low=mid+1;
else
high=mid-1;
}
ll maxi=low;
set <ll> s;
set <ll> :: iterator itr,itr1,itr2;
s.insert(maxi);
int RandomRange=n;
for(ll i=0;i<30;i++)
{
int k = rng64() % RandomRange+1;
ll l=query2(k);
s.insert(l);
if(s.size()==n)
break;
}
ll g=0;
itr2=s.end();
itr2--;
for(itr=s.begin();itr!=itr2;itr++)
{
itr1=itr;
itr1++;
g=__gcd(g,*itr1-*itr);
}
cout<<"! "<<maxi-(n-1)*g<<" "<<g<<endl;
}
| [
"atharva.sarage@gmail.com"
] | atharva.sarage@gmail.com |
fed9961ce5830e2de76ee717fdd5a7359b750ed6 | 20319e3b72920474e45be77f29e175b648daa19f | /NOWY/CStateMachine.h | 3b3e765c6a31f60daab9f7a15f5e4f0fb00c23dd | [] | no_license | mad0/SomeNEW | c67e3794a713da2c9048a529e4ad3957f05c14dc | 1d48ea04cccc2bf709f173b47d0dad3a67cbbe1f | refs/heads/master | 2020-05-21T08:34:18.757733 | 2019-07-10T12:26:00 | 2019-07-10T12:26:00 | 185,984,498 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 514 | h | #pragma once
#include <memory>
#include "SFML/Graphics.hpp"
#include <map>
enum STATES {MENU, PLAY};
class CGameState;
class CStateMachine {
public:
CStateMachine();
~CStateMachine();
void addState(STATES, std::shared_ptr<CGameState>);
void changeState(STATES);
std::shared_ptr<CGameState> getState(STATES);
void delState(STATES);
void input();
void update();
void draw();
STATES sType;
private:
std::shared_ptr<CGameState> curentState;
std::map<STATES, std::shared_ptr<CGameState>> mResources;
};
| [
"madowaty@gmail.com"
] | madowaty@gmail.com |
899e49a875596c2a867dc61e0afa93e4da45c5b7 | 6f4dbb99df537ff0f86bbc323e30371f2a4521d2 | /easy-as-pie/funcs/source/stores.cpp | 0198161be108d3614f0c65a7e0f0ab089aaac5e0 | [
"Unlicense"
] | permissive | rodrigobmg/psx | 0e54d12aba6a25987274e1cf81a18019e367eafe | 34ca33d2254958963026d1719c31cfc69bfaaf7b | refs/heads/master | 2020-04-03T19:13:11.007887 | 2018-08-20T16:12:49 | 2018-08-20T16:12:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,049 | cpp | // C:\diabpsx\SOURCE\STORES.CPP
#include "types.h"
// address: 0x800633E8
void FreeStoreMem__Fv() {
}
// address: 0x800633F0
void DrawSTextBack__Fv() {
}
// address: 0x80063460
void PrintSString__FiiUcPcci(int x, int y, unsigned char cjustflag, char *str, int col, int val) {
// register: 21
register int xx;
// register: 19
register int yy;
// address: 0xFFFFFFB0
// size: 0x20
auto char valstr[32];
// register: 30
register int SpinnerY;
// register: 20
register unsigned char R;
// register: 18
register unsigned char G;
// register: 17
register unsigned char B;
// address: 0x8012B508
static unsigned char DaveFix;
}
// address: 0x80063838
void DrawSLine__Fi(int y) {
// register: 16
register int yy;
}
// address: 0x800638CC
void ClearSText__Fii(int s, int e) {
// register: 4
register int i;
}
// address: 0x80063964
void AddSLine__Fi(int y) {
}
// address: 0x800639B4
void AddSTextVal__Fii(int y, int val) {
}
// address: 0x800639DC
void AddSText__FiiUcPccUc(int x, int y, unsigned char j, char *str, int clr, int sel) {
}
// address: 0x80063A90
void PrintStoreItem__FPC10ItemStructic(struct ItemStruct *x, int l, char iclr) {
// address: 0xFFFFFF58
// size: 0x80
auto char sstr[128];
// register: 21
register int li;
}
// address: 0x80063F18
void StoreAutoPlace__Fv() {
// register: 16
register int i;
// register: 18
register int w;
// register: 19
register int h;
// register: 3
register int idx;
// register: 4
register unsigned char done;
}
// address: 0x80064538
void S_StartSmith__Fv() {
}
// address: 0x800646C0
void S_ScrollSBuy__Fi(int idx) {
// register: 17
register int l;
// register: 20
register int ls;
// register: 18
register char iclr;
}
// address: 0x80064878
void S_StartSBuy__Fv() {
}
// address: 0x800649A8
void S_ScrollSPBuy__Fi(int idx) {
// register: 17
register int l;
// register: 22
register int ls;
// register: 16
register char iclr;
// register: 3
register int boughtitems;
{
{
{
{
// register: 16
register char *StrPtr;
}
}
}
}
}
// address: 0x80064BC8
unsigned char S_StartSPBuy__Fv() {
// register: 4
register int i;
}
// address: 0x80064D18
unsigned char SmithSellOk__Fi(int i) {
}
// address: 0x80064DFC
void S_ScrollSSell__Fi(int idx) {
// register: 19
register int l;
// register: 23
register int ls;
// register: 20
register int v;
// register: 18
register char iclr;
{
{
{
{
// register: 17
register char *StrPtr;
}
}
}
}
}
// address: 0x80065024
void S_StartSSell__Fv() {
// register: 16
register int i;
// register: 18
register unsigned char sellok;
}
// address: 0x80065454
unsigned char SmithRepairOk__Fi(int i) {
}
// address: 0x800654F8
void AddStoreHoldRepair__FP10ItemStructi(struct ItemStruct *itm, int i) {
// register: 4
register int v;
}
// address: 0x800656D8
void S_StartSRepair__Fv() {
// register: 16
register int i;
// register: 18
register unsigned char repairok;
}
// address: 0x80065BA8
void S_StartWitch__Fv() {
}
// address: 0x80065CE8
void S_ScrollWBuy__Fi(int idx) {
// register: 19
register int l;
// register: 21
register int ls;
// register: 18
register char iclr;
{
{
{
{
// register: 17
register char *StrPtr;
}
}
}
}
}
// address: 0x80065EC0
void S_StartWBuy__Fv() {
}
// address: 0x80065FEC
unsigned char WitchSellOk__Fi(int i) {
// register: 5
register unsigned char rv;
// register: 3
// size: 0x98
register struct ItemStruct *pI;
}
// address: 0x80066110
void S_StartWSell__Fv() {
// register: 16
register int i;
// register: 19
register unsigned char sellok;
}
// address: 0x80066768
unsigned char WitchRechargeOk__Fi(int i) {
// register: 6
register unsigned char rv;
}
// address: 0x800667F0
void AddStoreHoldRecharge__FG10ItemStructi(struct ItemStruct itm, int i) {
}
// address: 0x80066970
void S_StartWRecharge__Fv() {
// register: 16
register int i;
// register: 18
register unsigned char rechargeok;
}
// address: 0x80066D90
void S_StartNoMoney__Fv() {
}
// address: 0x80066DF8
void S_StartNoRoom__Fv() {
}
// address: 0x80066E58
void S_StartConfirm__Fv() {
// register: 16
register char iclr;
// register: 3
register unsigned char idprint;
}
// address: 0x800671A8
void S_StartBoy__Fv() {
}
// address: 0x80067338
void S_StartBBoy__Fv() {
// register: 17
register int iclr;
}
// address: 0x80067494
void S_StartHealer__Fv() {
}
// address: 0x80067668
void S_ScrollHBuy__Fi(int idx) {
// register: 19
register int l;
}
// address: 0x800677D4
void S_StartHBuy__Fv() {
}
// address: 0x800678F4
void S_StartStory__Fv() {
}
// address: 0x800679E4
unsigned char IdItemOk__FP10ItemStruct(struct ItemStruct *i) {
}
// address: 0x80067A18
void AddStoreHoldId__FG10ItemStructi(struct ItemStruct itm, int i) {
}
// address: 0x80067AEC
void S_StartSIdentify__Fv() {
// register: 16
register int i;
// register: 19
register unsigned char idok;
}
// address: 0x8006854C
void S_StartIdShow__Fv() {
// register: 17
register char iclr;
// register: 16
register char *StrPtr;
}
// address: 0x80068720
void S_StartTalk__Fv() {
// register: 18
register int i;
// register: 5
register int tq;
// register: 17
register int sn;
// register: 22
register int la;
// register: 20
register int gl;
}
// address: 0x80068950
void S_StartTavern__Fv() {
}
// address: 0x80068A48
void S_StartBarMaid__Fv() {
}
// address: 0x80068B1C
void S_StartDrunk__Fv() {
}
// address: 0x80068BF0
void StartStore__Fc(char s) {
// register: 3
register int i;
}
// address: 0x80068EE0
void DrawSText__Fv() {
}
// address: 0x80068F20
void DrawSTextTSK__FP4TASK(struct TASK *T) {
}
// address: 0x80068FE8
void DoThatDrawSText__Fv() {
// register: 17
register int i;
}
// address: 0x80069194
void STextESC__Fv() {
}
// address: 0x80069310
void STextUp__Fv() {
}
// address: 0x80069498
void STextDown__Fv() {
}
// address: 0x80069630
void S_SmithEnter__Fv() {
}
// address: 0x80069704
void SetGoldCurs__Fii(int pnum, int i) {
}
// address: 0x80069780
void SetSpdbarGoldCurs__Fii(int pnum, int i) {
}
// address: 0x800697FC
void TakePlrsMoney__Fl(long cost) {
// register: 16
register int i;
}
// address: 0x80069C48
void SmithBuyItem__Fv() {
// register: 10
register int idx;
}
// address: 0x80069E3C
void S_SBuyEnter__Fv() {
// register: 4
register int idx;
// register: 16
register int i;
// register: 3
register unsigned char done;
}
// address: 0x8006A060
void SmithBuyPItem__Fv() {
// register: 6
register int idx;
// register: 5
register int i;
// register: 3
register int xx;
}
// address: 0x8006A1E8
void S_SPBuyEnter__Fv() {
// register: 5
register int idx;
// register: 16
register int i;
// register: 3
register unsigned char done;
{
// register: 3
register int xx;
}
}
// address: 0x8006A418
unsigned char StoreGoldFit__Fi(int idx) {
// register: 18
register int sz;
// register: 16
register int numsqrs;
// register: 4
register int i;
// register: 17
register long cost;
}
// address: 0x8006A6D0
void PlaceStoreGold__Fl(long v) {
// register: 16
register int i;
// register: 18
register int ii;
// register: 19
register int xx;
// register: 17
register int yy;
// register: 5
register unsigned char done;
{
{
{
{
}
}
}
}
}
// address: 0x8006A934
void StoreSellItem__Fv() {
// register: 16
register int idx;
// register: 16
register int i;
// register: 17
register long cost;
}
// address: 0x8006AC28
void S_SSellEnter__Fv() {
// register: 8
register int idx;
}
// address: 0x8006AD2C
void SmithRepairItem__Fv() {
// register: 5
register int i;
// register: 4
register int idx;
}
// address: 0x8006AF9C
void S_SRepairEnter__Fv() {
// register: 8
register int idx;
}
// address: 0x8006B0F8
void S_WitchEnter__Fv() {
}
// address: 0x8006B1A8
void WitchBuyItem__Fv() {
// register: 16
register int idx;
}
// address: 0x8006B3A8
void S_WBuyEnter__Fv() {
// register: 4
register int idx;
// register: 16
register int i;
// register: 3
register unsigned char done;
}
// address: 0x8006B594
void S_WSellEnter__Fv() {
// register: 8
register int idx;
}
// address: 0x8006B698
void WitchRechargeItem__Fv() {
// register: 2
register int i;
// register: 4
register int idx;
}
// address: 0x8006B810
void S_WRechargeEnter__Fv() {
// register: 8
register int idx;
}
// address: 0x8006B96C
void S_BoyEnter__Fv() {
}
// address: 0x8006BAA4
void BoyBuyItem__Fv() {
}
// address: 0x8006BB28
void HealerBuyItem__Fv() {
// register: 16
register int idx;
}
// address: 0x8006BDCC
void S_BBuyEnter__Fv() {
// register: 16
register int i;
// register: 3
register unsigned char done;
}
// address: 0x8006BFA4
void StoryIdItem__Fv() {
// register: 5
register int i;
// register: 2
register int idx;
}
// address: 0x8006C2F0
void S_ConfirmEnter__Fv() {
}
// address: 0x8006C40C
void S_HealerEnter__Fv() {
}
// address: 0x8006C4A4
void S_HBuyEnter__Fv() {
// register: 4
register int idx;
// register: 16
register int i;
// register: 3
register unsigned char done;
}
// address: 0x8006C6B0
void S_StoryEnter__Fv() {
}
// address: 0x8006C748
void S_SIDEnter__Fv() {
// register: 8
register int idx;
}
// address: 0x8006C8C4
void S_TalkEnter__Fv() {
// register: 16
register int i;
// register: 5
register int tq;
// register: 18
register int sn;
// register: 21
register int la;
{
{
{
{
}
}
}
}
}
// address: 0x8006CABC
void S_TavernEnter__Fv() {
}
// address: 0x8006CB2C
void S_BarmaidEnter__Fv() {
}
// address: 0x8006CB9C
void S_DrunkEnter__Fv() {
}
// address: 0x8006CC0C
void STextEnter__Fv() {
}
// address: 0x8006CE0C
void CheckStoreBtn__Fv() {
// register: 16
// size: 0x6C
register struct CPad *Pad;
}
// address: 0x8006CF28
void ReleaseStoreBtn__Fv() {
}
// address: 0x8006CF3C
void _GLOBAL__D_pSTextBoxCels() {
}
// address: 0x8006CF64
void _GLOBAL__I_pSTextBoxCels() {
}
| [
"rnd0x00@gmail.com"
] | rnd0x00@gmail.com |
cd55d30dc23988d234c44226796fd67d07c30764 | c1ff870879152fba2b54eddfb7591ec322eb3061 | /plugins/render/ogreRender/3rdParty/ogre/RenderSystems/GL3Plus/include/OgreGL3PlusRenderSystem.h | 73111225dd48bf4527c9a7c8d738cb4980696374 | [
"LicenseRef-scancode-free-unknown",
"MIT"
] | permissive | MTASZTAKI/ApertusVR | 1a9809fb7af81c3cd7fb732ed481ebe4ce66fefa | 424ec5515ae08780542f33cc4841a8f9a96337b3 | refs/heads/0.9 | 2022-12-11T20:03:42.926813 | 2019-10-11T09:29:45 | 2019-10-11T09:29:45 | 73,708,854 | 188 | 55 | MIT | 2022-12-11T08:53:21 | 2016-11-14T13:48:00 | C++ | UTF-8 | C++ | false | false | 21,400 | h | /*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org
Copyright (c) 2000-2014 Torus Knot Software Ltd
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __GL3PlusRenderSystem_H__
#define __GL3PlusRenderSystem_H__
#include "OgreGL3PlusPrerequisites.h"
#include "OgreMaterialManager.h"
#include "OgreRenderSystem.h"
#include "OgreGLSLShader.h"
namespace Ogre {
class GL3PlusContext;
class GL3PlusSupport;
class GL3PlusRTTManager;
class GLSLShaderManager;
class GLSLShaderFactory;
class HardwareBufferManager;
/**
Implementation of GL 3 as a rendering system.
*/
class _OgreGL3PlusExport GL3PlusRenderSystem : public RenderSystem
{
private:
/// Rendering loop control
bool mStopRendering;
typedef OGRE_HashMap<GLenum, GLuint> BindBufferMap;
/// View matrix to set world against
Matrix4 mViewMatrix;
Matrix4 mWorldMatrix;
Matrix4 mTextureMatrix;
/// Last min & mip filtering options, so we can combine them
FilterOptions mMinFilter;
FilterOptions mMipFilter;
bool mTextureCompareEnabled;
/** Used to store the number of mipmaps in the currently bound texture. This is then
used to modify the texture unit filtering.
*/
size_t mTextureMipmapCount;
/// What texture coord set each texture unit is using
size_t mTextureCoordIndex[OGRE_MAX_TEXTURE_LAYERS];
/// Holds texture type settings for every stage
GLenum mTextureTypes[OGRE_MAX_TEXTURE_LAYERS];
GLfloat mLargestSupportedAnisotropy;
/// Number of fixed-function texture units
unsigned short mFixedFunctionTextureUnits;
void initConfigOptions(void);
/// Store last colour write state
bool mColourWrite[4];
/// Store last depth write state
bool mDepthWrite;
/// Store last scissor enable state
bool mScissorsEnabled;
/// Store last stencil mask state
uint32 mStencilWriteMask;
GLfloat mAutoTextureMatrix[16];
bool mUseAutoTextureMatrix;
/// GL support class, used for creating windows etc.
GL3PlusSupport *mGLSupport;
/* The main GL context - main thread only */
GL3PlusContext *mMainContext;
/* The current GL context - main thread only */
GL3PlusContext *mCurrentContext;
typedef list<GL3PlusContext*>::type GL3PlusContextList;
/// List of background thread contexts
GL3PlusContextList mBackgroundContextList;
GLSLShaderManager *mShaderManager;
GLSLShaderFactory* mGLSLShaderFactory;
HardwareBufferManager* mHardwareBufferManager;
/** Manager object for creating render textures.
Direct render to texture via FBO is preferable
to pbuffers, which depend on the GL support used and are generally
unwieldy and slow. However, FBO support for stencil buffers is poor.
*/
GL3PlusRTTManager *mRTTManager;
/** These variables are used for caching RenderSystem state.
They are cached because OpenGL state changes can be quite expensive,
which is especially important on mobile or embedded systems.
*/
GLenum mActiveTextureUnit;
BindBufferMap mActiveBufferMap;
/// Check if the GL system has already been initialised
bool mGLInitialised;
// check if GL 4.3 is supported
bool mHasGL43;
// check if GL 3.2 is supported
bool mHasGL32;
// local data members of _render that were moved here to improve performance
// (save allocations)
vector<GLuint>::type mRenderAttribsBound;
vector<GLuint>::type mRenderInstanceAttribsBound;
#if OGRE_NO_QUAD_BUFFER_STEREO == 0
/// @copydoc RenderSystem::setDrawBuffer
virtual bool setDrawBuffer(ColourBufferType colourBuffer);
#endif
/**
Cache the polygon mode value
*/
GLenum mPolygonMode;
GLint getCombinedMinMipFilter(void) const;
GLSLShader* mCurrentVertexShader;
GLSLShader* mCurrentFragmentShader;
GLSLShader* mCurrentGeometryShader;
GLSLShader* mCurrentHullShader;
GLSLShader* mCurrentDomainShader;
GLSLShader* mCurrentComputeShader;
GLint getTextureAddressingMode(TextureUnitState::TextureAddressingMode tam) const;
GLenum getBlendMode(SceneBlendFactor ogreBlend) const;
bool activateGLTextureUnit(size_t unit);
void bindVertexElementToGpu( const VertexElement &elem, HardwareVertexBufferSharedPtr vertexBuffer,
const size_t vertexStart,
vector<GLuint>::type &attribsBound,
vector<GLuint>::type &instanceAttribsBound,
bool updateVAO);
public:
// Default constructor / destructor
GL3PlusRenderSystem();
~GL3PlusRenderSystem();
friend class ShaderGeneratorTechniqueResolverListener;
// ----------------------------------
// Overridden RenderSystem functions
// ----------------------------------
/** See
RenderSystem
*/
const String& getName(void) const;
/** See
RenderSystem
*/
const String& getFriendlyName(void) const;
/** See
RenderSystem
*/
ConfigOptionMap& getConfigOptions(void);
/** See
RenderSystem
*/
void setConfigOption(const String &name, const String &value);
/** See
RenderSystem
*/
String validateConfigOptions(void);
/** See
RenderSystem
*/
RenderWindow* _initialise(bool autoCreateWindow, const String& windowTitle = "OGRE Render Window");
/** See
RenderSystem
*/
virtual RenderSystemCapabilities* createRenderSystemCapabilities() const;
/** See
RenderSystem
*/
void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps, RenderTarget* primary);
/** See
RenderSystem
*/
void reinitialise(void); // Used if settings changed mid-rendering
/** See
RenderSystem
*/
void shutdown(void);
/** See
RenderSystem
*/
void setAmbientLight(float r, float g, float b) { }; // Not supported
/** See
RenderSystem
*/
void setShadingType(ShadeOptions so) { }; // Not supported
/** See
RenderSystem
*/
void setLightingEnabled(bool enabled) { }; // Not supported
/// @copydoc RenderSystem::_createRenderWindow
RenderWindow* _createRenderWindow(const String &name, unsigned int width, unsigned int height,
bool fullScreen, const NameValuePairList *miscParams = 0);
/// @copydoc RenderSystem::_createRenderWindows
bool _createRenderWindows(const RenderWindowDescriptionList& renderWindowDescriptions,
RenderWindowList& createdWindows);
/// @copydoc RenderSystem::_createDepthBufferFor
DepthBuffer* _createDepthBufferFor( RenderTarget *renderTarget );
/// Mimics D3D9RenderSystem::_getDepthStencilFormatFor, if no FBO RTT manager, outputs GL_NONE
void _getDepthStencilFormatFor( GLenum internalColourFormat, GLenum *depthFormat,
GLenum *stencilFormat );
/// @copydoc RenderSystem::createMultiRenderTarget
virtual MultiRenderTarget * createMultiRenderTarget(const String & name);
/** See
RenderSystem
*/
void destroyRenderWindow(RenderWindow* pWin);
/** See
RenderSystem
*/
String getErrorDescription(long errorNumber) const;
/** See
RenderSystem
*/
VertexElementType getColourVertexElementType(void) const;
/** See
RenderSystem
*/
void setNormaliseNormals(bool normalise) { }; // Not supported
// -----------------------------
// Low-level overridden members
// -----------------------------
/** See
RenderSystem
*/
void _useLights(const LightList& lights, unsigned short limit) { }; // Not supported
/** See
RenderSystem
*/
bool areFixedFunctionLightsInViewSpace() const { return true; }
/** See
RenderSystem
*/
void _setWorldMatrix(const Matrix4 &m);
/** See
RenderSystem
*/
void _setViewMatrix(const Matrix4 &m);
/** See
RenderSystem
*/
void _setProjectionMatrix(const Matrix4 &m);
/** See
RenderSystem
*/
void _setSurfaceParams(const ColourValue &ambient,
const ColourValue &diffuse, const ColourValue &specular,
const ColourValue &emissive, Real shininess,
TrackVertexColourType tracking) {}
/** See
RenderSystem
*/
void _setPointParameters(Real size, bool attenuationEnabled,
Real constant, Real linear, Real quadratic, Real minSize, Real maxSize);
/** See
RenderSystem
*/
void _setPointSpritesEnabled(bool enabled);
/** See
RenderSystem
*/
void _setVertexTexture(size_t unit, const TexturePtr &tex);
/** See
RenderSystem
*/
void _setGeometryTexture(size_t unit, const TexturePtr &tex);
/** See
RenderSystem
*/
void _setComputeTexture(size_t unit, const TexturePtr &tex);
/** See
RenderSystem
*/
void _setTesselationHullTexture(size_t unit, const TexturePtr &tex);
/** See
RenderSystem
*/
void _setTesselationDomainTexture(size_t unit, const TexturePtr &tex);
/** See
RenderSystem
*/
void _setTexture(size_t unit, bool enabled, const TexturePtr &tex);
/** See
RenderSystem
*/
void _setTextureCoordSet(size_t stage, size_t index);
/** See
RenderSystem
*/
void _setTextureCoordCalculation(size_t stage, TexCoordCalcMethod m,
const Frustum* frustum = 0) { }; // Not supported
/** See
RenderSystem
*/
void _setTextureBlendMode(size_t stage, const LayerBlendModeEx& bm) { }; // Not supported
/** See
RenderSystem
*/
void _setTextureAddressingMode(size_t stage, const TextureUnitState::UVWAddressingMode& uvw);
/** See
RenderSystem
*/
void _setTextureBorderColour(size_t stage, const ColourValue& colour);
/** See
RenderSystem
*/
void _setTextureMipmapBias(size_t unit, float bias);
/** See
RenderSystem
*/
void _setTextureMatrix(size_t stage, const Matrix4& xform) { }; // Not supported
/** See
RenderSystem
*/
void _setViewport(Viewport *vp);
/** See
RenderSystem
*/
void _beginFrame(void);
/** See
RenderSystem
*/
void _endFrame(void);
/** See
RenderSystem
*/
void _setCullingMode(CullingMode mode);
/** See
RenderSystem
*/
void _setDepthBufferParams(bool depthTest = true, bool depthWrite = true, CompareFunction depthFunction = CMPF_LESS_EQUAL);
/** See
RenderSystem
*/
void _setDepthBufferCheckEnabled(bool enabled = true);
/** See
RenderSystem
*/
void _setDepthBufferWriteEnabled(bool enabled = true);
/** See
RenderSystem
*/
void _setDepthBufferFunction(CompareFunction func = CMPF_LESS_EQUAL);
/** See
RenderSystem
*/
void _setDepthBias(float constantBias, float slopeScaleBias);
/** See
RenderSystem
*/
void _setColourBufferWriteEnabled(bool red, bool green, bool blue, bool alpha);
/** See
RenderSystem
*/
void _setFog(FogMode mode, const ColourValue& colour, Real density, Real start, Real end) {}
/** See
RenderSystem
*/
void _convertProjectionMatrix(const Matrix4& matrix,
Matrix4& dest, bool forGpuProgram = false);
/** See
RenderSystem
*/
void _makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
Matrix4& dest, bool forGpuProgram = false);
/** See
RenderSystem
*/
void _makeProjectionMatrix(Real left, Real right, Real bottom, Real top,
Real nearPlane, Real farPlane, Matrix4& dest, bool forGpuProgram = false);
/** See
RenderSystem
*/
void _makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane,
Matrix4& dest, bool forGpuProgram = false);
/** See
RenderSystem
*/
void _applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane,
bool forGpuProgram);
/** See
RenderSystem
*/
void setClipPlane (ushort index, Real A, Real B, Real C, Real D);
/** See
RenderSystem
*/
void enableClipPlane (ushort index, bool enable);
/** See
RenderSystem
*/
void _setPolygonMode(PolygonMode level);
/** See
RenderSystem
*/
void setStencilCheckEnabled(bool enabled);
/** See
RenderSystem.
*/
void setStencilBufferParams(CompareFunction func = CMPF_ALWAYS_PASS,
uint32 refValue = 0, uint32 compareMask = 0xFFFFFFFF, uint32 writeMask = 0xFFFFFFFF,
StencilOperation stencilFailOp = SOP_KEEP,
StencilOperation depthFailOp = SOP_KEEP,
StencilOperation passOp = SOP_KEEP,
bool twoSidedOperation = false,
bool readBackAsTexture = false);
/** See
RenderSystem
*/
void _setTextureUnitFiltering(size_t unit, FilterType ftype, FilterOptions filter);
/** See
RenderSystem
*/
void _setTextureUnitCompareFunction(size_t unit, CompareFunction function);
/** See
RenderSystem
*/
void _setTextureUnitCompareEnabled(size_t unit, bool compare);
/** See
RenderSystem
*/
void _setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy);
/** See
RenderSystem
*/
void setVertexDeclaration(VertexDeclaration* decl) {}
/** See
RenderSystem
*/
void setVertexDeclaration(VertexDeclaration* decl, VertexBufferBinding* binding) {}
/** See
RenderSystem.
*/
void setVertexBufferBinding(VertexBufferBinding* binding) {}
/** See
RenderSystem
*/
void _render(const RenderOperation& op);
/** See
RenderSystem
*/
void setScissorTest(bool enabled, size_t left = 0, size_t top = 0, size_t right = 800, size_t bottom = 600);
void clearFrameBuffer(unsigned int buffers,
const ColourValue& colour = ColourValue::Black,
Real depth = 1.0f, unsigned short stencil = 0);
HardwareOcclusionQuery* createHardwareOcclusionQuery(void);
Real getHorizontalTexelOffset(void) { return 0.0; } // No offset in GL
Real getVerticalTexelOffset(void) { return 0.0; } // No offset in GL
Real getMinimumDepthInputValue(void) { return -1.0f; } // Range [-1.0f, 1.0f]
Real getMaximumDepthInputValue(void) { return 1.0f; } // Range [-1.0f, 1.0f]
OGRE_MUTEX(mThreadInitMutex);
void registerThread();
void unregisterThread();
void preExtraThreadsStarted();
void postExtraThreadsStarted();
void setClipPlanesImpl(const Ogre::PlaneList& planeList);
// ----------------------------------
// GL3PlusRenderSystem specific members
// ----------------------------------
/** Returns the main context */
GL3PlusContext* _getMainContext() { return mMainContext; }
/** Unregister a render target->context mapping. If the context of target
is the current context, change the context to the main context so it
can be destroyed safely.
@note This is automatically called by the destructor of
GL3PlusContext.
*/
void _unregisterContext(GL3PlusContext *context);
/** Switch GL context, dealing with involved internal cached states too
*/
void _switchContext(GL3PlusContext *context);
/** One time initialization for the RenderState of a context. Things that
only need to be set once, like the LightingModel can be defined here.
*/
void _oneTimeContextInitialization();
void initialiseContext(RenderWindow* primary);
/**
* Set current render target to target, enabling its GL context if needed
*/
void _setRenderTarget(RenderTarget *target);
GLint convertCompareFunction(CompareFunction func) const;
GLint convertStencilOp(StencilOperation op, bool invert = false) const;
void bindGpuProgram(GpuProgram* prg);
void unbindGpuProgram(GpuProgramType gptype);
void bindGpuProgramParameters(GpuProgramType gptype, GpuProgramParametersSharedPtr params, uint16 mask);
void bindGpuProgramPassIterationParameters(GpuProgramType gptype);
/// @copydoc RenderSystem::_setSceneBlending
void _setSceneBlending( SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendOperation op );
/// @copydoc RenderSystem::_setSeparateSceneBlending
void _setSeparateSceneBlending( SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendFactor sourceFactorAlpha, SceneBlendFactor destFactorAlpha, SceneBlendOperation op, SceneBlendOperation alphaOp );
/// @copydoc RenderSystem::_setAlphaRejectSettings
void _setAlphaRejectSettings( CompareFunction func, unsigned char value, bool alphaToCoverage );
/// @copydoc RenderSystem::getDisplayMonitorCount
unsigned int getDisplayMonitorCount() const;
/// Internal method for anisotropy validation
GLfloat _getCurrentAnisotropy(size_t unit);
GLenum _getPolygonMode(void) { return mPolygonMode; }
void _setSceneBlendingOperation(SceneBlendOperation op);
void _setSeparateSceneBlendingOperation(SceneBlendOperation op, SceneBlendOperation alphaOp);
/// @copydoc RenderSystem::hasAnisotropicMipMapFilter
virtual bool hasAnisotropicMipMapFilter() const { return false; }
/// @copydoc RenderSystem::beginProfileEvent
virtual void beginProfileEvent( const String &eventName );
/// @copydoc RenderSystem::endProfileEvent
virtual void endProfileEvent( void );
/// @copydoc RenderSystem::markProfileEvent
virtual void markProfileEvent( const String &eventName );
};
}
#endif
| [
"peter.kovacs@sztaki.mta.hu"
] | peter.kovacs@sztaki.mta.hu |
cb341429c1b042dfcb7aa1f3d3b98bec237bcc39 | 181a888d842f9aafcbb618960f2ffe568ec9fc9c | /Navigator.cpp | 7a5a2611da9a0a3712ca5aca80a4ba9ad589fb4b | [] | no_license | katiecai/BruinNav | 4b4e0009470e1e69bcb9fb4143d5e76f758e619b | 5918e142939e61eaacb2286e0a2a239a54fc327d | refs/heads/master | 2020-12-02T19:32:50.227674 | 2017-07-05T20:21:20 | 2017-07-05T20:21:20 | 96,357,998 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,051 | cpp | //#include "provided.h"
#include "MyMap.h"
#include "support.h"
#include <string>
#include <vector>
#include <queue>
#include <iostream>
using namespace std;
struct Node {
Node(const GeoCoord cur, const GeoCoord dest, Node* p, double distance) : m_cur(cur.latitudeText, cur.longitudeText) {
h = distanceEarthMiles(cur, dest);
g = distance;
f = g + h;
parent = p;
//if queue is empty, pass in nullptr
if (parent == nullptr)
path.push_back(cur);
else {
path = parent->path;
path.push_back(cur);
}
}
Node() {
}
GeoCoord m_cur;
double f;
double g;
double h;
Node* parent;
Node& operator=(const Node& rhs);
vector<GeoCoord> path;
};
Node& Node::operator=(const Node& rhs) {
if (this != &rhs) {
m_cur = rhs.m_cur;
f = rhs.f;
g = rhs.g;
h = rhs.h;
path = rhs.path;
parent = rhs.parent;
}
return *this;
}
bool operator==(const Node& lhs, const Node& rhs) {
if (lhs.f == rhs.f)
return true;
return false;
}
bool operator<(const Node& lhs, const Node& rhs) {
if (lhs.f > rhs.f)
return true;
return false;
}
bool operator>(const Node& lhs, const Node& rhs) {
if (lhs.f < rhs.f)
return true;
return false;
}
class NavigatorImpl
{
public:
NavigatorImpl();
~NavigatorImpl();
bool loadMapData(string mapFile);
NavResult navigate(string start, string end, vector<NavSegment>& directions) const;
string getDirection(double angle) const;
string getTurnDirection(double angle) const;
private:
MapLoader ml;
AttractionMapper am;
SegmentMapper sm;
};
NavigatorImpl::NavigatorImpl()
{
}
NavigatorImpl::~NavigatorImpl()
{
}
string NavigatorImpl::getDirection(double angle) const {
if (angle >= 0 && angle <= 22.5)
return "east";
else if (angle > 22.5 && angle <= 67.5)
return "northeast";
else if (angle > 67.5 && angle <= 112.5)
return "north";
else if (angle > 112.5 && angle <= 157.5)
return "northwest";
else if (angle > 157.5 && angle <= 202.5)
return "west";
else if (angle > 202.5 && angle <= 247.5)
return "southwest";
else if (angle > 247.5 && angle <= 292.5)
return "south";
else if (angle > 292.5 && angle <= 337.5)
return "southeast";
return "east";
}
string NavigatorImpl::getTurnDirection(double angle) const {
if (angle < 180)
return "left";
else
return "right";
}
bool NavigatorImpl::loadMapData(string mapFile)
{
MapLoader ml;
if (ml.load(mapFile)) {
am.init(ml);
sm.init(ml);
return true;
}
return false;// This compiles, but may not be correct
}
NavResult NavigatorImpl::navigate(string start, string end, vector<NavSegment> &directions) const
{
//A*
MyMap<GeoCoord, Node> closed;
priority_queue<Node> open;
GeoCoord begin;
GeoCoord dest;
if (!am.getGeoCoord(start, begin))
return NAV_BAD_SOURCE;
if (!am.getGeoCoord(end, dest))
return NAV_BAD_DESTINATION;
//push starting coord onto open and closed lists
Node first(begin, dest, nullptr, 0);
open.push(first);
closed.associate(first.m_cur, first);
if (first.m_cur == dest)
return NAV_SUCCESS;
while (!open.empty()) {
Node current = open.top();
open.pop();
//found a path of geocoords -> create vector of streetsegments -> create vector of navsegments
if (current.m_cur == dest) {
closed.associate(current.m_cur, current);
cerr << closed.find(dest)->path.size() << endl;
vector<GeoCoord> gcPath = closed.find(dest)->path;
vector<StreetSegment> correctStreetSegs;
// for (int i = 0; i < gcPath.size(); i++) {
// cerr << gcPath[i].latitudeText << ", " << gcPath[i].longitudeText << endl;
// }
for (int j = 0; j < gcPath.size()-1; j++) {
vector<StreetSegment> streetSegs = sm.getSegments(closed.find(dest)->path.at(j));
for (int k = 0; k < streetSegs.size(); k++) {
//if the start and end geocoords of the street segment are equal to two consecutive geocoords in the path
//we found the correct street segment
if ((streetSegs[k].segment.start == gcPath[j+1] && streetSegs[k].segment.end == gcPath[j]) ||
(streetSegs[k].segment.start == gcPath[j] && streetSegs[k].segment.end == gcPath[j+1])) {
cerr << "lol";
StreetSegment temp;
temp.segment.start = gcPath[j];
temp.segment.end = gcPath[j+1];
temp.streetName = streetSegs[k].streetName;
correctStreetSegs.push_back(temp);
break;
}
//loop through attractions to see if the start/end attractions are in the middle of a street
for (int l = 0; l < streetSegs[k].attractions.size(); l++) {
if ((gcPath[j] == streetSegs[k].attractions[l].geocoordinates && gcPath[j+1] == streetSegs[k].segment.end) ||
(gcPath[j] == streetSegs[k].attractions[l].geocoordinates && gcPath[j+1] == streetSegs[k].segment.start) ||
(gcPath[j+1] == streetSegs[k].attractions[l].geocoordinates && gcPath[j] == streetSegs[k].segment.end) ||
(gcPath[j+1] == streetSegs[k].attractions[l].geocoordinates && gcPath[j] == streetSegs[k].segment.start)) {
cerr << "lol";
StreetSegment temp;
temp.segment.start = gcPath[j];
temp.segment.end = gcPath[j+1];
temp.streetName = streetSegs[k].streetName;
correctStreetSegs.push_back(temp);
break;
}
}
}
}
//push first direction onto vector
//if (correctStreetSegs.size() > 0) {
string firstDirection = getDirection(angleOfLine(correctStreetSegs[0].segment));
directions.push_back(NavSegment(firstDirection, correctStreetSegs[0].streetName, distanceEarthMiles(correctStreetSegs[0].segment.start, correctStreetSegs[0].segment.end), correctStreetSegs[0].segment));
//}
//loop thru rest of street segments
for (int l = 1; l < correctStreetSegs.size(); l++) {
string dir = getDirection(angleOfLine(correctStreetSegs[l].segment));
double dist = distanceEarthMiles(correctStreetSegs[l].segment.start, correctStreetSegs[l].segment.end);
if (correctStreetSegs[l].streetName == correctStreetSegs[l-1].streetName)
directions.push_back(NavSegment(dir, correctStreetSegs[l].streetName, dist, correctStreetSegs[l].segment));
else {
directions.push_back(NavSegment(getTurnDirection(angleBetween2Lines(correctStreetSegs[l-1].segment, correctStreetSegs[l].segment)), correctStreetSegs[l].streetName));
directions.push_back(NavSegment(dir, correctStreetSegs[l].streetName, dist, correctStreetSegs[l].segment));
}
}
for (int x = 0; x < directions.size(); x++) {
cerr << directions[x].m_streetName << endl;
cerr << directions[x].m_direction << endl;
cerr << directions[x].m_distance << endl;
}
//
cerr << "success" << endl;
return NAV_SUCCESS;
}
vector<StreetSegment> streets = sm.getSegments(current.m_cur);
for (int i = 0; i < streets.size(); i++) {
GeoCoord gc;
GeoCoord gc2;
bool isThereGc2 = false;
if (streets[i].segment.end == current.m_cur)
gc = streets[i].segment.start;
else if (streets[i].segment.start == current.m_cur)
gc = streets[i].segment.end;
else {
gc = streets[i].segment.start;
gc2 = streets[i].segment.end;
isThereGc2 = true;
}
//check attractions in case attraction destination is in the middle of the street
vector<Attraction> a = streets[i].attractions;
for (int j = 0; j < a.size(); j++) {
if (a[j].geocoordinates == dest)
gc = a[j].geocoordinates;
}
Node neighbor(gc, dest, ¤t, current.g + distanceEarthMiles(gc, current.m_cur));
if (closed.find(neighbor.m_cur) == nullptr || (closed.find(neighbor.m_cur) != nullptr &&
neighbor.f < closed.find(neighbor.m_cur)->f))
open.push(neighbor);
if (isThereGc2)
open.push(Node(gc2, dest, ¤t, current.g + distanceEarthMiles(gc2, current.m_cur)));
closed.associate(current.m_cur, current);
}
}
return NAV_NO_ROUTE;
}
//******************** Navigator functions ************************************
// These functions simply delegate to NavigatorImpl's functions.
// You probably don't want to change any of this code.
Navigator::Navigator()
{
m_impl = new NavigatorImpl;
}
Navigator::~Navigator()
{
delete m_impl;
}
bool Navigator::loadMapData(string mapFile)
{
return m_impl->loadMapData(mapFile);
}
NavResult Navigator::navigate(string start, string end, vector<NavSegment>& directions) const
{
return m_impl->navigate(start, end, directions);
}
| [
"katiecai@g.ucla.edu"
] | katiecai@g.ucla.edu |
f755445951474a6ee0a31b6be7648a7779e11d7c | b4828cf9403fedde5dd346b3338a5f4bf0f1eb96 | /codeforces_sol/B-Vanya_and_Lanterns.cpp | 0661110efd8633ad95e532f4e24c7e19e01beffa | [] | no_license | Masters-Akt/CS_codes | 9ab3d87ca384ebd364c7b87c8da94b753082a7e3 | 1aaa107439f2e208bb67b0bcca676f90b6bc6a11 | refs/heads/master | 2023-01-24T00:11:05.151592 | 2023-01-21T18:45:57 | 2023-01-21T18:45:57 | 292,529,160 | 6 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 476 | cpp | #include <bits/stdc++.h>
using namespace std;
int main() {
// your code goes here
int n;
long long int l;
cin>>n>>l;
double a[n];
for(int i=0;i<n;i++){
cin>>a[i];
}
sort(a, a+n);
// for(int i=0;i<n;i++) cout<<a[i]<<" ";
// cout<<"\n";
double m=0;
if(a[0]>m) m=a[0];
if(l-a[n-1]>m) m=l-a[n-1];
for(int i=1;i<n;i++){
if((a[i]-a[i-1])/2>m) m = (a[i]-a[i-1])/2;
// printf("%.10f ",(a[i]-a[i-1])/2);
}
// cout<<"\n";
printf("%.10f",m);
return 0;
}
| [
"64123046+Masters-Akt@users.noreply.github.com"
] | 64123046+Masters-Akt@users.noreply.github.com |
ce226b28bc80e700d084e00192f7e18199871d82 | 83d04e85b76463d6ae12e03db7e998ab89da6a44 | /C++/1330.cpp | 741447068fbf7172dc13f6f41fa4892d84d8d6eb | [] | no_license | tunde02/Algorithms | d10856b704ba8863db40a686d15d3c1a03639cba | ec81db5de25f9b5732a67c925305b3edfefb7be4 | refs/heads/main | 2023-08-03T18:59:22.738786 | 2023-07-29T14:04:14 | 2023-07-29T14:04:14 | 207,979,167 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 192 | cpp | #include <iostream>
using namespace std;
int a, b;
int main() {
cin >> a >> b;
if(a > b) {
cout << ">";
}
else if(a == b) {
cout << "==";
}
else {
cout << "<";
}
return 0;
}
| [
"snskrktja@naver.com"
] | snskrktja@naver.com |
d0839a1c5979eac2ea688f3d8f1391e97155d0ca | 5c0cde9516179e199beda1104a329b252c7684b7 | /Graphics/Middleware/QT/include/QtPrintSupport/qprintengine.h | 2abf3dda74beff151f31cba1f0251d6f8ccdf307 | [] | no_license | herocrx/OpenGLMatrices | 3f8ff924e7160e76464d9480af7cf5652954622b | ca532ebba199945813a563fe2fbadc2f408e9f4b | refs/heads/master | 2021-05-07T08:28:21.614604 | 2017-12-17T19:45:40 | 2017-12-17T19:45:40 | 109,338,861 | 0 | 0 | null | 2017-12-17T19:45:41 | 2017-11-03T01:47:27 | HTML | UTF-8 | C++ | false | false | 3,445 | h | /****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#ifndef QPRINTENGINE_H
#define QPRINTENGINE_H
#include <QtCore/qvariant.h>
#include <QtPrintSupport/qprinter.h>
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
#ifndef QT_NO_PRINTER
class Q_PRINTSUPPORT_EXPORT QPrintEngine
{
public:
virtual ~QPrintEngine() {}
enum PrintEnginePropertyKey {
PPK_CollateCopies,
PPK_ColorMode,
PPK_Creator,
PPK_DocumentName,
PPK_FullPage,
PPK_NumberOfCopies,
PPK_Orientation,
PPK_OutputFileName,
PPK_PageOrder,
PPK_PageRect,
PPK_PageSize,
PPK_PaperRect,
PPK_PaperSource,
PPK_PrinterName,
PPK_PrinterProgram,
PPK_Resolution,
PPK_SelectionOption,
PPK_SupportedResolutions,
PPK_WindowsPageSize,
PPK_FontEmbedding,
PPK_Duplex,
PPK_PaperSources,
PPK_CustomPaperSize,
PPK_PageMargins,
PPK_CopyCount,
PPK_SupportsMultipleCopies,
PPK_PaperSize = PPK_PageSize,
PPK_CustomBase = 0xff00
};
virtual void setProperty(PrintEnginePropertyKey key, const QVariant &value) = 0;
virtual QVariant property(PrintEnginePropertyKey key) const = 0;
virtual bool newPage() = 0;
virtual bool abort() = 0;
virtual int metric(QPaintDevice::PaintDeviceMetric) const = 0;
virtual QPrinter::PrinterState printerState() const = 0;
};
#endif // QT_NO_PRINTER
QT_END_NAMESPACE
QT_END_HEADER
#endif // QPRINTENGINE_H
| [
"hubertkuc13@gmail.com"
] | hubertkuc13@gmail.com |
975fe2f9bf6b60ea0810bf8f35e8153176d0527c | 304dcc859ff1bad63ae881a096e687f7dc3de04b | /Test_PC_Poker/UPGCommon/src/Community/BlackBuddyAddDlg.cpp | 54a509bebc15978cea22ef39debc01063746a7ff | [] | no_license | idh37/testrepo | 03e416b115563cf62a4436f7a278eda2cd05d115 | b07cdd22bd42356522a599963f031a6294e14065 | refs/heads/master | 2020-07-11T00:57:34.526556 | 2019-09-10T07:22:35 | 2019-09-10T07:22:35 | 204,413,346 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 6,329 | cpp | #include "stdafx.h"
#include "BlackBuddyAddDlg.h"
#include "BlackBuddyAddDlgID.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
CBlackBuddyAddDlg::CBlackBuddyAddDlg(CWnd* pParent/* = NULL*/)
: LSY::CLSYLibDialogBase(pParent),
m_pWndBack(NULL),
m_pTxtResult(NULL),
m_pEditBlackBuddyIDorNickName(NULL),
m_pBtnAddBlackBuddy(NULL),
m_pBtnCancelBlackBuddy(NULL),
m_pBtnClose(NULL),
m_pBtnOK(NULL),
m_pBtnCancel(NULL)
{
}
BEGIN_MESSAGE_MAP(CBlackBuddyAddDlg, LSY::CLSYLibDialogBase)
END_MESSAGE_MAP()
INT_PTR CBlackBuddyAddDlg::DoModal(BLACKBUDDYADDDLGTYPE nType, std::string strMessage, CWnd *pParent)
{
m_pParentWnd = pParent;
m_nStartType = nType;
m_nCurType = nType;
m_strMessage = strMessage;
return CLSYLibDialogBase::DoModal(GetObjectMan(), ID_BLACKLISTADD);
}
bool CBlackBuddyAddDlg::OnCreatedProject(void)
{
LSY::CObjectProject *pProject = m_pObjectMan->GetProjectFromID(m_nID);
m_pWndBack = (LSY::CWindows *)pProject->GetMainObject();
m_pTxtResult = (LSY::CText *)GetObject(ID_BLACKLISTADD_TXT_USERLIST_ADD);
m_pTxtResult->SetText(m_strMessage);
m_pEditBlackBuddyIDorNickName = (LSY::CEdit *)GetObject(ID_BLACKLISTADD_EDIT_BLACKLIST_NICKNAME);
m_pEditBlackBuddyIDorNickName->SetText("");
m_pBtnAddBlackBuddy = (LSY::CButton *)GetObject(ID_BLACKLISTADD_BTN_ADD_BLACKLIST);
m_pBtnAddBlackBuddy->AddHandler(LSY::EM_O_MOUSELCLICK, LSY::Fnt(this, &CBlackBuddyAddDlg::OnClickButton));
m_pBtnCancelBlackBuddy = (LSY::CButton *)GetObject(ID_BLACKLISTADD_BTN_CANCEL_BLACKLIST);
m_pBtnCancelBlackBuddy->AddHandler(LSY::EM_O_MOUSELCLICK, LSY::Fnt(this, &CBlackBuddyAddDlg::OnClickButton));
m_pBtnOK = (LSY::CButton *)GetObject(ID_BLACKLISTADD_BTN_OK);
m_pBtnOK->AddHandler(LSY::EM_O_MOUSELCLICK, LSY::Fnt(this, &CBlackBuddyAddDlg::OnClickButton));
m_pBtnCancel = (LSY::CButton *)GetObject(ID_BLACKLISTADD_BTN_CANCEL);
m_pBtnCancel->AddHandler(LSY::EM_O_MOUSELCLICK, LSY::Fnt(this, &CBlackBuddyAddDlg::OnClickButton));
m_pBtnClose = (LSY::CButton *)GetObject(ID_BLACKLISTADD_BTN_CLOSE);
m_pBtnClose->AddHandler(LSY::EM_O_MOUSELCLICK, LSY::Fnt(this, &CBlackBuddyAddDlg::OnClickButton));
m_pObjectMan->SetFocus(m_pEditBlackBuddyIDorNickName);
SetCurType(m_nStartType);
return TRUE;
}
void CBlackBuddyAddDlg::SetCurType(BLACKBUDDYADDDLGTYPE nType)
{
switch(nType)
{
case BBADT_EDIT:
m_pWndBack->SetIndex(2);
m_pTxtResult->SetShow(false);
m_pEditBlackBuddyIDorNickName->SetShow(true);
m_pBtnAddBlackBuddy->SetShow(true);
m_pBtnCancelBlackBuddy->SetShow(true);
m_pBtnOK->SetShow(false);
m_pBtnCancel->SetShow(false);
m_pBtnClose->SetShow(false);
break;
case BBADT_QUESTION:
m_pWndBack->SetIndex(1);
m_pTxtResult->SetShow(true);
m_pTxtResult->SetText("블랙리스트에 추가 하시겠습니까?");
m_pEditBlackBuddyIDorNickName->SetShow(false);
m_pBtnAddBlackBuddy->SetShow(false);
m_pBtnCancelBlackBuddy->SetShow(false);
m_pBtnOK->SetShow(true);
m_pBtnCancel->SetShow(true);
m_pBtnClose->SetShow(false);
break;
case BBADT_MESSAGE:
m_pWndBack->SetIndex(1);
m_pTxtResult->SetShow(true);
m_pEditBlackBuddyIDorNickName->SetShow(false);
m_pBtnAddBlackBuddy->SetShow(false);
m_pBtnCancelBlackBuddy->SetShow(false);
m_pBtnOK->SetShow(false);
m_pBtnCancel->SetShow(false);
m_pBtnClose->SetShow(true);
break;
}
m_nCurType = nType;
}
LRESULT CBlackBuddyAddDlg::OnClickButton(LSY::CMessage *pMsg)
{
LSY::CObjectMessage *msg = (LSY::CObjectMessage *)pMsg;
switch(msg->GetObject()->GetID())
{
case ID_BLACKLISTADD_BTN_ADD_BLACKLIST:
{
CString strName = m_pEditBlackBuddyIDorNickName->GetText().c_str();
strName.Trim();
if(strName == "")
{
m_pTxtResult->SetText("블랙리스트에 추가할 닉네임/아이디를 입력해주세요.");
SetCurType(BBADT_MESSAGE);
}
else if(CCommunityManager::Instance()->IsConnect())
{
if(CCommunityManager::Instance()->GetMyID() == strName.GetString() || CCommunityManager::Instance()->GetMyNickName() == strName.GetString())
{
m_pTxtResult->SetText("자기 자신을 블랙리스트에 추가할 수 없습니다.");
SetCurType(BBADT_MESSAGE);
}
else
{
SetCurType(BBADT_QUESTION);
}
}
else
{
m_pTxtResult->SetText("커뮤니티 서버에 연결되어 있지 않아 블랙리스트에 추가할 수 없습니다.");
SetCurType(BBADT_MESSAGE);
}
}
break;
case ID_BLACKLISTADD_BTN_CANCEL_BLACKLIST:
OnCancel();
break;
case ID_BLACKLISTADD_BTN_OK:
if(m_nStartType == BBADT_EDIT)
{
CString strName = m_pEditBlackBuddyIDorNickName->GetText().c_str();
strName.Trim();
list<std::string> listNickName;
listNickName.push_back(strName.GetString());
CCommunityManager::Instance()->SendGetUserInfo(CCommunityUserInfo::ECUIT_ADDBLACKLIST, NULL, listNickName, "");
}
OnOK();
break;
case ID_BLACKLISTADD_BTN_CANCEL:
if(m_nStartType == BBADT_EDIT)
{
SetCurType(BBADT_EDIT);
}
else
{
OnCancel();
}
break;
case ID_BLACKLISTADD_BTN_CLOSE:
if(m_nStartType == BBADT_MESSAGE)
{
OnCancel();
}
else
{
SetCurType(BBADT_EDIT);
}
break;
}
return TRUE;
}
bool CBlackBuddyAddDlg::OnAddGroup(const std::string &strName)
{
return CCommunityManager::Instance()->SendBuddyGroupAdd(strName);
}
BOOL CBlackBuddyAddDlg::PreTranslateMessage(MSG* pMsg)
{
if(m_pObjectMan)
{
switch(pMsg->message)
{
case WM_SYSKEYDOWN:
switch(pMsg->wParam)
{
case VK_F4:
if((GetKeyState(VK_LMENU) & 0xff00) && (m_nStartType == BBADT_EDIT) && (m_nCurType == BBADT_QUESTION))
{
SetCurType(BBADT_EDIT);
return TRUE;
}
break;
}
break;
case WM_KEYDOWN:
switch(pMsg->wParam)
{
case VK_RETURN:
switch(m_nCurType)
{
case BBADT_EDIT:
{
LSY::CMO_MouseLClick msg(m_pBtnAddBlackBuddy, m_pBtnAddBlackBuddy->GetPos());
OnClickButton(&msg);
}
return TRUE;
case BBADT_QUESTION:
{
LSY::CMO_MouseLClick msg(m_pBtnOK, m_pBtnOK->GetPos());
OnClickButton(&msg);
}
return TRUE;
}
break;
case VK_ESCAPE:
if((m_nStartType == BBADT_EDIT) && (m_nCurType == BBADT_QUESTION))
{
SetCurType(BBADT_EDIT);
return TRUE;
}
break;
}
break;
}
}
return __super::PreTranslateMessage(pMsg);
} | [
"idh37@nm-4ones.com"
] | idh37@nm-4ones.com |
13786c3a61c242a91a5d523a6a8a14c16ed8aa5f | 92fc392b5e3b7517ea7535fa6986aa63cd204b8c | /CaptureGifEncoder/GifEncoder.cpp | 4c9642b733c7e17dad68a2eea439bc6ee1243399 | [
"MIT"
] | permissive | robmikh/CaptureGifEncoder | 1709bb45a10079d8f01894908af3863a5e546daa | 005771f83a36cf3b6a9549a1887cd51634dfd8f2 | refs/heads/master | 2023-01-12T09:05:03.069616 | 2022-12-27T01:52:13 | 2022-12-27T01:52:13 | 245,104,898 | 23 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 8,033 | cpp | #include "pch.h"
#include "GifEncoder.h"
namespace winrt
{
using namespace Windows::Graphics;
using namespace Windows::Graphics::Capture;
using namespace Windows::Storage::Streams;
}
namespace util
{
using namespace robmikh::common::uwp;
}
GifEncoder::GifEncoder(
winrt::com_ptr<ID3D11Device> const& d3dDevice,
winrt::com_ptr<ID3D11DeviceContext> const& d3dContext,
winrt::com_ptr<ID2D1Device> const& d2dDevice,
winrt::com_ptr<IWICImagingFactory2> const& wicFactory,
winrt::IRandomAccessStream const& stream,
winrt::SizeInt32 gifSize)
{
m_gifSize = gifSize;
m_d3dDevice = d3dDevice;
winrt::check_hresult(d2dDevice->CreateDeviceContext(D2D1_DEVICE_CONTEXT_OPTIONS_NONE, m_d2dContext.put()));
auto abiStream = util::CreateStreamFromRandomAccessStream(stream);
// Setup WIC to encode a gif
winrt::check_hresult(wicFactory->CreateEncoder(GUID_ContainerFormatGif, nullptr, m_encoder.put()));
winrt::check_hresult(m_encoder->Initialize(abiStream.get(), WICBitmapEncoderNoCache));
winrt::check_hresult(wicFactory->CreateImageEncoder(d2dDevice.get(), m_imageEncoder.put()));
// Write the application block
// http://www.vurdalakov.net/misc/gif/netscape-looping-application-extension
winrt::com_ptr<IWICMetadataQueryWriter> metadata;
winrt::check_hresult(m_encoder->GetMetadataQueryWriter(metadata.put()));
{
PROPVARIANT value = {};
value.vt = VT_UI1 | VT_VECTOR;
value.caub.cElems = 11;
std::string text("NETSCAPE2.0");
std::vector<uint8_t> chars(text.begin(), text.end());
WINRT_VERIFY(chars.size() == 11);
value.caub.pElems = chars.data();
winrt::check_hresult(metadata->SetMetadataByName(L"/appext/application", &value));
}
{
PROPVARIANT value = {};
value.vt = VT_UI1 | VT_VECTOR;
value.caub.cElems = 5;
// The first value is the size of the block, which is the fixed value 3.
// The second value is the looping extension, which is the fixed value 1.
// The third and fourth values comprise an unsigned 2-byte integer (little endian).
// The value of 0 means to loop infinitely.
// The final value is the block terminator, which is the fixed value 0.
std::vector<uint8_t> data({ 3, 1, 0, 0, 0 });
value.caub.pElems = data.data();
winrt::check_hresult(metadata->SetMetadataByName(L"/appext/data", &value));
}
// Setup our frame compositor and texture differ
m_frameCompositor = std::make_unique<FrameCompositor>(d3dDevice, d3dContext, gifSize);
m_textureDiffer = std::make_unique<TextureDiffer>(d3dDevice, d3dContext, gifSize);
}
bool GifEncoder::ProcessFrame(winrt::Direct3D11CaptureFrame const& frame)
{
auto timeStamp = frame.SystemRelativeTime();
auto firstFrame = false;
// Compute frame delta
if (m_lastTimeStamp.count() == 0)
{
m_lastTimeStamp = timeStamp;
firstFrame = true;
}
auto timeStampDelta = timeStamp - m_lastTimeStamp;
// Throttle frame processing to 30fps
if (!firstFrame && timeStampDelta < std::chrono::milliseconds(33))
{
return false;
}
m_lastCandidateTimeStamp = timeStamp;
auto composedFrame = m_frameCompositor->ProcessFrame(frame);
return ProcessFrame(composedFrame, false);
}
void GifEncoder::StopEncoding()
{
// Repeat the last frame
auto composedFrame = m_frameCompositor->RepeatFrame(m_lastCandidateTimeStamp);
ProcessFrame(composedFrame, true);
winrt::check_hresult(m_encoder->Commit());
}
bool GifEncoder::ProcessFrame(ComposedFrame const& composedFrame, bool force)
{
bool updated = false;
auto diff = m_textureDiffer->ProcessFrame(composedFrame.Texture);
if (force && !diff.has_value())
{
// Since there's no change, pick a small random part of the frame.
diff = std::optional(DiffRect{ 0, 0, 5, 5 });
}
if (auto diffRect = diff)
{
auto timeStampDelta = composedFrame.SystemRelativeTime - m_lastTimeStamp;
m_lastTimeStamp = composedFrame.SystemRelativeTime;
// Inflate our rect to eliminate artifacts
auto inflateAmount = 1;
auto left = static_cast<uint32_t>(std::max(static_cast<int32_t>(diffRect->Left) - inflateAmount, 0));
auto top = static_cast<uint32_t>(std::max(static_cast<int32_t>(diffRect->Top) - inflateAmount, 0));
auto right = static_cast<uint32_t>(std::min(static_cast<int32_t>(diffRect->Right) + inflateAmount, m_gifSize.Width));
auto bottom = static_cast<uint32_t>(std::min(static_cast<int32_t>(diffRect->Bottom) + inflateAmount, m_gifSize.Height));
// Create the frame
auto textureCopy = util::CopyD3DTexture(m_d3dDevice, composedFrame.Texture, false);
auto frame = std::make_shared<GifFrameImage>(textureCopy, DiffRect { left, top, right, bottom }, composedFrame.SystemRelativeTime);
// Encode the frame
m_previousFrame.swap(frame);
if (frame != nullptr)
{
auto currentTime = composedFrame.SystemRelativeTime;
if (force)
{
currentTime += timeStampDelta;
}
EncodeFrame(frame, currentTime);
}
updated = true;
}
return updated;
}
void GifEncoder::EncodeFrame(std::shared_ptr<GifFrameImage> const& frame, winrt::Windows::Foundation::TimeSpan const& currentTime)
{
auto diffWidth = frame->Rect.Right - frame->Rect.Left;
auto diffHeight = frame->Rect.Bottom - frame->Rect.Top;
auto frameDuration = currentTime - frame->TimeStamp;
// Compute the frame delay
auto millisconds = std::chrono::duration_cast<std::chrono::milliseconds>(frameDuration);
// Use 10ms units
auto frameDelay = millisconds.count() / 10;
// Create a D2D bitmap
winrt::com_ptr<ID2D1Bitmap1> d2dBitmap;
winrt::check_hresult(m_d2dContext->CreateBitmapFromDxgiSurface(frame->Texture.as<IDXGISurface>().get(), nullptr, d2dBitmap.put()));
// Setup our WIC frame (note the matching pixel format)
winrt::com_ptr<IWICBitmapFrameEncode> wicFrame;
winrt::check_hresult(m_encoder->CreateNewFrame(wicFrame.put(), nullptr));
winrt::check_hresult(wicFrame->Initialize(nullptr));
auto wicPixelFormat = GUID_WICPixelFormat32bppBGRA;
winrt::check_hresult(wicFrame->SetPixelFormat(&wicPixelFormat));
// Write frame metadata
winrt::com_ptr<IWICMetadataQueryWriter> metadata;
winrt::check_hresult(wicFrame->GetMetadataQueryWriter(metadata.put()));
// Delay
{
PROPVARIANT delayValue = {};
delayValue.vt = VT_UI2;
delayValue.uiVal = static_cast<unsigned short>(frameDelay);
winrt::check_hresult(metadata->SetMetadataByName(L"/grctlext/Delay", &delayValue));
}
// Left
{
PROPVARIANT metadataValue = {};
metadataValue.vt = VT_UI2;
metadataValue.uiVal = static_cast<unsigned short>(frame->Rect.Left);
winrt::check_hresult(metadata->SetMetadataByName(L"/imgdesc/Left", &metadataValue));
}
// Top
{
PROPVARIANT metadataValue = {};
metadataValue.vt = VT_UI2;
metadataValue.uiVal = static_cast<unsigned short>(frame->Rect.Top);
winrt::check_hresult(metadata->SetMetadataByName(L"/imgdesc/Top", &metadataValue));
}
// Write the frame to our image (this must come after you write the metadata)
WICImageParameters frameParams = {};
frameParams.PixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM;
frameParams.PixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;
frameParams.DpiX = 96.0f;
frameParams.DpiY = 96.0f;
frameParams.Left = static_cast<float>(frame->Rect.Left);
frameParams.Top = static_cast<float>(frame->Rect.Top);
frameParams.PixelWidth = diffWidth;
frameParams.PixelHeight = diffHeight;
winrt::check_hresult(m_imageEncoder->WriteFrame(d2dBitmap.get(), wicFrame.get(), &frameParams));
winrt::check_hresult(wicFrame->Commit());
}
| [
"rob.mikh@outlook.com"
] | rob.mikh@outlook.com |
1ba61cb52b4bbd5c2eeb157c2afb410f1b00b569 | e48b2ede55e28c6142d6452d8fbe68686134b141 | /src/AudioConfigIIRFilterBank_F32.cpp | 2342ec6676a5b33b460aa5269030c1d0c8d36e6b | [
"MIT"
] | permissive | kxm-creare/Tympan_Library | b33c0f53c6cf105f1a3bac1d41dbee24ee680a29 | 4fc9206b5040cf934d2cdbdc37dc5872814546f2 | refs/heads/master | 2021-06-29T16:10:46.589723 | 2021-06-11T17:50:52 | 2021-06-11T17:50:52 | 130,901,324 | 0 | 0 | MIT | 2021-06-11T17:56:19 | 2018-04-24T19:02:44 | HTML | UTF-8 | C++ | false | false | 15,622 | cpp | /*
* iir_filterbank.cpp
*
* Created: Chip Audette, Creare LLC, May 2020
* Primarly built upon CHAPRO "Generic Hearing Aid" from
* Boys Town National Research Hospital (BTNRH): https://github.com/BTNRH/chapro
*
* License: MIT License. Use at your own risk.
*
*/
#include "AudioConfigIIRFilterBank_F32.h"
#include "utility/BTNRH_iir_filterbank.h"
#ifndef fmove
#define fmove(x,y,n) memmove(x,y,(n)*sizeof(float))
#endif
#ifndef fcopy
#define fcopy(x,y,n) memcpy(x,y,(n)*sizeof(float))
#endif
#ifndef fzero
#define fzero(x,n) memset(x,0,(n)*sizeof(float))
#endif
/*
iir_filterbank_basic : design a bank of IIR filters with a smooth transition between each
b = Output: filter "b" coefficients. float[N_CHAN][N_IIR+1]
a = Output: filter "a" coefficients. float[N_CHAN][N_IIR+1]
cv = Input: cross-over frequencies (Hz) between filters. float[N_CHAN-1]
nc = Input: number of channels (number of filters)
n_iir = Input: order of each IIR filter (1 <= N <= 8)
sr = Input: Sample rate (Hz)
*/
int AudioConfigIIRFilterBank_F32::iir_filterbank_basic(float *b, float *a, float *cf, const int nc, const int n_iir, const float sr) {
//Serial.print("AudioConfigIIRFilterBank: iir_filterbank: nw_orig = "); Serial.print(nw_orig);
//Serial.print(", nw = "); Serial.println(nw);
if (n_iir < 1) {
Serial.println("AudioConfigIIRFilterBank: iir_filterbank: *** ERROR *** filter order must be at least 1.");
return -1;
}
if (n_iir > 8) {
Serial.println("AudioConfigIIRFilterBank: iir_filterbank: *** ERROR *** filter order must be <= 8.");
return -1;
}
//allocate some memory
float *z = (float *) calloc(nc*(n_iir*2), sizeof(float)); //z is complex, so needs to be twice as long
float *p = (float *) calloc(nc*(n_iir*2), sizeof(float)); //p is complex, so needs to be twice as long
float *g = (float *) calloc(nc, sizeof(float));
//design filterbank, zeros and poles and gains
//Serial.println("cha_iirfb_design: calling iirfb_zp...");delay(500);
int nz = n_iir; //the CHA code from BTNRH uses this notation
iirfb_zp(z, //filter zeros. pointer to array float[64]
p, //filter poles. pointer to array float[64]
g, //gain for each filter. pointer to array float[8]
cf, //pointer to cutoff frequencies, float[7]
sr, //sample rate (Hz)
nc, //number of channels (8)
nz); //filter order. (4)
//change representation from pole-zero to transfer function
zp2ba_fb(z,p,nz,nc,b,a);
//apply the gain to the b coefficients
for (int Ichan = 0; Ichan < nc; Ichan++) {
for (int Icoeff = 0; Icoeff < n_iir+1; Icoeff++) {
b[Ichan*(nz+1)+Icoeff] *= g[Ichan];
}
}
return 0;
}
/*
iir_filterbank : design a bank of IIR filters with a smooth transition between each.
Also, it computes the best delay for each filter to time-align the inpulse responses.
Also, it computes the best gain per band to equlibrate their responses, depsite overlaping coverage.
Arguments:
b = Output: filter "b" coefficients. float[N_CHAN][N_IIR+1]
a = Output: filter "a" coefficients. float[N_CHAN][N_IIR+1]
d = Output: filter delay (samples) to align impulse respsones. int[N_CHAN]
cv = Input: cross-over frequencies (Hz) between filters. float[N_CHAN-1]
nc = Input: number of channels (number of filters)
n_iir = Input: order of each IIR filter (1 <= N <= 8)
sr = Input: Sample rate (Hz)
td = Input: max time delay (mseconds) allowed for aligning the impulse response of the filters
*/
int AudioConfigIIRFilterBank_F32::iir_filterbank(float *b, float *a, int *d, float *cf, const int nc, const int n_iir, const float sr, const float td) {
if (n_iir < 1) {
Serial.println("AudioConfigIIRFilterBank: iir_filterbank: *** ERROR *** filter order must be at least 1.");
return -1;
}
if (n_iir > 8) {
Serial.println("AudioConfigIIRFilterBank: iir_filterbank: *** ERROR *** filter order must be <= 8.");
return -1;
}
//allocate some memory
float *z = (float *) calloc(nc*n_iir*2,sizeof(float)); //z is complex, so needs to be twice as long
float *p = (float *) calloc(nc*n_iir*2,sizeof(float)); //p i scomplex, so needs to be twice as long
float *g = (float *) calloc(nc, sizeof(float)); // gain is real
if (g==NULL) {
Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank: *** ERROR *** could not allocate memory.");
}
//Serial.print("AudioConfigIIRFilterBank_F32: iir_filterbank: allocated memory...FreeRAM(B) = ");
//Serial.println(FreeRam());
//design filterbank, zeros and poles and gains
int nz = n_iir; //the CHA code from BTNRH uses this notation
iirfb_zp(z, //filter zeros. pointer to array float[64]
p, //filter poles. pointer to array float[64]
g, //gain for each filter. pointer to array float[8]
cf, //pointer to cutoff frequencies, float[7]
sr, //sample rate (Hz)
nc, //number of channels (8)
nz); //filter order. (4)
#if 0
//plot zeros and poles and gains
Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank: orig zero-pole");
for (int Iband=0; Iband < nc; Iband++) {
Serial.print(" : Band "); Serial.print(Iband); Serial.print(", Gain = "); Serial.println(g[Iband],8);
Serial.print(" : Z: ");for (int i=0; i < 2*n_iir; i++) { Serial.print(z[(Iband*2*n_iir)+i],4); Serial.print(", ");}; Serial.println();
Serial.print(" : P: ");for (int i=0; i < 2*n_iir; i++) { Serial.print(p[(Iband*2*n_iir)+i],4); Serial.print(", ");}; Serial.println();
}
#endif
//adjust filter to time-align the peaks of the fiter response
align_peak_fb(z, //filter zeros. pointer to array float[64]
p, //filter poles. pointer to array float[64]
g, //gain for each filter. pointer to array float[8]
d, //delay for each filter (samples). pointer to array int[8]
td, //max time delay (msec?) for the filters?
sr, //sample rate (Hz)
nc, //number of channels
nz); //filter order (4)
int ret_val = 0;
if (0) {
//adjust gain of each filter (for flat response even during crossover?)
//WARNING: This operation takes a lot of RAM. If ret_val is -1, it failed.
ret_val = adjust_gain_fb(z, //filter zeros. pointer to array float[64]
p, //filter poles. pointer to array float[64]
g, //gain for each filter. pointer to array float[8]
d, //delay for each filter (samples). pointer to array int[8]
cf, //pointer to cutoff frequencies, float[7]
sr, //sample rate (Hz)
nc, //number of channels (8)
nz); //filter order (4)
if (ret_val < 0) {
Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank: *** ERROR *** failed (in adjust_gain_fb.");
}
}
#if 0
//plot zeros and poles and gains
Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank: prior to b-a conversion");
for (int Iband=0; Iband < nc; Iband++) {
Serial.print(" : Band "); Serial.print(Iband); Serial.print(", Gain = "); Serial.println(g[Iband],8);
Serial.print(" : Z: ");for (int i=0; i < 2*n_iir; i++) { Serial.print(z[(Iband*2*n_iir)+i],4); Serial.print(", ");}; Serial.println();
Serial.print(" : P: ");for (int i=0; i < 2*n_iir; i++) { Serial.print(p[(Iband*2*n_iir)+i],4); Serial.print(", ");}; Serial.println();
}
#endif
//change representation from pole-zero to transfer function
zp2ba_fb(z,p,nz,nc,b,a);
//print the coeff for debugging
//Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank: ");
//for (int Ichan = 0; Ichan < nc; Ichan++) {
// Serial.print("Band "); Serial.print(Ichan);Serial.print(", g = "); Serial.print(g[Ichan],5); Serial.print(", b");
// for (int Icoeff = 0; Icoeff < n_iir+1; Icoeff++) {
// Serial.print(", ");
// Serial.print(b[Ichan*(nz+1)+Icoeff],5);
// }
// Serial.println();
//}
//apply the gain to the b coefficients
for (int Ichan = 0; Ichan < nc; Ichan++) {
for (int Icoeff = 0; Icoeff < n_iir+1; Icoeff++) {
//if ((Ichan == 0) || (Ichan == nc-1)) { //really? only do it for the first and last? WEA 6/8/2020
b[Ichan*(nz+1)+Icoeff] *= g[Ichan];
//}
}
}
//Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank: post g*b: ");
//for (int Ichan = 0; Ichan < nc; Ichan++) {
// Serial.print("Band "); Serial.print(Ichan);Serial.print(", b");
// for (int Icoeff = 0; Icoeff < n_iir+1; Icoeff++) {
// Serial.print(", ");
// Serial.print(b[Ichan*(nz+1)+Icoeff],5);
// }
// Serial.println();
//}
//release the allocated memory
free(g);
free(p);
free(z);
return ret_val;
}
// Compute the filter coefficients as second-order-sections
/* What size is the SOS array?
* Each SOS is a biquad specified by 6 values (the three 'b' followed by the three 'a')
* For each filter, there are N_IIR/2 biquads. So, for N=6, there are 3 biquads.
* So, sos is [nchannels][nbiquads][6] => [nc][ceil(n_iir/2)][6]
*/
int AudioConfigIIRFilterBank_F32::iir_filterbank_sos(float *sos, int *d, float *cf, const int nc, const int n_iir, const float sr, const float td) {
if (n_iir < 1) {
Serial.println("AudioConfigIIRFilterBank: iir_filterbank_sos: *** ERROR *** filter order must be at least 1.");
return -1;
}
if (n_iir > 8) {
Serial.println("AudioConfigIIRFilterBank: iir_filterbank_sos: *** ERROR *** filter order must be <= 8.");
return -1;
}
if ( (n_iir % 2) != 0 ) {
Serial.println("AudioConfigIIRFilterBank: iir_filterbank_sos: *** ERROR *** filter order must be even to make SOS!");
return -1;
}
//allocate some memory
float *z = (float *) calloc(nc*n_iir*2,sizeof(float)); //z is complex, so needs to be twice as long
float *p = (float *) calloc(nc*n_iir*2,sizeof(float)); //p i scomplex, so needs to be twice as long
float *g = (float *) calloc(nc, sizeof(float)); // gain is real
if (g==NULL) {
Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank_sos: *** ERROR *** could not allocate memory.");
}
//Serial.print("AudioConfigIIRFilterBank_F32: iir_filterbank: allocated memory...FreeRAM(B) = ");
//Serial.println(FreeRam());
//design filterbank, zeros and poles and gains
Serial.println("AudioConfigIIRFilterBank_F32::iir_filterbank_sos: calling iirfb_zp()");
int nz = n_iir; //the CHA code from BTNRH uses this notation
iirfb_zp(z, //filter zeros. pointer to array float[64]
p, //filter poles. pointer to array float[64]
g, //gain for each filter. pointer to array float[8]
cf, //pointer to cutoff frequencies, float[7]
sr, //sample rate (Hz)
nc, //number of channels (8)
nz); //filter order. (4)
#if 0
//plot zeros and poles and gains
Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank_sos: orig zero-pole");
for (int Iband=0; Iband < nc; Iband++) {
Serial.print(" : Band "); Serial.print(Iband); Serial.print(", Gain = "); Serial.println(g[Iband],8);
Serial.print(" : Z: ");for (int i=0; i < 2*n_iir; i++) { Serial.print(z[(Iband*2*n_iir)+i],4); Serial.print(", ");}; Serial.println();
Serial.print(" : P: ");for (int i=0; i < 2*n_iir; i++) { Serial.print(p[(Iband*2*n_iir)+i],4); Serial.print(", ");}; Serial.println();
}
#endif
//adjust filter to time-align the peaks of the fiter response
Serial.println("AudioConfigIIRFilterBank_F32::iir_filterbank_sos: calling align_peak_fb()");
align_peak_fb(z, //filter zeros. pointer to array float[64]
p, //filter poles. pointer to array float[64]
g, //gain for each filter. pointer to array float[8]
d, //delay for each filter (samples). pointer to array int[8]
td, //max time delay (msec?) for the filters?
sr, //sample rate (Hz)
nc, //number of channels
nz); //filter order (4)
int ret_val = 0;
if (0) {
//adjust gain of each filter (for flat response even during crossover?)
//WARNING: This operation takes a lot of RAM. If ret_val is -1, it failed.
ret_val = adjust_gain_fb(z, //filter zeros. pointer to array float[64]
p, //filter poles. pointer to array float[64]
g, //gain for each filter. pointer to array float[8]
d, //delay for each filter (samples). pointer to array int[8]
cf, //pointer to cutoff frequencies, float[7]
sr, //sample rate (Hz)
nc, //number of channels (8)
nz); //filter order (4)
if (ret_val < 0) {
Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank_sos: *** ERROR *** failed (in adjust_gain_fb.");
}
}
#if 0
//plot zeros and poles and gains
Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank_sos: prior to b-a conversion");
for (int Iband=0; Iband < nc; Iband++) {
Serial.print(" : Band "); Serial.print(Iband); Serial.print(", Gain = "); Serial.println(g[Iband],8);
Serial.print(" : Z: ");for (int i=0; i < 2*n_iir; i++) { Serial.print(z[(Iband*2*n_iir)+i],4); Serial.print(", ");}; Serial.println();
Serial.print(" : P: ");for (int i=0; i < 2*n_iir; i++) { Serial.print(p[(Iband*2*n_iir)+i],4); Serial.print(", ");}; Serial.println();
}
#endif
//convert to second order sections
Serial.println("AudioConfigIIRFilterBank_F32::iir_filterbank_sos: converting to second order sections");
float bk[3], ak[3]; //each biquad is 3 b coefficients and 3 a coefficients
int out_ind ;
int n_biquad = nz / 2;
int n_coeff_per_biquad = 6;
float *zk, *pk;
for (int k=0; k < nc; k++) { //loop over filter bands
for (int Ibiquad = 0; Ibiquad < n_biquad; Ibiquad++) {
//convert zero-pole to transfer function
zk = z + (((k * n_biquad + Ibiquad)*2) * 2); //two zeros per biquad (that's the first *2). Each zero is a complex number (that's the second *2)
pk = p + (((k * n_biquad + Ibiquad)*2) * 2); //two poles per biquad (that's the first *2). Each pole is a complex number (that's the second *2)
int nz_foo = 2; //each biquad is 2nd order
zp2ba(zk,pk,nz_foo,bk,ak); //I think that this is in Tympan_Library\src\utility\BTNRH_iir_design.h
//apply gain to first coefficients only
if (Ibiquad==0) {
bk[0] *= g[k];
bk[1] *= g[k];
bk[2] *= g[k];
}
//accumulate in sos structure
out_ind = (k*n_biquad+Ibiquad)*n_coeff_per_biquad;
sos[out_ind+0] = bk[0];
sos[out_ind+1] = bk[1];
sos[out_ind+2] = bk[2];
sos[out_ind+3] = ak[0];
sos[out_ind+4] = ak[1];
sos[out_ind+5] = ak[2];
}
}
//print the SOS coeff for debugging
#if 0
Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank_sos: sos sections");
for (int Iband=0; Iband < nc; Iband++) {
Serial.print(" : Band "); Serial.print(Iband); Serial.println();
for (int Ibiquad=0; Ibiquad < n_biquad; Ibiquad++) {
out_ind = (Iband*n_biquad+Ibiquad)*n_coeff_per_biquad;
//Serial.print(" : sos "); Serial.print(Ibiquad); Serial.print(": ");
Serial.print(" ");
for (int i=0; i < n_coeff_per_biquad; i++) { Serial.print(sos[out_ind+i],7); Serial.print(", ");}; Serial.println();
}
}
#endif
//apply the gain to the b coefficients
//for (int Ichan = 0; Ichan < nc; Ichan++) {
// for (int Icoeff = 0; Icoeff < n_iir+1; Icoeff++) {
// //if ((Ichan == 0) || (Ichan == nc-1)) { //really? only do it for the first and last? WEA 6/8/2020
// b[Ichan*(nz+1)+Icoeff] *= g[Ichan];
// //}
// }
//}
//Serial.println("AudioConfigIIRFilterBank_F32: iir_filterbank: post g*b: ");
//for (int Ichan = 0; Ichan < nc; Ichan++) {
// Serial.print("Band "); Serial.print(Ichan);Serial.print(", b");
// for (int Icoeff = 0; Icoeff < n_iir+1; Icoeff++) {
// Serial.print(", ");
// Serial.print(b[Ichan*(nz+1)+Icoeff],5);
// }
// Serial.println();
//}
//release the allocated memory
Serial.println("AudioConfigIIRFilterBank_F32::iir_filterbank_sos: calling freeing memory");
free(g);
free(p);
free(z);
return ret_val;
}
| [
"chipaudette@yahoo.com"
] | chipaudette@yahoo.com |
a3161a696f06976f5cdf56940f749e1be38b1185 | 55f945f29f78c0c0c6ac110df808126a38999be5 | /devel/.private/mavros_msgs/include/mavros_msgs/RTCM.h | cbb34b1a8be801f6433a7ad02fdfd39339312ba2 | [] | no_license | aarchilla/NodeROS | 43e9f0d6931d1eb11057d229e20e2911fba943c2 | 4d79e3ffbbb19c11535613249fed2191ada63000 | refs/heads/master | 2020-06-16T20:00:39.218889 | 2019-07-07T18:36:17 | 2019-07-07T18:36:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,397 | h | // Generated by gencpp from file mavros_msgs/RTCM.msg
// DO NOT EDIT!
#ifndef MAVROS_MSGS_MESSAGE_RTCM_H
#define MAVROS_MSGS_MESSAGE_RTCM_H
#include <string>
#include <vector>
#include <map>
#include <ros/types.h>
#include <ros/serialization.h>
#include <ros/builtin_message_traits.h>
#include <ros/message_operations.h>
#include <std_msgs/Header.h>
namespace mavros_msgs
{
template <class ContainerAllocator>
struct RTCM_
{
typedef RTCM_<ContainerAllocator> Type;
RTCM_()
: header()
, data() {
}
RTCM_(const ContainerAllocator& _alloc)
: header(_alloc)
, data(_alloc) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef std::vector<uint8_t, typename ContainerAllocator::template rebind<uint8_t>::other > _data_type;
_data_type data;
typedef boost::shared_ptr< ::mavros_msgs::RTCM_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::mavros_msgs::RTCM_<ContainerAllocator> const> ConstPtr;
}; // struct RTCM_
typedef ::mavros_msgs::RTCM_<std::allocator<void> > RTCM;
typedef boost::shared_ptr< ::mavros_msgs::RTCM > RTCMPtr;
typedef boost::shared_ptr< ::mavros_msgs::RTCM const> RTCMConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::mavros_msgs::RTCM_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::mavros_msgs::RTCM_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace mavros_msgs
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True}
// {'geographic_msgs': ['/opt/ros/kinetic/share/geographic_msgs/cmake/../msg'], 'sensor_msgs': ['/opt/ros/kinetic/share/sensor_msgs/cmake/../msg'], 'std_msgs': ['/opt/ros/kinetic/share/std_msgs/cmake/../msg'], 'mavros_msgs': ['/home/esaii-admin/catkin_ws/src/mavros/mavros_msgs/msg'], 'geometry_msgs': ['/opt/ros/kinetic/share/geometry_msgs/cmake/../msg'], 'uuid_msgs': ['/opt/ros/kinetic/share/uuid_msgs/cmake/../msg']}
// !!!!!!!!!!! ['__class__', '__delattr__', '__dict__', '__doc__', '__eq__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_parsed_fields', 'constants', 'fields', 'full_name', 'has_header', 'header_present', 'names', 'package', 'parsed_fields', 'short_name', 'text', 'types']
template <class ContainerAllocator>
struct IsFixedSize< ::mavros_msgs::RTCM_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::mavros_msgs::RTCM_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct IsMessage< ::mavros_msgs::RTCM_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::mavros_msgs::RTCM_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::mavros_msgs::RTCM_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::mavros_msgs::RTCM_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::mavros_msgs::RTCM_<ContainerAllocator> >
{
static const char* value()
{
return "8903b686ebe5db3477e83c6d0bb149f8";
}
static const char* value(const ::mavros_msgs::RTCM_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0x8903b686ebe5db34ULL;
static const uint64_t static_value2 = 0x77e83c6d0bb149f8ULL;
};
template<class ContainerAllocator>
struct DataType< ::mavros_msgs::RTCM_<ContainerAllocator> >
{
static const char* value()
{
return "mavros_msgs/RTCM";
}
static const char* value(const ::mavros_msgs::RTCM_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::mavros_msgs::RTCM_<ContainerAllocator> >
{
static const char* value()
{
return "# RTCM message for the gps_rtk plugin\n\
# The gps_rtk plugin will fragment the data if necessary and \n\
# forward it to the FCU via Mavlink through the available link.\n\
# data should be <= 4*180, higher will be discarded.\n\
std_msgs/Header header\n\
uint8[] data\n\
\n\
================================================================================\n\
MSG: std_msgs/Header\n\
# Standard metadata for higher-level stamped data types.\n\
# This is generally used to communicate timestamped data \n\
# in a particular coordinate frame.\n\
# \n\
# sequence ID: consecutively increasing ID \n\
uint32 seq\n\
#Two-integer timestamp that is expressed as:\n\
# * stamp.sec: seconds (stamp_secs) since epoch (in Python the variable is called 'secs')\n\
# * stamp.nsec: nanoseconds since stamp_secs (in Python the variable is called 'nsecs')\n\
# time-handling sugar is provided by the client library\n\
time stamp\n\
#Frame this data is associated with\n\
# 0: no frame\n\
# 1: global frame\n\
string frame_id\n\
";
}
static const char* value(const ::mavros_msgs::RTCM_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::mavros_msgs::RTCM_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.data);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct RTCM_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::mavros_msgs::RTCM_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::mavros_msgs::RTCM_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "data[]" << std::endl;
for (size_t i = 0; i < v.data.size(); ++i)
{
s << indent << " data[" << i << "]: ";
Printer<uint8_t>::stream(s, indent + " ", v.data[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // MAVROS_MSGS_MESSAGE_RTCM_H
| [
"aarchilla21@gmail.com"
] | aarchilla21@gmail.com |
b0f07196a8f2a746cfb2231cbcaf528ebcb10933 | eec816ee04e0c5fa8aa050d182a687c5e90fbbd7 | /device/source/Main/ServerCommunication.h | c058f235dd36d49fcdfc14149ca4fa55ee282ebf | [] | no_license | HAL-RO-Developer/iot_platform | d7e9112aba330e41590244c0dab50e694c5b0b52 | d14f8617cc33f2cec8b265110142a91908699626 | refs/heads/master | 2021-01-22T11:29:00.934570 | 2018-01-15T04:22:50 | 2018-01-15T04:22:50 | 92,702,104 | 3 | 0 | null | 2017-12-10T22:09:11 | 2017-05-29T03:00:33 | JavaScript | UTF-8 | C++ | false | false | 792 | h | #ifndef __SERVER_COMMUNICATION_H_
#define __SERVER_COMMUNICATION_H_
/* --- includeファイル --- */
#include "ArduinoLibrary.h"
#include "System.h"
#include "InfoStruct.h"
#define SERVER_SUCCESS ( 1 )
#define SERVER_CONNECT_ERROR ( -1 )
/* --- HTTPステータスコード --- */
#define HTTP_STATUS_OK ( 200 )
#define HTTP_STATUS_FORBIDDEN ( 403 )
#define HTTP_STATUS_NOT_FOUND ( 404 )
class ServerCommunication{
private:
WiFiClient client;
String host;
String port;
String url;
SINT status;
public:
ServerCommunication(String host="");
~ServerCommunication();
SSHT connect(String host, String port);
void request(String url, String json);
SINT response(String json[]);
void setUrl(String url);
SINT getStatus();
};
#endif /* __SERVER_COMMUNICATION_H_ */
| [
"tanaka.shogo2@gmail.com"
] | tanaka.shogo2@gmail.com |
5c7c21b9bf44653a775253b4dcb1de82a82ea07f | 1ae7e3c269e0bd2df0bc725a33f307971816d40d | /app/src/main/cpp/boost/range/detail/value_type.hpp | 033783fe8cae2ef10f1b8c0e958c093f975ceedf | [] | no_license | HOTFIGHTER/XmLogger | 347902372bf2afc88cf26d2342434c1ea556201f | 433a0420c99a883bd65e99fd5f04ac353ac6d7b6 | refs/heads/master | 2021-02-18T08:46:12.122640 | 2020-03-05T14:16:39 | 2020-03-05T14:16:39 | 245,178,943 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,723 | hpp | // Boost.Range library
//
// Copyright Thorsten Ottosen 2003-2004. Use, modification and
// distribution is subject to the Boost Software License, Version
// 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
// For more information, see http://www.boost.org/libs/range/
//
#ifndef BOOST_RANGE_DETAIL_VALUE_TYPE_HPP
#define BOOST_RANGE_DETAIL_VALUE_TYPE_HPP
#include <boost/range/detail/common.hpp>
#include <boost/range/detail/remove_extent.hpp>
#include <boost/iterator/iterator_traits.hpp>
//////////////////////////////////////////////////////////////////////////////
// missing partial specialization workaround.
//////////////////////////////////////////////////////////////////////////////
namespace mars_boost {}
namespace boost = mars_boost;
namespace mars_boost {
namespace range_detail {
template<typename T>
struct range_value_type_;
template<>
struct range_value_type_<std_container_> {
template<typename C>
struct pts {
typedef BOOST_RANGE_DEDUCED_TYPENAME C
::value_type type;
};
};
template<>
struct range_value_type_<std_pair_> {
template<typename P>
struct pts {
typedef BOOST_RANGE_DEDUCED_TYPENAME mars_boost
::iterator_value<BOOST_RANGE_DEDUCED_TYPENAME P::first_type>::type type;
};
};
template<>
struct range_value_type_<array_> {
template<typename T>
struct pts {
typedef BOOST_DEDUCED_TYPENAME remove_extent
<T>::type
type;
};
};
}
template<typename C>
class range_value {
typedef BOOST_DEDUCED_TYPENAME range_detail
::range<C>::type c_type;
public:
typedef BOOST_DEDUCED_TYPENAME range_detail
::range_value_type_<c_type>::BOOST_NESTED_TEMPLATE pts<C>::type
type;
};
}
#endif
| [
"linfeng.yu@ximalaya.com"
] | linfeng.yu@ximalaya.com |
f9e5b73d7faa5011f4f6c11a4c394244ed544880 | 632516b82a6d662ab0d542190759f4620cf98d14 | /tests/unit_tests/address_from_url.cpp | 71b6c54b3a1447fe918ab457de073321a9f4134c | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference",
"MIT"
] | permissive | creddit-project/creddit | cf5adca578d778d4bb9352ecfd416f7bf4953e27 | 4b76b4e26076d778f0ffa451104c420cd1a5cc64 | refs/heads/master | 2020-06-25T01:57:29.958980 | 2019-07-27T12:40:27 | 2019-07-27T12:40:27 | 198,517,938 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,921 | cpp | // Copyright (c) 2014-2019, The Monero Project
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// FIXME: move this into a full wallet2 unit test suite, if possible
#include "gtest/gtest.h"
#include "wallet/wallet2.h"
#include "common/dns_utils.h"
#include "simplewallet/simplewallet.h"
#include <string>
TEST(AddressFromTXT, Success)
{
std::string addr = "46BeWrHpwXmHDpDEUmZBWZfoQpdc6HaERCNmx1pEYL2rAcuwufPN9rXHHtyUA4QVy66qeFQkn6sfK8aHYjA3jk3o1Bv16em";
std::string txtr = "oa1:xmr";
txtr += " recipient_address=";
txtr += addr;
txtr += ";";
std::string res = tools::dns_utils::address_from_txt_record(txtr);
EXPECT_STREQ(addr.c_str(), res.c_str());
std::string txtr2 = "foobar";
txtr2 += txtr;
txtr2 += "more foobar";
res = tools::dns_utils::address_from_txt_record(txtr2);
EXPECT_STREQ(addr.c_str(), res.c_str());
std::string txtr3 = "foobar oa1:xmr tx_description=\"Donation for Creddit Development Fund\"; ";
txtr3 += "recipient_address=";
txtr3 += addr;
txtr3 += "; foobar";
res = tools::dns_utils::address_from_txt_record(txtr3);
EXPECT_STREQ(addr.c_str(), res.c_str());
}
TEST(AddressFromTXT, Failure)
{
std::string txtr = "oa1:xmr recipient_address=not a real address";
std::string res = tools::dns_utils::address_from_txt_record(txtr);
ASSERT_STREQ("", res.c_str());
txtr += ";";
res = tools::dns_utils::address_from_txt_record(txtr);
ASSERT_STREQ("", res.c_str());
}
TEST(AddressFromURL, Success)
{
const std::string addr = MONERO_DONATION_ADDR;
bool dnssec_result = false;
std::vector<std::string> addresses = tools::dns_utils::addresses_from_url("donate.getmonero.org", dnssec_result);
EXPECT_EQ(1, addresses.size());
if (addresses.size() == 1)
{
EXPECT_STREQ(addr.c_str(), addresses[0].c_str());
}
// OpenAlias address with an @ instead of first .
addresses = tools::dns_utils::addresses_from_url("donate@getmonero.org", dnssec_result);
EXPECT_EQ(1, addresses.size());
if (addresses.size() == 1)
{
EXPECT_STREQ(addr.c_str(), addresses[0].c_str());
}
}
TEST(AddressFromURL, Failure)
{
bool dnssec_result = false;
std::vector<std::string> addresses = tools::dns_utils::addresses_from_url("example.veryinvalid", dnssec_result);
// for a non-existing domain such as "example.invalid", the non-existence is proved with NSEC records
ASSERT_TRUE(dnssec_result);
ASSERT_EQ(0, addresses.size());
}
| [
"jedibear@protonmail.com"
] | jedibear@protonmail.com |
a7004c103c75751cc8695e8a8ab861ef83fc2c51 | a7cd1fc70b9c87fc35ec3c3be5d4d3332e7ff9da | /RayTracer/PointLight.cpp | a973e88f2909295c49384e124949b9e5a6287224 | [] | no_license | Thomas92330/2021_Classes | 0deca281df37bc3597036ec512fa0c253b2771f0 | fd6456399ba26e87964e827c060d164a772add25 | refs/heads/master | 2023-03-13T07:34:24.982300 | 2021-02-25T12:50:17 | 2021-02-25T12:50:17 | 342,186,741 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 260 | cpp | #include "PointLight.h"
PointLight::PointLight(Vector _origine)
:Light(), origine(_origine)
{
}
PointLight::~PointLight()
{
}
Vector PointLight::VectorL(const Vector& point)
{
Vector vectorL = (point - origine);
vectorL.normalize();
return vectorL;
}
| [
"toto.tranchet@gmail.com"
] | toto.tranchet@gmail.com |
aef45e542988c33f7dce842357a162004bd58fc7 | c90ce2d1e2b96409e20fef94af1207d5543cddec | /sw/src/sw/ctrl/RootControl.cpp | 9bcf606e2fefbde4c03382c2e25336b502e763e3 | [] | no_license | definedD4/SlickWindows | 2f58407a14088117683df073bdd5d83fc686d47f | 4e538f6447acc8ec923ad297ab08eb814b74ddd8 | refs/heads/master | 2021-01-21T11:44:54.781130 | 2016-05-11T16:04:04 | 2016-05-11T16:04:04 | 49,780,757 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,026 | cpp | #include "RootControl.h"
namespace sw {
RootControl::RootControl(Window* owner) : ControlParrent(), m_Owner(owner) { }
RootControl::~RootControl() {
delete m_Content;
}
Size RootControl::getContainerArea(ControlBase* control) const {
ASSERT(m_Owner != nullptr)
ASSERT(control == m_Content)
return m_Owner->getSize();
}
//Point RootControl::transformToWindowSpace(Point point, const ControlBase* const control) const {
// return point;
//}
Renderer RootControl::getRenderer(ControlBase* control) const {
ASSERT(control == m_Content)
ASSERT(m_Owner != nullptr)
return Renderer(m_Owner->getRenderTarget());
}
void RootControl::setContent(ControlBase* content) {
if (m_Content != nullptr) {
delete m_Content;
}
ASSERT(content != nullptr)
m_Content = content;
m_Content->setParrent(static_cast<ControlParrent*>(this));
}
void RootControl::render() {
m_Content->render();
}
void RootControl::resize() {
m_Content->resize();
}
}
| [
"definedd4@gmail.com"
] | definedd4@gmail.com |
d23b5f1c74655ec67782169a182ddeffce6d17a0 | 56148fb60af13e0b7464bf19248ee019998be461 | /Delta-2A_Windows_Demo/sdk/app/frame_grabber/SerialSelDlg.cpp | 005701fa42121c8f35ae93d563a3edef727fc304 | [] | no_license | shuimuyangsha/Lider_Delta2A | 14a99cd31b783adb8d02c85aea7c119d931db370 | 452b1df04bbc7f3b35d856bc3d7628b8b409e1a5 | refs/heads/master | 2022-11-08T05:59:07.940341 | 2020-07-04T08:41:35 | 2020-07-04T08:41:35 | 276,083,115 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,808 | cpp | /*
* RSLIDAR System
* Driver Interface
*
* Copyright 2015 RS Team
* All rights reserved.
*
* Author: ruishi, Data:2015-12-25
*
*/
// SerialSelDlg.cpp : implementation of the CSerialSelDlg class
//
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "resource.h"
#include "SerialSelDlg.h"
UINT16 CSerialSelDlg::FindSerialPort()
{
CRegKey RegKey;
if (RegKey.Open(HKEY_LOCAL_MACHINE, "Hardware\\DeviceMap\\SerialComm") == ERROR_SUCCESS)
{
while (true)
{
char ValueName[_MAX_PATH];
unsigned char ValueData[_MAX_PATH];
DWORD nValueSize = _MAX_PATH;
DWORD nDataSize = _MAX_PATH;
DWORD nType;
if (::RegEnumValue(HKEY(RegKey), SerialNumber, ValueName, &nValueSize, NULL, &nType, ValueData, &nDataSize) == ERROR_NO_MORE_ITEMS)
{
break;
}
PortList[SerialNumber++] = ValueData;
}
}
return SerialNumber;
}
CSerialSelDlg::CSerialSelDlg()
: selectedID(-1)
{
}
LRESULT CSerialSelDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
CenterWindow(GetParent());
this->DoDataExchange();
char buf[100];
SerialNumber = 0;
FindSerialPort();
for (int pos = 0; pos < SerialNumber; ++pos) {
sprintf(buf, "%s", PortList[pos]);
m_sel_box.AddString(buf);
}
m_sel_box.SetCurSel(0);
selectedID = 0;
return TRUE;
}
LRESULT CSerialSelDlg::OnOK(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
EndDialog(wID);
return 0;
}
LRESULT CSerialSelDlg::OnCancel(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
EndDialog(wID);
return 0;
}
LRESULT CSerialSelDlg::OnCbnSelchangeCombSerialSel(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
selectedID = m_sel_box.GetCurSel();
return 0;
}
| [
"dongxh@dadaoii.com"
] | dongxh@dadaoii.com |
9bc55e00cde41bfa922e87e1a4abb1144c50deb1 | 6ced41da926682548df646099662e79d7a6022c5 | /aws-cpp-sdk-redshift-serverless/source/model/GetWorkgroupResult.cpp | 5423e1060b3005216804a527c1842d584f9ea94a | [
"Apache-2.0",
"MIT",
"JSON"
] | permissive | irods/aws-sdk-cpp | 139104843de529f615defa4f6b8e20bc95a6be05 | 2c7fb1a048c96713a28b730e1f48096bd231e932 | refs/heads/main | 2023-07-25T12:12:04.363757 | 2022-08-26T15:33:31 | 2022-08-26T15:33:31 | 141,315,346 | 0 | 1 | Apache-2.0 | 2022-08-26T17:45:09 | 2018-07-17T16:24:06 | C++ | UTF-8 | C++ | false | false | 959 | cpp | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#include <aws/redshift-serverless/model/GetWorkgroupResult.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <aws/core/AmazonWebServiceResult.h>
#include <aws/core/utils/StringUtils.h>
#include <aws/core/utils/UnreferencedParam.h>
#include <utility>
using namespace Aws::RedshiftServerless::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
using namespace Aws;
GetWorkgroupResult::GetWorkgroupResult()
{
}
GetWorkgroupResult::GetWorkgroupResult(const Aws::AmazonWebServiceResult<JsonValue>& result)
{
*this = result;
}
GetWorkgroupResult& GetWorkgroupResult::operator =(const Aws::AmazonWebServiceResult<JsonValue>& result)
{
JsonView jsonValue = result.GetPayload().View();
if(jsonValue.ValueExists("workgroup"))
{
m_workgroup = jsonValue.GetObject("workgroup");
}
return *this;
}
| [
"aws-sdk-cpp-automation@github.com"
] | aws-sdk-cpp-automation@github.com |
8ca29d213b3aa587db1a02a738cd86f355599b3b | 89016fcda83d19cf880a3671e7923d69b8cb7c39 | /spriterengine/objectref/spriterefinstance.cpp | 76d48689b0e2f7b04fd7c5ca65c9f03279aeb0e5 | [
"Zlib"
] | permissive | lucidspriter/SpriterPlusPlus | 9f83e68cd81295642dd3814ab800cd92967ee6c0 | 8fb550e1633036b42acd1cce0e05cfe60a3041c0 | refs/heads/master | 2023-08-10T10:29:03.386422 | 2021-02-17T22:13:10 | 2021-02-17T22:13:10 | 45,448,363 | 97 | 55 | NOASSERTION | 2023-07-23T13:17:31 | 2015-11-03T07:09:45 | C++ | UTF-8 | C++ | false | false | 903 | cpp | #include "spriterefinstance.h"
#include "../objectinfo/universalobjectinterface.h"
#include "../file/filereference.h"
#include "../override/imagefile.h"
namespace SpriterEngine
{
SpriteRefInstance::SpriteRefInstance(UniversalObjectInterface *initialResultObject,
TransformProcessor *initialParentTransformer,
TimelineKey *initialKey,
FileReference *initialImageRef,
bool initialUseDefaultPivotPoint) :
ObjectRefInstance(initialResultObject, initialParentTransformer, initialKey),
imageRef(initialImageRef),
useDefaultPivot(initialUseDefaultPivotPoint)
{
}
void SpriteRefInstance::preProcess()
{
resultObject()->setImage(imageRef->image());
if (useDefaultPivot && imageRef->image())
{
resultObject()->setPivot(imageRef->image()->defaultPivot);
}
}
void SpriteRefInstance::process(real currentTime)
{
preProcess();
ObjectRefInstance::process(currentTime);
}
}
| [
"lucid@brashmonkey.com"
] | lucid@brashmonkey.com |
d42698b9cee689e9138b7e5321007a0406cd3aaf | 686f674dd3c28e1a9fd1518c2dab134d77f4828e | /main85.cpp | 327c7033742ecbd59e29727e8dc8c5ca1f263de9 | [] | no_license | jack-Dong/NubtOj | 8aa452f44a0ef1ba7bb7be4e211fa28a4dbf1fa2 | 7cecf56289b247dd85625bc9102141324ff81a8b | refs/heads/master | 2021-01-23T07:44:55.374580 | 2017-03-28T09:52:27 | 2017-03-28T09:52:27 | 86,443,612 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,331 | cpp | #include <iostream>
#include <vector>
#include <math.h>
using namespace std;
//点的结构体
typedef struct Point
{
double x,y;
}Point;
//判断是否在一条直线上
inline bool jugleOnALine(Point p1,Point p2,Point p3)
{
double det = (p2.y - p1.y)*(p3.x - p1.x) - (p2.x - p1.x)*(p3.y - p1.y);
if( fabs(det) < 0.0001 )
{
return true;
}
return false;
}
int main()
{
int caseN;
cin>>caseN; //得到测试用例个数
vector<Point> nums;
vector<string> rts; //结果
int numN;
Point temp;
for(int i = 0; i < caseN;i++)
{
cin>>numN;//得到单个测试用例参数个数
//得到所有的坐标
for(int j = 0; j < numN;j++)
{
cin>>temp.x>>temp.y;
nums.push_back(temp);
}
//计算任意三个坐标是否在一条直线上
bool flag = false;
for(int m = 0; m < nums.size();++m)
{
for(int n = 0; n < nums.size() && n != m ; ++n)
{
for(int k = 0; k < nums.size() && k != m && k != n; ++k)
{
if( jugleOnALine(nums[m],nums[n],nums[k]) )
{
flag = true;
break;
}
}
if(flag)
{
break;
}
}
if(flag)
{
break;
}
}
if(flag)
{
rts.push_back("Yes");
}else
{
rts.push_back("No");
}
nums.clear();
}
//输出答案
for(int i = 0; i < rts.size();i++)
{
cout << rts[i]<<endl;
}
}
| [
"1099633787@qq.com"
] | 1099633787@qq.com |
7fa7a63706605fc3267d6e2d8d1cde03caeca3c8 | d9167eaed1bc14c7cf3ba8555e241c4ca2fd9d1b | /KernelMonitor/context.cpp | 6e9c4340c1fe61195119b6019d4e3c399b1120c0 | [] | no_license | yuaom/KernelMon | 8301af36c34d05e13b306f9ea4b4a67fba644018 | 4f545da24980c72e6e9f6dcc9ad78fceb45d37b7 | refs/heads/master | 2023-06-07T11:17:40.826321 | 2021-03-05T12:24:37 | 2021-03-05T12:24:37 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,923 | cpp | #include "context.h"
#include "ept.h"
static vmx::Vmxon* alloc_vmxon();
static vmx::Vmcs* alloc_vmcs();
static unsigned __int64 virtual_to_physical(PVOID vaddr);
vmx::VmmContext* vmx::alloc_vmm_context() {
PHYSICAL_ADDRESS physical_max;
physical_max.QuadPart = ~0ULL;
auto vmm_context = new(NonPagedPool) VmmContext{ 0 };
RtlSecureZeroMemory(vmm_context, sizeof(VmmContext));
if (!vmm_context)
return nullptr;
vmm_context->processor_count = KeQueryActiveProcessorCountEx(ALL_PROCESSOR_GROUPS);
vmm_context->vcpu_table = new(NonPagedPool) VCpu[vmm_context->processor_count]{ 0 };
if (!vmm_context->vcpu_table) {
delete vmm_context;
return nullptr;
}
RtlSecureZeroMemory(vmm_context->vcpu_table, sizeof(VCpu) * vmm_context->processor_count);
auto msr_bitmap = MmAllocateContiguousMemory(PAGE_SIZE, physical_max);
if (!msr_bitmap) {
delete[] vmm_context->vcpu_table;
delete vmm_context;
return nullptr;
}
RtlSecureZeroMemory(msr_bitmap, PAGE_SIZE);
for (unsigned __int32 i = 0; i < vmm_context->processor_count; i++) {
vmm_context->vcpu_table[i].vmxon = alloc_vmxon();
vmm_context->vcpu_table[i].vmcs = alloc_vmcs();
vmm_context->vcpu_table[i].msr_bitmap = msr_bitmap;
vmm_context->vcpu_table[i].stack = MmAllocateNonCachedMemory(VMM_STACK_SIZE);
if (!ept::setup_ept(&vmm_context->vcpu_table[i]) || vmm_context->vcpu_table[i].vmcs == nullptr || vmm_context->vcpu_table[i].vmxon == nullptr || vmm_context->vcpu_table[i].stack == nullptr) {
cleanup_vmm_context(vmm_context);
return nullptr;
}
vmm_context->vcpu_table[i].vmxon_physical = virtual_to_physical(vmm_context->vcpu_table[i].vmxon);
vmm_context->vcpu_table[i].vmcs_physical = virtual_to_physical(vmm_context->vcpu_table[i].vmcs);
vmm_context->vcpu_table[i].msr_bitmap_physical = virtual_to_physical(vmm_context->vcpu_table[i].msr_bitmap);
}
return vmm_context;
}
static vmx::Vmxon* alloc_vmxon() {
arch::Ia32VmxBasicMsr vmx_basic_msr{ 0 };
vmx::Vmxon* vmxon;
PHYSICAL_ADDRESS physical_max;
physical_max.QuadPart = ~0ULL;
vmx_basic_msr.control = __readmsr(static_cast<unsigned __int64>(arch::Msr::MSR_IA32_VMX_BASIC));
if (vmx_basic_msr.fields.vmxon_region_size > PAGE_SIZE)
vmxon = static_cast<vmx::Vmxon*>(MmAllocateContiguousMemory(PAGE_SIZE, physical_max));
else
vmxon = static_cast<vmx::Vmxon*>(MmAllocateContiguousMemory(vmx_basic_msr.fields.vmxon_region_size, physical_max));
if (!vmxon)
return nullptr;
RtlSecureZeroMemory(vmxon, vmx::VMXON_REGION_SIZE);
vmxon->revision_identifier = vmx_basic_msr.fields.vmcs_revision_identifier;
return vmxon;
}
static vmx::Vmcs* alloc_vmcs() {
arch::Ia32VmxBasicMsr vmx_basic_msr{ 0 };
vmx_basic_msr.control = __readmsr(static_cast<unsigned __int64>(arch::Msr::MSR_IA32_VMX_BASIC));
PHYSICAL_ADDRESS physical_max;
physical_max.QuadPart = ~0ULL;
auto vmcs = static_cast<vmx::Vmcs*>(MmAllocateContiguousMemory(PAGE_SIZE, physical_max));
RtlSecureZeroMemory(vmcs, vmx::VMCS_REGION_SIZE);
vmcs->revision_identifier = vmx_basic_msr.fields.vmcs_revision_identifier;
vmcs->shadow_vmcs_indicator = 0;
return vmcs;
}
static unsigned __int64 virtual_to_physical(PVOID vaddr) {
return MmGetPhysicalAddress(vaddr).QuadPart;
}
void vmx::cleanup_vmm_context(vmx::VmmContext* vmm_context) {
if (!vmm_context)
return;
if (vmm_context->vcpu_table) {
MmFreeContiguousMemory(vmm_context->vcpu_table[0].msr_bitmap);
for (unsigned __int32 i = 0; i < vmm_context->processor_count; i++) {
if (vmm_context->vcpu_table[i].vmxon)
MmFreeContiguousMemory(vmm_context->vcpu_table[i].vmxon);
if (vmm_context->vcpu_table[i].vmcs)
MmFreeContiguousMemory(vmm_context->vcpu_table[i].vmcs);
if (vmm_context->vcpu_table[i].stack)
MmFreeNonCachedMemory(vmm_context->vcpu_table[i].stack, VMM_STACK_SIZE);
ept::cleanup_ept(&vmm_context->vcpu_table[i]);
}
}
delete[] vmm_context->vcpu_table;
delete vmm_context;
} | [
"alonbenti@gmail.com"
] | alonbenti@gmail.com |
8b39ec91989d277cda0767101743597b7b23dac1 | c40a70b70835a0a8b8672f3d2c10c82fe13d55ff | /switch.cpp | a459913b2f25c14707e1761cc9033e1bcaded569 | [] | no_license | RodArg/OOPDemo | 4561df368f5753990cb94a87882fe0f502503b2d | 55351defeeff0f8fe660ba38d21d363cc38f873a | refs/heads/master | 2020-03-22T05:59:06.663981 | 2018-08-01T22:51:18 | 2018-08-01T22:51:18 | 139,604,312 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 321 | cpp | #include "std_lib_facilities.h"
int main(){
int num;
cout << "What's your favorite number 1-10?";
cin >> num;
switch(num){
case 0: case 2: case 4: case 6: case 8: case 10:
cout << "Nice and even";
break;
case 1: case 3: case 5: case 9:
cout << "That's odd";
break;
case 7:
cout << "Lucky!";
break;
}
} | [
"rodrigo.arg01@gmail.com"
] | rodrigo.arg01@gmail.com |
9544de486ebc10609f6b066923b9020d781b8938 | 5e2e27daacfddfe119015736fcc6e9a864d66c49 | /GameEngine/Graphics/Anim2Bone.cpp | db53db079308dd27a65033a6f9aab04f82670dd4 | [] | no_license | mdubovoy/Animation_System | 17ddc22740962209e7edbd8ea85bec108499f3e2 | b356d0ea6812e0548336bc4813662463e786de93 | refs/heads/master | 2021-01-22T11:41:13.637727 | 2014-09-22T14:01:20 | 2014-09-22T14:01:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,129 | cpp | #include "OpenGLWrapper.h"
#include "Pyramid.h"
#include "PyramidObject.h"
#include "GraphicsObjectManager.h"
#include "Anim.h"
#include "Constants.h"
#define BONE_ANIM 0
#if BONE_ANIM
// temporary hack
Frame_Bucket *pHead = 0;
PyramidObject *firstBone;
// PyramidObject *p1;
Pyramid *pPyramid;
#define BONE_WIDTH 13.0f
void walk_anim_node( GraphicsObject *node ); // move to Anim.h?
void SetAnimationHierarchy()
{
// setup the bone model, this case we are using pyramid
// todo - create a cool Bone Object, ball(drk blue) + pyramid arm (dark yellow)
pPyramid = new Pyramid();
pPyramid->loadTexture();
pPyramid->createVAO();
// Get the manager
GraphicsObjectManager *goMgr = GraphicsObjectManager::getInstance();
// create two bones
PyramidObject* p0 = new PyramidObject( "Bone_0", pPyramid );
p0->setPos( Vect(0.0f, 0.0f, 0.0f) );
p0->setLightPos( Vect(50.0f, 50.0f, 0.0f) );
p0->setLightColor( Vect(1.5f, 0.5f, 0.5f) ); // RED
// p0->setTexture(TEX1);
// goMgr->addObject(p0);
p0->setIndex(0);
PyramidObject* p1 = new PyramidObject( "Bone_1", pPyramid );
p1->setPos( Vect(1.0f, 1.0f, 0.0f) );
p1->setLightPos( Vect(50.0f, 50.0f, 0.0f) );
p1->setLightColor( Vect(0.5f, 1.5f, 0.5f) ); // Green
// p1->setTexture(TEX1);
// goMgr->addObject(p1);
p1->setIndex(1);
// here we insert bones directly into tree -
// vs calling goMgr->addObject which inserts every node with root as parent
PCSTree *tree = goMgr->getTree();
PCSNode *root = tree->getRoot();
// Add 1st two bones
tree->insert( p0, root );
tree->insert( p1, p0 );
firstBone = p0;
// Debug
// tree->dumpTree();
}
// picture: double-linked list with Result at head, followed by each frame
// Each node's pBone points to an array of size NUM_Bones (all the bones)
// we fill each bone's data with the matrices provided by FBX output
void SetAnimationData()
{
// ------------- Result Frame -----------------------------
// create head bucket - the head of our list points to the bone_result array
pHead = new Frame_Bucket();
pHead->prevBucket = 0;
pHead->nextBucket = 0;
pHead->KeyTime = Time(TIME_ZERO);
pHead->pBone = new Bone[NUM_BONES];
// --------------- Frame 0 ------------------------------------
Frame_Bucket *pTmp = new Frame_Bucket();
pTmp->prevBucket = pHead;
pTmp->nextBucket = 0;
pTmp->KeyTime = 0 * Time(TIME_NTSC_30_FRAME);
pTmp->pBone = new Bone[NUM_BONES];
pHead->nextBucket = pTmp;
// Bone 0 ---------------------------------
//Local matrix
//Trans: -113.894875, 0.000000, 0.000000
//Rot: -0.000000, -0.000000, 0.005445
//Scale: 1.000000, 1.000000, 1.000000
pTmp->pBone[0].T = Vect(-113.894875f, 0.000000f, 0.000000f);
pTmp->pBone[0].Q = Quat(ROT_XYZ, 0.0f* MATH_PI_180 , 0.0f* MATH_PI_180, 0.005445f * MATH_PI_180 );
pTmp->pBone[0].S = Vect(1.0f, 1.0f, 1.0f);
// Bone 1 --------------------------------------
// Trans: 114.826065, -0.000016, 0.000000
// Rot: 0.000000, 0.000000, -0.005444
// Scale: 1.000000, 1.000000, 1.000000
pTmp->pBone[1].T = Vect(114.826065f, -0.000016f, 0.000000f);
pTmp->pBone[1].Q = Quat(ROT_XYZ, 0.000000f * MATH_PI_180, 0.000000f* MATH_PI_180, -0.005444f * MATH_PI_180);
pTmp->pBone[1].S = Vect(1.0f, 1.0f, 1.0f);
// --------------- Frame 35 -----------------------------
Frame_Bucket *pTmp2 = new Frame_Bucket();
pTmp2->prevBucket = pTmp;
pTmp2->nextBucket = 0;
pTmp2->KeyTime = 35 * Time(TIME_NTSC_30_FRAME);
pTmp2->pBone = new Bone[NUM_BONES];
pTmp->nextBucket = pTmp2;
// Bone 0 -------------------------------
//Trans: -69.141525, 0.000000, 0.000000
//Rot: -0.000000, -0.000000, 35.000000
//Scale: 1.000000, 1.000000, 1.000000
pTmp2->pBone[0].T = Vect(-69.141525f, 0.000000f, 0.000000f);
pTmp2->pBone[0].Q = Quat(ROT_XYZ, 0.0f* MATH_PI_180, 0.0f* MATH_PI_180, 35.0f * MATH_PI_180);
pTmp2->pBone[0].S = Vect(1.0f, 1.0f, 1.0f);
// Bone 1 ---------------------------------
//Trans: 114.826065, -0.000016, 0.000000
// Rot: -0.000000, 0.000000, -69.954391
//Scale: 1.000000, 1.000000, 1.000000
pTmp2->pBone[1].T = Vect(114.826065f, -0.000016f, 0.000000f);
pTmp2->pBone[1].Q = Quat(ROT_XYZ, 0.000000f* MATH_PI_180 , 0.000000f* MATH_PI_180, -69.954391f * MATH_PI_180);
pTmp2->pBone[1].S = Vect(1.0f, 1.0f, 1.0f);
//------------------------- Frame 70 -----------------------------------
Frame_Bucket *pTmp3 = new Frame_Bucket();
pTmp3->prevBucket = pTmp2;
pTmp3->nextBucket = 0;
pTmp3->KeyTime = 70 * Time(TIME_NTSC_30_FRAME);
pTmp3->pBone = new Bone[NUM_BONES];
pTmp2->nextBucket = pTmp3;
// Bone 0 ---------------------------------------
//Trans: -39.924347, 0.000000, 0.000000
//Rot: 0.000000, -0.000000, 0.000003
//Scale: 1.000000, 1.000000, 1.000000
pTmp3->pBone[0].T = Vect(-39.924347f, 0.000000f, 0.000000f);
pTmp3->pBone[0].Q = Quat(ROT_XYZ, 0.0f* MATH_PI_180,0.0f* MATH_PI_180 ,0.000003f * MATH_PI_180);
pTmp3->pBone[0].S = Vect(1.0f, 1.0f, 1.0f);
// Bone 1--------------------------------------
//Trans: 114.826065, -0.000016, 0.000000
//Rot: 0.000000, 0.000000, -0.000000
//Scale: 1.000000, 1.000000, 1.000000
pTmp3->pBone[1].T = Vect(114.826065f, -0.000016f, 0.000000f);
pTmp3->pBone[1].Q = Quat(ROT_XYZ, 0.000000f * MATH_PI_180, 0.000000f* MATH_PI_180, 0.0f * MATH_PI_180);
pTmp3->pBone[1].S = Vect( 1.0f, 1.0f, 1.0f);
}
void SetAnimationPose(GraphicsObject* root)
{
// First thing, get the first frame of animation
Time tCurr(TIME_ZERO);
// IS THIS NEEDED? Already called via GameLoop at Time Zero by now
ProcessAnimation( tCurr ); // fills result array with bone's position at time 0
// walks the anim node does the pose for everything that
walk_anim_node( root );
}
void setBonePose(GraphicsObject * node)
{
// Now get the world matrices
GraphicsObject *childNode = (GraphicsObject *)node->getChild();
GraphicsObject *parentNode = node;
if( parentNode != 0 && childNode != 0 )
{
// starting point
Vect start(0.0f,0.0f,0.0f);
// calling transform first to evaluate an up-to-date world, then get starting point in World coords
// ***ORDER*** do this for parent first, then child - in transform, p1 will get parent's world matrix
parentNode->transform();
Vect ptA = start * parentNode->getWorld();
childNode->transform();
Vect ptB = start * childNode->getWorld();
// At this point, we have the two bones initial positions in world space
// Now get the direction between two anchor points of respective bones, and direction
Vect dir = ptB- ptA;
float mag = dir.mag();
Matrix S( SCALE, BONE_WIDTH, BONE_WIDTH, mag);
// rotate along dir or DOF
Quat Q( ROT_ORIENT, dir.getNorm(), Vect( 0.0f, 1.0f, 0.0f) );
Matrix BoneOrient = S * Q;
parentNode->setBoneOrientation(BoneOrient);
}
// deal with last node, when there isn't a terminal node
// copy orientation matrix from grandparent to set Parent's orientation
if( parentNode != 0 && childNode == 0 )
{
// get the parent's parent -> grandParent
GraphicsObject *grandParentNode = (GraphicsObject *)parentNode->getParent();
Matrix BoneOrient = grandParentNode->getBoneOrientation();
parentNode->setBoneOrientation( BoneOrient );
}
}
void walk_anim_node( GraphicsObject *node )
{
// --------- Do pose stuff here -----------------------
setBonePose(node);
// iterate through all of the active children - copied from GOM, will it work here???
GraphicsObject *child = 0;
if (node->getChild() != 0)
{
child = (GraphicsObject *)node->getChild();
// make sure that allocation is not a child node
while (child != 0)
{
walk_anim_node( child );
// goto next sibling - node's child, but now we are iterating SIBLINGS
child = (GraphicsObject *)child->getSibling();
}
}
else
{
// bye bye exit condition
}
}
#else
//
#endif | [
"michel.dubovoy@gmail.com"
] | michel.dubovoy@gmail.com |
4ac0f3c41d2b7d82a0a417aa007341f7895efad9 | 9056dcc0298c2c9142ceb070bafaec52a75e13a9 | /Cpp-version/libs/map.cpp | f829b2c6d0cdfb2e11ab58b0d123a44544ecd706 | [] | no_license | vwdorsey/dungeon | 641597439d2da7adc16cf42230d72fc717cd05bd | ad5c315ea3a95a66f52aef530c5795123acc6705 | refs/heads/master | 2020-05-29T14:16:34.788538 | 2015-04-26T02:56:50 | 2015-04-26T02:56:50 | 82,594,383 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,818 | cpp | /*
* map.cpp - Contains all the classes and functions necessary to
* create and maintain a map for the dungeon crawler
*
*/
#include <iostream>
#include <cstdlib>
#include <random>
#include "values.hpp"
#include "dijkstra.hpp"
#include "map.hpp"
map::map(){
room_count = min_rooms + (random() % ((max_rooms - min_rooms) + 1));
random.seed(rand());
column_dist = std::uniform_int_distribution<int>(0, columns-1);
row_dist = std::uniform_int_distribution<int>(0, rows-1);
init_map();
place_rooms();
determine_paths();
}
map::~map(){
}
void map::init_map(){
int x = 0;
int y = 0;
for(y = 0; y < columns; y++){
for(x = 0; x < rows; x++){
if(y == 0 || y == columns-1){
layout[y][x].type = tile_type_immutable;
layout[y][x].hardness = 9;
layout[y][x].pc = NULL;
layout[y][x].mon = NULL;
layout[y][x].obj = NULL;
}
else if(x == 0 || x == rows-1){
layout[y][x].type = tile_type_immutable;
layout[y][x].hardness = 9;
layout[y][x].pc = NULL;
layout[y][x].mon = NULL;
layout[y][x].obj = NULL;
}
else{
layout[y][x].type = tile_type_empty;
layout[y][x].hardness = (rand() % 8) + 1;
layout[y][x].pc = NULL;
layout[y][x].mon = NULL;
layout[y][x].obj = NULL;
}
}
}
}
void map::design_output(){
int x = 0;
int y = 0;
for(y = 0; y < columns; y++){
for(x = 0; x < rows; x++){
std::cout << layout[y][x].type;
}
std::cout << '\n';
}
}
void map::place_rooms(){
int i = 0;
std::uniform_int_distribution<int> room_x(min_room_x, max_room_x);
std::uniform_int_distribution<int> room_y(min_room_y, max_room_y);
while(i < room_count) {
int start_y = column_dist(random);
int start_x = row_dist(random);
int y_dim = room_y(random);
int x_dim = room_x(random);
if(layout[start_y][start_x].type == tile_type_empty){
if(check_room_placement(y_dim, x_dim, start_y, start_x) == 0){
for(int j = 0; j < y_dim+1; j++){
for(int k = 0; k < x_dim+1; k++){
if(j == 0 || j == y_dim){
layout[start_y+j][start_x+k].type = tile_type_wall;
layout[start_y+j][start_x+k].is_room = 1;
}
else if(k == 0 || k == x_dim){
layout[start_y+j][start_x+k].type = tile_type_wall;
layout[start_y+j][start_x+k].is_room = 1;
}
else{
layout[start_y+j][start_x+k].type = tile_type_floor;
layout[start_y+j][start_x+k].is_room = 1;
layout[start_y+j][start_x+k].hardness = 0;
}
}
}
room_info[i].x_dim = x_dim;
room_info[i].y_dim = y_dim;
room_info[i].x_start = start_x;
room_info[i].y_start = start_y;
i++;
}
}
}
}
char map::check_room_placement(int y_dim, int x_dim, int y, int x){
for(int i = 0; i < y_dim; i++){
if(x+i > 152 || x+i < 6) return -1;
for(int j = 0; j < x_dim; j++){
if(y+j > 91|| y+j < 5) return -1;
if(layout[y+i][x+j].type != tile_type_empty) return -1;
if(layout[y+i+4][x+j].type != tile_type_empty) return -1;
if(layout[y+i-4][x+j].type != tile_type_empty) return -1;
if(layout[y+i][x+j+4].type != tile_type_empty) return -1;
if(layout[y+i][x+j-4].type != tile_type_empty) return -1;
if(layout[y+i+4][x+j+4].type != tile_type_empty) return -1;
if(layout[y+i-4][x+j+4].type != tile_type_empty) return -1;
if(layout[y+i+4][x+j-4].type != tile_type_empty) return -1;
if(layout[y+i-4][x+j-4].type != tile_type_empty) return -1;
}
}
return 0;
}
void map::determine_paths(){
for(int i = 0; i < room_count-1; i++){
int src_panel_select = (rand() % 2)+1;
int src_x, src_y, des_x, des_y;
if(src_panel_select == 1){ //Right Panel
src_y = (room_info[i].y_start + 2 + (rand() % (room_info[i].y_dim)/2));
src_x = (room_info[i].x_start - 1 + room_info[i].x_dim);
}
else{ //Left Panel
src_y = (room_info[i].y_start + 2 + (rand() % (room_info[i].y_dim)/2));
src_x = (room_info[i].x_start);
}
des_x = (room_info[i+1].x_start + (room_info[i+1].x_dim / 2));
des_y = (room_info[i+1].y_start + (room_info[i+1].y_dim / 2));
generate_corridors(src_y, src_x, src_panel_select, des_y, des_x);
}
}
void map::generate_corridors(int s_y, int s_x, int src_pnl, int d_y, int d_x){
int cur_x = s_x;
int cur_y = s_y;
int i;
for(i = 0; i < 3; i++){
if(src_pnl == 1){ //right side
if (i != 0) cur_x++;
layout[cur_y][cur_x].type = tile_type_floor;
if(layout[cur_y+1][cur_x].type == tile_type_empty) layout[cur_y+1][cur_x].type = tile_type_wall;
if(layout[cur_y+1][cur_x+1].type == tile_type_empty) layout[cur_y+1][cur_x+1].type = tile_type_wall;
if(layout[cur_y][cur_x+1].type == tile_type_empty) layout[cur_y][cur_x+1].type = tile_type_wall;
if(layout[cur_y-1][cur_x+1].type == tile_type_empty) layout[cur_y-1][cur_x+1].type = tile_type_wall;
}
else{ //left side
if (i != 0) cur_x--;
layout[cur_y][cur_x].type = tile_type_floor;
if(layout[cur_y+1][cur_x].type == tile_type_empty) layout[cur_y+1][cur_x].type = tile_type_wall;
if(layout[cur_y][cur_x-1].type == tile_type_empty) layout[cur_y][cur_x-1].type = tile_type_wall;
if(layout[cur_y+1][cur_x-1].type == tile_type_empty) layout[cur_y+1][cur_x-1].type = tile_type_wall;
if(layout[cur_y-1][cur_x-1].type == tile_type_empty) layout[cur_y-1][cur_x-1].type = tile_type_wall;
}
}
if(cur_y < d_y){
while(cur_y != d_y){
cur_y++;
layout[cur_y][cur_x].type = tile_type_floor;
wall_stamp(cur_y, cur_x);
}
}
else{
while(cur_y != d_y){
cur_y--;
layout[cur_y][cur_x].type = tile_type_floor;
wall_stamp(cur_y, cur_x);
}
}
if(cur_x < d_x){
while(cur_x != d_x){ //moves down
cur_x++;
layout[cur_y][cur_x].type = tile_type_floor;
wall_stamp(cur_y, cur_x);
}
}
else{
while(cur_x != d_x){ //moves up
cur_x--;
layout[cur_y][cur_x].type = tile_type_floor;
wall_stamp(cur_y, cur_x);
}
}
}
void map::wall_stamp(int cur_y, int cur_x){
if(layout[cur_y][cur_x-1].type == tile_type_empty) layout[cur_y][cur_x-1].type = tile_type_wall;
if(layout[cur_y+1][cur_x-1].type == tile_type_empty) layout[cur_y+1][cur_x-1].type = tile_type_wall;
if(layout[cur_y-1][cur_x-1].type == tile_type_empty) layout[cur_y-1][cur_x-1].type = tile_type_wall;
if(layout[cur_y+1][cur_x].type == tile_type_empty) layout[cur_y+1][cur_x].type = tile_type_wall;
if(layout[cur_y-1][cur_x].type == tile_type_empty) layout[cur_y-1][cur_x].type = tile_type_wall;
if(layout[cur_y+1][cur_x+1].type == tile_type_empty) layout[cur_y+1][cur_x+1].type = tile_type_wall;
if(layout[cur_y][cur_x+1].type == tile_type_empty) layout[cur_y][cur_x+1].type = tile_type_wall;
if(layout[cur_y-1][cur_x+1].type == tile_type_empty) layout[cur_y-1][cur_x+1].type = tile_type_wall;
}
| [
"vwdorsey@iastate.edu"
] | vwdorsey@iastate.edu |
0ff5fe476bd1749edd16259586c393bd797a89db | 198f1f5606add5d11ecc7f264e11e83e05de92e7 | /Classes/not used/SensoryMemory.cpp | 826cc558e5e1eda0cb40819fcccbb46b2454788f | [] | no_license | jsenter/MOBAclient | 407c6a44441976adbd0d040cb6ac8548fb254a6d | 490924a9bbfccd9fe54f9b1916fd70be32b18326 | refs/heads/master | 2021-01-15T21:30:31.820134 | 2016-11-26T05:12:38 | 2016-11-26T05:12:38 | null | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 11,259 | cpp | #include "SensoryMemory.h"
#include "GameWorld.h"
#include "AbstCharacter.h"
#include "Timer/CrudeTimer.h"
#include "SteeringBehavior.h"
USING_NS_CC;
std::stringstream & operator<<(std::stringstream &ss, const MemoryRecord& m)
{
ss << m.attackable << std::endl
<< m.within_view << std::endl
<< m.time_became_visible << std::endl
<< m.time_last_sensed << std::endl
<< m.time_last_visible << std::endl
<< m.recent_damage << std::endl
<< m.last_sensed_position.x << ", "
<< m.last_sensed_position.y << std::endl;
return ss;
}
//------------------------------- ctor ----------------------------------------
//-----------------------------------------------------------------------------
SensoryMemory::SensoryMemory(
AbstCharacter* const owner,
double memory_span)
:
_owner(owner),
_memory_span(memory_span)
{
//--------------------------"Rendering Setting-------------------------------//
_memory_label = Label::createWithTTF(
"", Prm.FontFolderName + "/" + "arial" + ".ttf", 11);
float min_x = owner->getNowSprite()->getBoundingBox().getMinX();
float min_y = owner->getNowSprite()->getBoundingBox().getMinY();
float max_x = owner->getNowSprite()->getBoundingBox().getMaxX();
float max_y = owner->getNowSprite()->getBoundingBox().getMaxY();
_memory_label->setVerticalAlignment(cocos2d::TextVAlignment::TOP);
_memory_label->setHorizontalAlignment(cocos2d::TextHAlignment::LEFT);
_memory_label->setAnchorPoint(Vec2(1, 1));
RenderUtil::labelSetting(
owner->getNowSprite(),
_memory_label,
Vec2(0, max_y - min_y));
_memory_label->setVisible(Prm.RenderMemoryLabel);
}
SensoryMemory::~SensoryMemory()
{
_memory_label->removeFromParent();
}
//--------------------- makeNewRecordIfNotAlreadyPresent ----------------------
void SensoryMemory::makeNewRecordIfNotAlreadyPresent(AbstCharacter* const opponent)
{
//else check to see if this Opponent already exists in the memory. If it doesn't,
//create a new record
if (_memory_map.find(opponent) == _memory_map.end())
{
_memory_map[opponent] = MemoryRecord();
}
}
//------------------------ removeBotFromMemory --------------------------------
//
// this removes a bot's record from memory
//-----------------------------------------------------------------------------
void SensoryMemory::removeBotFromMemory(AbstCharacter* const bot)
{
MemoryMap::iterator record = _memory_map.find(bot);
if (record != _memory_map.end())
{
_memory_map.erase(record);
}
}
//----------------------- updateWithSoundSource -------------------------------
//
// this updates the record for an individual opponent. Note, there is no need to
// test if the opponent is within the FOV because that test will be done when the
// updateVision method is called
//-----------------------------------------------------------------------------
void SensoryMemory::updateWithSoundSource(AbstCharacter* const noise_maker)
{
//make sure the bot being examined is not this bot
if (_owner != noise_maker)
{
//if the bot is already part of the memory then update its data, else
//create a new memory record and add it to the memory
makeNewRecordIfNotAlreadyPresent(noise_maker);
MemoryRecord& info = _memory_map[noise_maker];
//test if there is LOS between bots
if (_owner->getWorld()->isLOSOkay(_owner->getPos(), noise_maker->getPos()))
{
info.attackable = true;
//record the position of the bot
info.last_sensed_position = noise_maker->getPos();
}
else
{
info.attackable = false;
}
//record the time it was sensed
info.time_last_sensed = (double)Clock.getCurrentTime();
}
}
//----------------------- updateWithDamageSource -------------------------------
//
// this updates the record for an individual opponent. Note, there is no need to
// test if the opponent is within the FOV because that test will be done when the
// updateVision method is called
// 때린사람 위치 기억.
//-----------------------------------------------------------------------------
void SensoryMemory::updateWithDamageSource(AbstCharacter* const shooter, int damage)
{
if (shooter == nullptr)
return;
//make sure the bot being examined is not this bot
if (_owner != shooter) // probably not possible
{
//if the bot is already part of the memory then update its data, else
//create a new memory record and add it to the memory
makeNewRecordIfNotAlreadyPresent(shooter);
MemoryRecord& info = _memory_map[shooter];
info.recent_damage += damage;
//test if there is LOS between bots
if (_owner->getWorld()->isLOSOkay(_owner->getPos(), shooter->getPos()))
{
//record the position of the bot
info.last_sensed_position = shooter->getPos();
}
else
{
info.attackable = false;
}
//record the time it was sensed
info.time_last_sensed = (double)Clock.getCurrentTime();
}
}
//----------------------------- updateVision ----------------------------------
//
// this method iterates through all the bots in the game world to test if
// they are in the field of view. Each bot's memory record is updated
// accordingly
//-----------------------------------------------------------------------------
void SensoryMemory::updateVision()
{
_owner->getWorld()->getGameMap()->getAgentCellSpace()->
calculateNeighborsForSmall(
_owner->getPos(),
&geometry::Circle(
_owner->getPos(),
_owner->getSteering()->getViewDistance()));
for (auto iter = _owner->getWorld()->getGameMap()->getAgentCellSpace()->begin();
!_owner->getWorld()->getGameMap()->getAgentCellSpace()->end();
iter = _owner->getWorld()->getGameMap()->getAgentCellSpace()->next())
{
if (_owner != iter)
{
//make sure it is part of the memory map
makeNewRecordIfNotAlreadyPresent(iter);
//get a reference to this bot's data
MemoryRecord& info = _memory_map[iter];
if (util::inRange(
_owner->getPos(),
iter->getPos(),
_owner->getSteering()->getViewDistance()))
{
info.time_last_sensed = Clock.getCurrentTime();
info.last_sensed_position = iter->getPos();
info.time_last_visible = Clock.getCurrentTime();
float tolerance = 20.0f;
if (util::inRange(
iter->getPos(),
_owner->getPos(),
_owner->getBRadius() + iter->getBRadius() + tolerance))
{
info.attackable = true;
}
else
info.attackable = false;
if (info.within_view == false)
{
info.within_view = true;
info.time_became_visible = info.time_last_sensed;
}
}
else
{
info.attackable = false;
info.within_view = false;
}
}
}
}
void SensoryMemory::render()
{
if (!Prm.RenderMemoryLabel)
return;
std::stringstream ss;
ss << "Memory\n";
for (auto it = std::begin(_memory_map); it != std::end(_memory_map); it++)
{
ss << "Id : " << it->first->getId() << std::endl;
ss << it->second << std::endl;
}
_memory_label->setString(ss.str());
}
//------------------------ getListOfRecentlySensedOpponents -------------------
//
// returns a list of the bots that have been sensed recently
//-----------------------------------------------------------------------------
std::list<AbstCharacter*>
SensoryMemory::getListOfRecentlySensedOpponents()const
{
//this will store all the opponents the bot can remember
std::list<AbstCharacter*> opponents;
double current_time = Clock.getCurrentTime();
MemoryMap::const_iterator rec = _memory_map.begin();
for (rec; rec != _memory_map.end(); ++rec)
{
//if this bot has been updated in the memory recently, add to list
if ((current_time - rec->second.time_last_sensed) <= _memory_span)
{
opponents.push_back(rec->first);
}
}
return opponents;
}
//----------------------------- isOpponentAttackable --------------------------------
//
// returns true if the bot given as a parameter can be shot (ie. its not
// obscured by walls)
//-----------------------------------------------------------------------------
bool SensoryMemory::isOpponentAttackable(AbstCharacter* const opponent)const
{
MemoryMap::const_iterator it = _memory_map.find(opponent);
if (it != _memory_map.end())
{
return it->second.attackable;
}
return false;
}
//----------------------------- isOpponentWithinFOV --------------------------------
//
// returns true if the bot given as a parameter is within FOV
//-----------------------------------------------------------------------------
bool SensoryMemory::isOpponentWithinFOV(AbstCharacter* const opponent) const
{
MemoryMap::const_iterator it = _memory_map.find(opponent);
if (it != _memory_map.end())
{
return it->second.within_view;
}
return false;
}
//---------------------------- getLastRecordedPositionOfOpponent -------------------
//
// returns the last recorded position of the bot
//-----------------------------------------------------------------------------
Vec2 SensoryMemory::getLastRecordedPositionOfOpponent(AbstCharacter* const opponent) const
{
MemoryMap::const_iterator it = _memory_map.find(opponent);
if (it != _memory_map.end())
{
return it->second.last_sensed_position;
}
throw std::runtime_error("< SensoryMemory::getLastRecordedPositionOfOpponent>: Attempting to get position of unrecorded bot");
}
//----------------------------- getTimeOpponentHasBeenVisible ----------------------
//
// returns the amount of time the given bot has been visible
//-----------------------------------------------------------------------------
double SensoryMemory::getTimeOpponentHasBeenVisible(AbstCharacter* const opponent) const
{
MemoryMap::const_iterator it = _memory_map.find(opponent);
if (it != _memory_map.end() && it->second.within_view)
{
return Clock.getCurrentTime() - it->second.time_became_visible;
}
return 0;
}
int SensoryMemory::getDamage(AbstCharacter* const opponent)const
{
MemoryMap::const_iterator it = _memory_map.find(opponent);
if (it != _memory_map.end())
{
return it->second.recent_damage;
}
return 0;
}
//-------------------- getTimeOpponentHasBeenOutOfView ------------------------
//
// returns the amount of time the given opponent has remained out of view
// returns a high value if opponent has never been seen or not present
//-----------------------------------------------------------------------------
double SensoryMemory::getTimeOpponentHasBeenOutOfView(AbstCharacter* const opponent)const
{
MemoryMap::const_iterator it = _memory_map.find(opponent);
if (it != _memory_map.end())
{
return Clock.getCurrentTime() - it->second.time_last_visible;
}
return std::numeric_limits<double>::max();
}
//------------------------ getTimeSinceLastSensed ----------------------
//
// returns the amount of time the given bot has been visible
//-----------------------------------------------------------------------------
double SensoryMemory::getTimeSinceLastSensed(AbstCharacter* const opponent)const
{
MemoryMap::const_iterator it = _memory_map.find(opponent);
if (it != _memory_map.end() && it->second.within_view)
{
return Clock.getCurrentTime() - it->second.time_last_sensed;
}
return 0;
}
bool SensoryMemory::isUnderAttack() const
{
MemoryMap::const_iterator rec = _memory_map.begin();
for (rec; rec != _memory_map.end(); ++rec)
{
//if this bot has hit us, return true
if ((*rec).second.recent_damage > 0)
return true;
}
return false;
} | [
"insooneelife@naver.com"
] | insooneelife@naver.com |
e609cef92d881e1f9ac4548a74bf2e91b485e1a4 | 49c55e28d66238a6b6cc6ad26b3ea4ff7db6f6df | /src/src/FlowSinkProcessor.h | 6708d7529964210ad504bb8bffe56bdd21de9ee2 | [] | no_license | akosiorek/optical_flow | 3380825e55d15a4d7f57e8717c7fa9be4d5c3e10 | d48918f56e864d7d1f087216e0e0e7435a19069a | refs/heads/master | 2021-01-02T22:57:14.563839 | 2015-07-03T11:23:04 | 2015-07-03T11:23:04 | 33,973,413 | 1 | 3 | null | 2015-05-19T17:46:10 | 2015-04-15T04:37:34 | C++ | UTF-8 | C++ | false | false | 1,423 | h | #ifndef FLOW_SINK_PROCESSOR_H
#define FLOW_SINK_PROCESSOR_H
#include <vector>
#include "common.h"
#include "DataFlowPolicy.h"
#include "FlowSlice.h"
#include "IFlowSinkTask.h"
template<template <class> class InputBufferT>
class FlowSinkProcessor :
public BufferedInputPolicy<FlowSlice::Ptr, InputBufferT>
{
public:
using InputBuffer = typename BufferedInputPolicy<FlowSlice::Ptr, InputBufferT>::InputBuffer;
FlowSinkProcessor()
: processThread_(nullptr),
running_(false)
{}
~FlowSinkProcessor()
{
stop();
}
bool start()
{
LOG_FUN_START;
processThread_ = std::make_unique<std::thread>(&FlowSinkProcessor::processFlowSlices, this);
if(processThread_ != nullptr) return running_ = true, running_;
else return false;
LOG_FUN_END;
}
void stop()
{
if(running_==true)
{
running_ = false;
processThread_->join();
processThread_.reset();
}
}
void addTask(std::unique_ptr<IFlowSinkTask> task)
{
taskQueue_.emplace_back(std::move(task));
}
private:
void processFlowSlices()
{
while(running_ == true)
{
if(this->hasInput())
{
auto input = this->inputBuffer_->front();
this->inputBuffer_->pop();
for(std::size_t i = 0; i<taskQueue_.size(); ++i)
{
taskQueue_[i]->process(input);
}
}
}
}
std::vector<std::unique_ptr<IFlowSinkTask> > taskQueue_;
std::unique_ptr<std::thread> processThread_;
std::atomic_bool running_;
};
#endif | [
"dawidh.adrian@googlemail.com"
] | dawidh.adrian@googlemail.com |
a661c438c4f7c5f3978590045c9d6c1d3945f128 | aafccc71b3ba659a9b6a606d805d9889c9fabc09 | /codechef/jan2014long/error.cpp | 485709f1c2995802b1555a4383db24418c90d228 | [] | no_license | abhashksingh/practice-programs | 6bf37670e8f385a2bb274bb14ffb9052944a9ab5 | 02602f61ad4812726dedb6c760c81dc647244b8c | refs/heads/master | 2021-01-25T05:23:09.630415 | 2014-08-24T17:07:10 | 2014-08-24T17:07:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 409 | cpp | #include <iostream>
#include <string>
#include <algorithm>
#include <stdio.h>
using namespace std;
int main()
{
string inp,c1="010",c2="101";
long long t;
size_t r1,r2;
scanf("%lld",&t);
cin.ignore();
while(t--)
{
getline(cin,inp);
r1 = inp.find(c1);
r2 = inp.find(c2);
if((r1!=string::npos)&&(r2!=string::npos))
{
printf("%s","Good\n");
}
else
{
printf("%s","Bad\n");
}
}
}
| [
"superabhash@gmail.com"
] | superabhash@gmail.com |
987fbefbf5d3a33536c65566ad89fff725a9c714 | 9ca5e88f35f1b9ca6e966498d49e853f20e7201e | /src/qt/sendcoinsdialog.cpp | 998df42b3fb1c254ebe6aabdb81a4d92a11afffe | [
"MIT"
] | permissive | myworldgithub/Horgerchain | dce64c51325de4efd6eb45dd7f31183b53bfe2c4 | 8d9c9bdf0c598b1457e75e90635afa97cb533ac6 | refs/heads/master | 2020-03-07T20:12:47.284188 | 2018-04-02T02:25:29 | 2018-04-02T02:25:29 | 127,691,667 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 18,653 | cpp | #include "sendcoinsdialog.h"
#include "ui_sendcoinsdialog.h"
// Coin Control
#include "init.h"
#include "addresstablemodel.h"
#include "coincontrol.h"
#include "coincontroldialog.h"
#include "walletmodel.h"
#include "bitcoinunits.h"
#include "addressbookpage.h"
#include "optionsmodel.h"
#include "sendcoinsentry.h"
#include "guiutil.h"
#include "askpassphrasedialog.h"
#include "base58.h"
#include "wallet.h"
#include <QMessageBox>
#include <QLocale>
#include <QTextDocument>
#include <QScrollBar>
// Coin Control
#include <QClipboard>
SendCoinsDialog::SendCoinsDialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::SendCoinsDialog),
model(0)
{
ui->setupUi(this);
#ifdef Q_OS_MAC // Icons on push buttons are very uncommon on Mac
ui->addButton->setIcon(QIcon());
ui->clearButton->setIcon(QIcon());
ui->sendButton->setIcon(QIcon());
#endif
#if QT_VERSION >= 0x040700
/* Do not move this to the XML file, Qt before 4.7 will choke on it */
ui->lineEditCoinControlChange->setPlaceholderText(tr("Enter a Horgerchain address"));
#endif
addEntry();
connect(ui->addButton, SIGNAL(clicked()), this, SLOT(addEntry()));
connect(ui->clearButton, SIGNAL(clicked()), this, SLOT(clear()));
// Coin Control
ui->lineEditCoinControlChange->setFont(GUIUtil::bitcoinAddressFont());
connect(ui->pushButtonCoinControl, SIGNAL(clicked()), this, SLOT(coinControlButtonClicked()));
connect(ui->checkBoxCoinControlChange, SIGNAL(stateChanged(int)), this, SLOT(coinControlChangeChecked(int)));
connect(ui->lineEditCoinControlChange, SIGNAL(textEdited(const QString &)), this, SLOT(coinControlChangeEdited(const QString &)));
// Coin Control: clipboard actions
QAction *clipboardQuantityAction = new QAction(tr("Copy quantity"), this);
QAction *clipboardAmountAction = new QAction(tr("Copy amount"), this);
QAction *clipboardFeeAction = new QAction(tr("Copy fee"), this);
QAction *clipboardAfterFeeAction = new QAction(tr("Copy after fee"), this);
QAction *clipboardBytesAction = new QAction(tr("Copy bytes"), this);
QAction *clipboardPriorityAction = new QAction(tr("Copy priority"), this);
QAction *clipboardLowOutputAction = new QAction(tr("Copy low output"), this);
QAction *clipboardChangeAction = new QAction(tr("Copy change"), this);
connect(clipboardQuantityAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardQuantity()));
connect(clipboardAmountAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardAmount()));
connect(clipboardFeeAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardFee()));
connect(clipboardAfterFeeAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardAfterFee()));
connect(clipboardBytesAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardBytes()));
connect(clipboardPriorityAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardPriority()));
connect(clipboardLowOutputAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardLowOutput()));
connect(clipboardChangeAction, SIGNAL(triggered()), this, SLOT(coinControlClipboardChange()));
ui->labelCoinControlQuantity->addAction(clipboardQuantityAction);
ui->labelCoinControlAmount->addAction(clipboardAmountAction);
ui->labelCoinControlFee->addAction(clipboardFeeAction);
ui->labelCoinControlAfterFee->addAction(clipboardAfterFeeAction);
ui->labelCoinControlBytes->addAction(clipboardBytesAction);
ui->labelCoinControlPriority->addAction(clipboardPriorityAction);
ui->labelCoinControlLowOutput->addAction(clipboardLowOutputAction);
ui->labelCoinControlChange->addAction(clipboardChangeAction);
fNewRecipientAllowed = true;
}
void SendCoinsDialog::setModel(WalletModel *model)
{
this->model = model;
for(int i = 0; i < ui->entries->count(); ++i)
{
SendCoinsEntry *entry = qobject_cast<SendCoinsEntry*>(ui->entries->itemAt(i)->widget());
if(entry)
{
entry->setModel(model);
}
}
if(model && model->getOptionsModel())
{
setBalance(model->getBalance(), model->getStake(), model->getUnconfirmedBalance(), model->getImmatureBalance());
connect(model, SIGNAL(balanceChanged(qint64, qint64, qint64, qint64)), this, SLOT(setBalance(qint64, qint64, qint64, qint64)));
connect(model->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));
// Coin Control
connect(model->getOptionsModel(), SIGNAL(displayUnitChanged(int)), this, SLOT(coinControlUpdateLabels()));
connect(model->getOptionsModel(), SIGNAL(coinControlFeaturesChanged(bool)), this, SLOT(coinControlFeatureChanged(bool)));
connect(model->getOptionsModel(), SIGNAL(transactionFeeChanged(qint64)), this, SLOT(coinControlUpdateLabels()));
ui->frameCoinControl->setVisible(model->getOptionsModel()->getCoinControlFeatures());
coinControlUpdateLabels();
}
}
SendCoinsDialog::~SendCoinsDialog()
{
delete ui;
}
void SendCoinsDialog::on_sendButton_clicked()
{
WalletModel::EncryptionStatus status = model->getEncryptionStatus();
if(status != WalletModel::Unencrypted)
{
model->setWalletLocked(true);
AskPassphraseDialog dlg(AskPassphraseDialog::Unlock, this);
emit sendCoinsClicked("UnLock Wallet");
dlg.setModel(model);
if(dlg.exec() != QDialog::Accepted)
{
return;
}
}
fWalletUnlockMintOnly = true;
emit sendCoinsClicked("Lock Wallet");
QList<SendCoinsRecipient> recipients;
bool valid = true;
if(!model)
return;
for(int i = 0; i < ui->entries->count(); ++i)
{
SendCoinsEntry *entry = qobject_cast<SendCoinsEntry*>(ui->entries->itemAt(i)->widget());
if(entry)
{
if(entry->validate())
{
recipients.append(entry->getValue());
}
else
{
valid = false;
}
}
}
if(!valid || recipients.isEmpty())
{
return;
}
// Format confirmation message
QStringList formatted;
foreach(const SendCoinsRecipient &rcp, recipients)
{
formatted.append(tr("<b>%1</b> to %2 (%3)").arg(BitcoinUnits::formatWithUnit(BitcoinUnits::BTC, rcp.amount), Qt::escape(rcp.label), rcp.address));
}
fNewRecipientAllowed = false;
QMessageBox::StandardButton retval = QMessageBox::question(this, tr("Confirm send coins"),
tr("Are you sure you want to send %1?").arg(formatted.join(tr(" and "))),
QMessageBox::Yes|QMessageBox::Cancel,
QMessageBox::Cancel);
if(retval != QMessageBox::Yes)
{
fNewRecipientAllowed = true;
return;
}
WalletModel::UnlockContext ctx(model->requestUnlock());
if(!ctx.isValid())
{
// Unlock wallet was cancelled
fNewRecipientAllowed = true;
return;
}
// WalletModel::SendCoinsReturn sendstatus = model->sendCoins(recipients);
// Coin Control
WalletModel::SendCoinsReturn sendstatus;
if (!model->getOptionsModel() || !model->getOptionsModel()->getCoinControlFeatures())
sendstatus = model->sendCoins(recipients);
else
sendstatus = model->sendCoins(recipients, CoinControlDialog::coinControl);
switch(sendstatus.status)
{
case WalletModel::InvalidAddress:
QMessageBox::warning(this, tr("Send Coins"),
tr("The recipient address is not valid, please recheck."),
QMessageBox::Ok, QMessageBox::Ok);
break;
case WalletModel::InvalidAmount:
QMessageBox::warning(this, tr("Send Coins"),
tr("The amount to pay must be larger than 0."),
QMessageBox::Ok, QMessageBox::Ok);
break;
case WalletModel::AmountExceedsBalance:
QMessageBox::warning(this, tr("Send Coins"),
tr("The amount exceeds your balance."),
QMessageBox::Ok, QMessageBox::Ok);
break;
case WalletModel::AmountWithFeeExceedsBalance:
QMessageBox::warning(this, tr("Send Coins"),
tr("The total exceeds your balance when the %1 transaction fee is included.").
arg(BitcoinUnits::formatWithUnit(BitcoinUnits::BTC, sendstatus.fee)),
QMessageBox::Ok, QMessageBox::Ok);
break;
case WalletModel::DuplicateAddress:
QMessageBox::warning(this, tr("Send Coins"),
tr("Duplicate address found, can only send to each address once per send operation."),
QMessageBox::Ok, QMessageBox::Ok);
break;
case WalletModel::TransactionCreationFailed:
QMessageBox::warning(this, tr("Send Coins"),
tr("Error: Transaction creation failed."),
QMessageBox::Ok, QMessageBox::Ok);
break;
case WalletModel::TransactionCommitFailed:
QMessageBox::warning(this, tr("Send Coins"),
tr("Error: The transaction was rejected. This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here."),
QMessageBox::Ok, QMessageBox::Ok);
break;
case WalletModel::Aborted: // User aborted, nothing to do
break;
case WalletModel::OK:
accept();
// Coin Control
CoinControlDialog::coinControl->UnSelectAll();
coinControlUpdateLabels();
break;
}
fNewRecipientAllowed = true;
}
void SendCoinsDialog::clear()
{
// Remove entries until only one left
while(ui->entries->count())
{
delete ui->entries->takeAt(0)->widget();
}
addEntry();
updateRemoveEnabled();
ui->sendButton->setDefault(true);
}
void SendCoinsDialog::reject()
{
clear();
}
void SendCoinsDialog::accept()
{
clear();
}
SendCoinsEntry *SendCoinsDialog::addEntry()
{
SendCoinsEntry *entry = new SendCoinsEntry(this);
entry->setModel(model);
ui->entries->addWidget(entry);
connect(entry, SIGNAL(removeEntry(SendCoinsEntry*)), this, SLOT(removeEntry(SendCoinsEntry*)));
// Coin Control
connect(entry, SIGNAL(payAmountChanged()), this, SLOT(coinControlUpdateLabels()));
updateRemoveEnabled();
// Focus the field, so that entry can start immediately
entry->clear();
entry->setFocus();
ui->scrollAreaWidgetContents->resize(ui->scrollAreaWidgetContents->sizeHint());
QCoreApplication::instance()->processEvents();
QScrollBar* bar = ui->scrollArea->verticalScrollBar();
if(bar)
bar->setSliderPosition(bar->maximum());
return entry;
}
void SendCoinsDialog::updateRemoveEnabled()
{
// Remove buttons are enabled as soon as there is more than one send-entry
bool enabled = (ui->entries->count() > 1);
for(int i = 0; i < ui->entries->count(); ++i)
{
SendCoinsEntry *entry = qobject_cast<SendCoinsEntry*>(ui->entries->itemAt(i)->widget());
if(entry)
{
entry->setRemoveEnabled(enabled);
}
}
setupTabChain(0);
// Coin Control
coinControlUpdateLabels();
}
void SendCoinsDialog::removeEntry(SendCoinsEntry* entry)
{
delete entry;
updateRemoveEnabled();
}
QWidget *SendCoinsDialog::setupTabChain(QWidget *prev)
{
for(int i = 0; i < ui->entries->count(); ++i)
{
SendCoinsEntry *entry = qobject_cast<SendCoinsEntry*>(ui->entries->itemAt(i)->widget());
if(entry)
{
prev = entry->setupTabChain(prev);
}
}
QWidget::setTabOrder(prev, ui->addButton);
QWidget::setTabOrder(ui->addButton, ui->sendButton);
return ui->sendButton;
}
void SendCoinsDialog::pasteEntry(const SendCoinsRecipient &rv)
{
if(!fNewRecipientAllowed)
return;
SendCoinsEntry *entry = 0;
// Replace the first entry if it is still unused
if(ui->entries->count() == 1)
{
SendCoinsEntry *first = qobject_cast<SendCoinsEntry*>(ui->entries->itemAt(0)->widget());
if(first->isClear())
{
entry = first;
}
}
if(!entry)
{
entry = addEntry();
}
entry->setValue(rv);
}
bool SendCoinsDialog::handleURI(const QString &uri)
{
SendCoinsRecipient rv;
// URI has to be valid
if (GUIUtil::parseBitcoinURI(uri, &rv))
{
CBitcoinAddress address(rv.address.toStdString());
if (!address.IsValid())
return false;
pasteEntry(rv);
return true;
}
return false;
}
void SendCoinsDialog::setBalance(qint64 balance, qint64 stake, qint64 unconfirmedBalance, qint64 immatureBalance)
{
Q_UNUSED(stake);
Q_UNUSED(unconfirmedBalance);
Q_UNUSED(immatureBalance);
if(!model || !model->getOptionsModel())
return;
int unit = model->getOptionsModel()->getDisplayUnit();
ui->labelBalance->setText(BitcoinUnits::formatWithUnit(unit, balance));
}
void SendCoinsDialog::updateDisplayUnit()
{
if(model && model->getOptionsModel())
{
// Update labelBalance with the current balance and the current unit
ui->labelBalance->setText(BitcoinUnits::formatWithUnit(model->getOptionsModel()->getDisplayUnit(), model->getBalance()));
}
}
// Coin Control: copy label "Quantity" to clipboard
void SendCoinsDialog::coinControlClipboardQuantity()
{
QApplication::clipboard()->setText(ui->labelCoinControlQuantity->text());
}
// Coin Control: copy label "Amount" to clipboard
void SendCoinsDialog::coinControlClipboardAmount()
{
QApplication::clipboard()->setText(ui->labelCoinControlAmount->text().left(ui->labelCoinControlAmount->text().indexOf(" ")));
}
// Coin Control: copy label "Fee" to clipboard
void SendCoinsDialog::coinControlClipboardFee()
{
QApplication::clipboard()->setText(ui->labelCoinControlFee->text().left(ui->labelCoinControlFee->text().indexOf(" ")));
}
// Coin Control: copy label "After fee" to clipboard
void SendCoinsDialog::coinControlClipboardAfterFee()
{
QApplication::clipboard()->setText(ui->labelCoinControlAfterFee->text().left(ui->labelCoinControlAfterFee->text().indexOf(" ")));
}
// Coin Control: copy label "Bytes" to clipboard
void SendCoinsDialog::coinControlClipboardBytes()
{
QApplication::clipboard()->setText(ui->labelCoinControlBytes->text());
}
// Coin Control: copy label "Priority" to clipboard
void SendCoinsDialog::coinControlClipboardPriority()
{
QApplication::clipboard()->setText(ui->labelCoinControlPriority->text());
}
// Coin Control: copy label "Low output" to clipboard
void SendCoinsDialog::coinControlClipboardLowOutput()
{
QApplication::clipboard()->setText(ui->labelCoinControlLowOutput->text());
}
// Coin Control: copy label "Change" to clipboard
void SendCoinsDialog::coinControlClipboardChange()
{
QApplication::clipboard()->setText(ui->labelCoinControlChange->text().left(ui->labelCoinControlChange->text().indexOf(" ")));
}
// Coin Control: settings menu - coin control enabled/disabled by user
void SendCoinsDialog::coinControlFeatureChanged(bool checked)
{
ui->frameCoinControl->setVisible(checked);
if (!checked && model) // coin control features disabled
CoinControlDialog::coinControl->SetNull();
}
// Coin Control: button inputs -> show actual coin control dialog
void SendCoinsDialog::coinControlButtonClicked()
{
CoinControlDialog dlg;
dlg.setModel(model);
dlg.exec();
coinControlUpdateLabels();
}
// Coin Control: checkbox custom change address
void SendCoinsDialog::coinControlChangeChecked(int state)
{
if (model)
{
if (state == Qt::Checked)
CoinControlDialog::coinControl->destChange = CBitcoinAddress(ui->lineEditCoinControlChange->text().toStdString()).Get();
else
CoinControlDialog::coinControl->destChange = CNoDestination();
}
ui->lineEditCoinControlChange->setEnabled((state == Qt::Checked));
ui->labelCoinControlChangeLabel->setEnabled((state == Qt::Checked));
}
// Coin Control: custom change address changed
void SendCoinsDialog::coinControlChangeEdited(const QString & text)
{
if (model)
{
CoinControlDialog::coinControl->destChange = CBitcoinAddress(text.toStdString()).Get();
// label for the change address
ui->labelCoinControlChangeLabel->setStyleSheet("QLabel{color:black;}");
if (text.isEmpty())
ui->labelCoinControlChangeLabel->setText("");
else if (!CBitcoinAddress(text.toStdString()).IsValid())
{
ui->labelCoinControlChangeLabel->setStyleSheet("QLabel{color:red;}");
ui->labelCoinControlChangeLabel->setText(tr("WARNING: Invalid Horgerchain address"));
}
else
{
QString associatedLabel = model->getAddressTableModel()->labelForAddress(text);
if (!associatedLabel.isEmpty())
ui->labelCoinControlChangeLabel->setText(associatedLabel);
else
{
CPubKey pubkey;
CKeyID keyid;
CBitcoinAddress(text.toStdString()).GetKeyID(keyid);
if (model->getPubKey(keyid, pubkey))
ui->labelCoinControlChangeLabel->setText(tr("(no label)"));
else
{
ui->labelCoinControlChangeLabel->setStyleSheet("QLabel{color:red;}");
ui->labelCoinControlChangeLabel->setText(tr("WARNING: unknown change address"));
}
}
}
}
}
// Coin Control: update labels
void SendCoinsDialog::coinControlUpdateLabels()
{
if (!model || !model->getOptionsModel() || !model->getOptionsModel()->getCoinControlFeatures())
return;
// set pay amounts
CoinControlDialog::payAmounts.clear();
for(int i = 0; i < ui->entries->count(); ++i)
{
SendCoinsEntry *entry = qobject_cast<SendCoinsEntry*>(ui->entries->itemAt(i)->widget());
if(entry)
CoinControlDialog::payAmounts.append(entry->getValue().amount);
}
if (CoinControlDialog::coinControl->HasSelected())
{
// actual coin control calculation
CoinControlDialog::updateLabels(model, this);
// show coin control stats
ui->labelCoinControlAutomaticallySelected->hide();
ui->widgetCoinControl->show();
}
else
{
// hide coin control stats
ui->labelCoinControlAutomaticallySelected->show();
ui->widgetCoinControl->hide();
ui->labelCoinControlInsuffFunds->hide();
}
}
| [
"eqrtty@163.com"
] | eqrtty@163.com |
c6adcc10b4743ccfbef86b75d557eea81d2318f3 | 4fc802a5e091f42d463917e07dd6e104604cecf6 | /Tarea2_Ej7/src/Headers/InputManager.h | e0a58c5b871e60323490cc0973d0b613c3aa642c | [] | no_license | FernandaRTenorio/DIMyR_FerRomeroT | c0ca9692960454bc8ac90f99975bfef6f71211d4 | 3ca115f6aa7b22a3e6f1230b8833749ae6239521 | refs/heads/master | 2020-12-07T03:49:04.678662 | 2016-12-13T17:22:46 | 2016-12-13T17:22:46 | 66,040,302 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,634 | h | #ifndef _InputManager_H
#define _InputManager_H
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/transform2.hpp>
#include <glm/gtx/quaternion.hpp>
#include <glm/gtc/type_ptr.hpp>
// Standar GLFW for the management of inputs codes keyboards
enum InputCodes {
kEscape = 27,
Space = 32,
Left = 37,
Up = 38,
Right = 39,
Down = 40,
a = 97,
A = 65,
b = 98,
B = 66,
c = 99,
C = 67,
d = 100,
D = 68,
e = 101,
E = 69,
f = 102,
F = 70,
g = 103,
G = 71,
h = 104,
H = 72,
i = 105,
I = 73,
j = 106,
J = 74,
k = 107,
K = 75,
l = 108,
L = 76,
m = 109,
M = 77,
n = 110,
N = 78,
o = 111,
O = 79,
p = 112,
P = 80,
q = 113,
Q = 81,
r = 114,
R = 82,
s = 115,
S = 83,
t = 116,
T = 84,
u = 117,
U = 85,
v = 118,
V = 86,
w = 119,
W = 87,
x = 120,
X = 88,
y = 121,
Y = 89,
z = 122,
Z = 90,
};
enum MouseCodes {
button_left = 1, button_right = 2, button_middle = 3,
};
class InputManager {
public:
static bool rotar;
InputManager() :
exitApp(false) {
}
void keyPressed(InputCodes code, float deltaTime);
void mouseMoved(float mouseX, float mouseY);
void mouseClicked(MouseCodes code);
void mouseScroll(float yoffset);
glm::mat4 getTransform();
bool isExitApp() {
return exitApp;
}
glm::ivec2 getLastMousePos() {
return lastMousePos;
}
void setLastMousePos(glm::ivec2 lastMousePos) {
this->lastMousePos = lastMousePos;
}
/* glm::mat4 getTransform(){
//transform = glm::rotate(transform, glm::radians(30.0f), glm::vec3(0.0f, 1.0f, 0.0f));
return transform;
}*/
protected:
bool exitApp;
glm::ivec2 lastMousePos;
};
#endif
| [
"fernandiux_mo@hotmail.com"
] | fernandiux_mo@hotmail.com |
20d6d432049f37e9c4a5f704e7b8652da6d1416a | a69574670179ba33bc67d9de6004c27fbefc6638 | /topcoder/TCO11 Wildcard/250.cpp | 4254fed5ea838f464b9723783e5e58f1372e7abf | [] | no_license | ashpsycho/CP | d60516ad6aad6a5045053344acb99210d954c53f | 1ae2d9825363c4d25ed2c865b04223a48d6b1f6a | refs/heads/master | 2021-01-18T23:37:19.382933 | 2018-06-05T11:02:39 | 2018-06-05T11:02:39 | 48,465,588 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 854 | cpp | #include <bits/stdc++.h>
using namespace std;
class EventOrder{
public:
int getCount(int longE,int inst){
long long i,j,k=0,mod=1000000009L, dp[2][3004];
for(i=0;i<2;i++)
for(j=0;j<3002;j++)dp[i][j]=0;
dp[0][0]=1;
for(i=0;i<longE;i++){
for(j=0;j<3002;j++){
dp[1][j]=(dp[1][j]+((j*(j-1))/2)*dp[0][j])%mod;
dp[1][j+1]=(dp[1][j+1]+j*(j+1)*dp[0][j])%mod;
dp[1][j+2]=(dp[1][j+2]+(((j+2)*(j+1))/2)*dp[0][j])%mod;
}
for(j=0;j<3002;j++){
dp[0][j]=dp[1][j];
dp[1][j]=0;
}
}
for(i=0;i<inst;i++){
for(j=0;j<3002;j++){
dp[1][j]=(dp[1][j]+j*dp[0][j])%mod;
dp[1][j+1]=(dp[1][j+1]+(j+1)*dp[0][j])%mod;
}
for(j=0;j<3002;j++){
dp[0][j]=dp[1][j];
dp[1][j]=0;
}
}
for(i=0;i<=(2*(longE+inst));i++)cout<<dp[0][i]<<" ";
cout<<"\n";
for(i=k=0;i<3002;i++)k=(k+dp[0][i])%mod;
return k;
}
}; | [
"lavania_a@worksap.co.jp"
] | lavania_a@worksap.co.jp |
7cd2f4bd102ca4415e512e65725a3323b62d2db5 | 790714546b4638d8d69995d9158a313c795dbffd | /inet_insertions/MobileNode.cc | cc9a10de99439d460bc93599f8394d93472ea8a2 | [] | no_license | brunoolivieri/omnetpp-mobility-drones | 13f76fdac4d5bda1668017a52436a26850320182 | f20f72fed2d8273ed29d302759898b2bc4542444 | refs/heads/master | 2023-03-05T06:57:29.253913 | 2021-02-18T10:17:41 | 2021-02-18T10:17:41 | 313,561,272 | 2 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 2,988 | cc | #include "MobileNode.h"
#include "stdlib.h"
#include <time.h>
#include "inet/inet_insertions/MobileNode.h"
//namespace inet {
//Register_Class(MobileNode);
Define_Module(MobileNode);
void MobileNode::initialize(){
// TO-DO: these ID shaw be UUID as in network
internalMobNodeId = this->getId() - par("simulationIndexOfFirstNode").intValue() + 1;
par("internalMobNodeId").setIntValue(internalMobNodeId);
//this->myType = static_cast<mobileNodeType>(par("nodeType").intValue());
std::cout << "UAV initialization of internalMobNodeId: " << internalMobNodeId << " Class " << this->getClassName() << "." << endl;
for (int n= 0; n< par("wayPointSetSize").intValue(); n++){
if (n == 0 ){
waypoints[n].x = 0;
waypoints[n].y = 0;
} else {
if (n % 2 == 0){
waypoints[n].x = n * 100 + internalMobNodeId * 200;
waypoints[n].y = n * 100 + internalMobNodeId * 200;
} else {
if (n % 3 == 0) {
waypoints[n].x = 2 * 100 + internalMobNodeId * 200;
waypoints[n].y = 0 * 100 + internalMobNodeId * 200;
} else {
waypoints[n].x = 0 * 100 + internalMobNodeId * 200;
waypoints[n].y = 2 * 100 + internalMobNodeId * 200;
}
}
}
waypoints[n].z = 10;// + internalMobNodeId;
}
par("nextX_0").setDoubleValue(0);
par("nextY_0").setDoubleValue(0);
par("nextZ_0").setDoubleValue(10);
par("nextX_1").setDoubleValue(0 * 100 + internalMobNodeId*100);
par("nextY_1").setDoubleValue(2 * 100 + internalMobNodeId*100);
par("nextZ_1").setDoubleValue(10);// + internalMobNodeId);
par("nextX_2").setDoubleValue(2 * 100 + internalMobNodeId*100);
par("nextY_2").setDoubleValue(2 * 100 + internalMobNodeId*100);
par("nextZ_2").setDoubleValue(10);// + internalMobNodeId);
par("nextX_3").setDoubleValue(2 * 100 + internalMobNodeId*100);
par("nextY_3").setDoubleValue(0 * 100 + internalMobNodeId*100);
par("nextZ_3").setDoubleValue(10);// + internalMobNodeId);
}
int MobileNode::processMessage(inet::Packet *msg) {
// O getname é o payload
std::cout << "UAV-" << internalMobNodeId << " received: " << msg->getName() << endl;
return 1;
}
string MobileNode::generateNextPacketToSend(){
std::ostringstream payload;
payload << "Hi from " << "UAV-" << internalMobNodeId << "{" << ++sentMsgs << "}" << endl;
return payload.str().c_str();
};
int MobileNode::refreshNextWayPoint() {
//int um = 1;
//std::cout << "\n\nrefreshNextWayPoint() = " << par("internalMobNodeId").intValue() << endl;
return internalMobNodeId;
}
void MobileNode::handleMessage(cMessage *msg) {
std::cout << " MobileNode::handleMessage: " << msg << endl;
}
//} //namespace
| [
"bruno@olivieri.com.br"
] | bruno@olivieri.com.br |
e8ef9f37e0485f383e9b869a5c93eb1aadac2844 | 917370624ba324c5a04996b3d68f31e9f0c1b5f9 | /lib/Sema/SemaDecl.cpp | 83ec34448fa8418aee2822696eb4630e8e7ee970 | [
"NCSA"
] | permissive | yuankong11/Clang-elementWise | 0137101a0adad425d464e0b801d9ee9e7ea1daf3 | 892ba3b080e34d5c7fd8da7a94832414d689da8d | refs/heads/master | 2022-01-24T21:17:41.683108 | 2019-07-07T12:52:33 | 2019-07-07T12:52:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 474,103 | cpp | //===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements semantic analysis for declarations.
//
//===----------------------------------------------------------------------===//
#include "clang/Sema/SemaInternal.h"
#include "TypeLocBuilder.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/CXXInheritance.h"
#include "clang/AST/CharUnits.h"
#include "clang/AST/CommentDiagnostic.h"
#include "clang/AST/DeclCXX.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/EvaluatedExprVisitor.h"
#include "clang/AST/ExprCXX.h"
#include "clang/AST/StmtCXX.h"
#include "clang/Basic/PartialDiagnostic.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Lex/HeaderSearch.h" // FIXME: Sema shouldn't depend on Lex
#include "clang/Lex/ModuleLoader.h" // FIXME: Sema shouldn't depend on Lex
#include "clang/Lex/Preprocessor.h" // FIXME: Sema shouldn't depend on Lex
#include "clang/Parse/ParseDiagnostic.h"
#include "clang/Sema/CXXFieldCollector.h"
#include "clang/Sema/DeclSpec.h"
#include "clang/Sema/DelayedDiagnostic.h"
#include "clang/Sema/Initialization.h"
#include "clang/Sema/Lookup.h"
#include "clang/Sema/ParsedTemplate.h"
#include "clang/Sema/Scope.h"
#include "clang/Sema/ScopeInfo.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/Triple.h"
#include <algorithm>
#include <cstring>
#include <functional>
using namespace clang;
using namespace sema;
Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) {
if (OwnedType) {
Decl *Group[2] = { OwnedType, Ptr };
return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2));
}
return DeclGroupPtrTy::make(DeclGroupRef(Ptr));
}
namespace {
class TypeNameValidatorCCC : public CorrectionCandidateCallback {
public:
TypeNameValidatorCCC(bool AllowInvalid, bool WantClass=false)
: AllowInvalidDecl(AllowInvalid), WantClassName(WantClass) {
WantExpressionKeywords = false;
WantCXXNamedCasts = false;
WantRemainingKeywords = false;
}
virtual bool ValidateCandidate(const TypoCorrection &candidate) {
if (NamedDecl *ND = candidate.getCorrectionDecl())
return (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND)) &&
(AllowInvalidDecl || !ND->isInvalidDecl());
else
return !WantClassName && candidate.isKeyword();
}
private:
bool AllowInvalidDecl;
bool WantClassName;
};
}
/// \brief Determine whether the token kind starts a simple-type-specifier.
bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const {
switch (Kind) {
// FIXME: Take into account the current language when deciding whether a
// token kind is a valid type specifier
case tok::kw_short:
case tok::kw_long:
case tok::kw___int64:
case tok::kw___int128:
case tok::kw_signed:
case tok::kw_unsigned:
case tok::kw_void:
case tok::kw_char:
case tok::kw_int:
case tok::kw_half:
case tok::kw_float:
case tok::kw_double:
case tok::kw_wchar_t:
case tok::kw_bool:
case tok::kw___underlying_type:
return true;
case tok::annot_typename:
case tok::kw_char16_t:
case tok::kw_char32_t:
case tok::kw_typeof:
case tok::kw_decltype:
return getLangOpts().CPlusPlus;
default:
break;
}
return false;
}
/// \brief If the identifier refers to a type name within this scope,
/// return the declaration of that type.
///
/// This routine performs ordinary name lookup of the identifier II
/// within the given scope, with optional C++ scope specifier SS, to
/// determine whether the name refers to a type. If so, returns an
/// opaque pointer (actually a QualType) corresponding to that
/// type. Otherwise, returns NULL.
///
/// If name lookup results in an ambiguity, this routine will complain
/// and then return NULL.
ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
Scope *S, CXXScopeSpec *SS,
bool isClassName, bool HasTrailingDot,
ParsedType ObjectTypePtr,
bool IsCtorOrDtorName,
bool WantNontrivialTypeSourceInfo,
IdentifierInfo **CorrectedII) {
// Determine where we will perform name lookup.
DeclContext *LookupCtx = 0;
if (ObjectTypePtr) {
QualType ObjectType = ObjectTypePtr.get();
if (ObjectType->isRecordType())
LookupCtx = computeDeclContext(ObjectType);
} else if (SS && SS->isNotEmpty()) {
LookupCtx = computeDeclContext(*SS, false);
if (!LookupCtx) {
if (isDependentScopeSpecifier(*SS)) {
// C++ [temp.res]p3:
// A qualified-id that refers to a type and in which the
// nested-name-specifier depends on a template-parameter (14.6.2)
// shall be prefixed by the keyword typename to indicate that the
// qualified-id denotes a type, forming an
// elaborated-type-specifier (7.1.5.3).
//
// We therefore do not perform any name lookup if the result would
// refer to a member of an unknown specialization.
if (!isClassName && !IsCtorOrDtorName)
return ParsedType();
// We know from the grammar that this name refers to a type,
// so build a dependent node to describe the type.
if (WantNontrivialTypeSourceInfo)
return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get();
NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context);
QualType T =
CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc,
II, NameLoc);
return ParsedType::make(T);
}
return ParsedType();
}
if (!LookupCtx->isDependentContext() &&
RequireCompleteDeclContext(*SS, LookupCtx))
return ParsedType();
}
// FIXME: LookupNestedNameSpecifierName isn't the right kind of
// lookup for class-names.
LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName :
LookupOrdinaryName;
LookupResult Result(*this, &II, NameLoc, Kind);
if (LookupCtx) {
// Perform "qualified" name lookup into the declaration context we
// computed, which is either the type of the base of a member access
// expression or the declaration context associated with a prior
// nested-name-specifier.
LookupQualifiedName(Result, LookupCtx);
if (ObjectTypePtr && Result.empty()) {
// C++ [basic.lookup.classref]p3:
// If the unqualified-id is ~type-name, the type-name is looked up
// in the context of the entire postfix-expression. If the type T of
// the object expression is of a class type C, the type-name is also
// looked up in the scope of class C. At least one of the lookups shall
// find a name that refers to (possibly cv-qualified) T.
LookupName(Result, S);
}
} else {
// Perform unqualified name lookup.
LookupName(Result, S);
}
NamedDecl *IIDecl = 0;
switch (Result.getResultKind()) {
case LookupResult::NotFound:
case LookupResult::NotFoundInCurrentInstantiation:
if (CorrectedII) {
TypeNameValidatorCCC Validator(true, isClassName);
TypoCorrection Correction = CorrectTypo(Result.getLookupNameInfo(),
Kind, S, SS, Validator);
IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo();
TemplateTy Template;
bool MemberOfUnknownSpecialization;
UnqualifiedId TemplateName;
TemplateName.setIdentifier(NewII, NameLoc);
NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier();
CXXScopeSpec NewSS, *NewSSPtr = SS;
if (SS && NNS) {
NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
NewSSPtr = &NewSS;
}
if (Correction && (NNS || NewII != &II) &&
// Ignore a correction to a template type as the to-be-corrected
// identifier is not a template (typo correction for template names
// is handled elsewhere).
!(getLangOpts().CPlusPlus && NewSSPtr &&
isTemplateName(S, *NewSSPtr, false, TemplateName, ParsedType(),
false, Template, MemberOfUnknownSpecialization))) {
ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr,
isClassName, HasTrailingDot, ObjectTypePtr,
IsCtorOrDtorName,
WantNontrivialTypeSourceInfo);
if (Ty) {
std::string CorrectedStr(Correction.getAsString(getLangOpts()));
std::string CorrectedQuotedStr(
Correction.getQuoted(getLangOpts()));
Diag(NameLoc, diag::err_unknown_type_or_class_name_suggest)
<< Result.getLookupName() << CorrectedQuotedStr << isClassName
<< FixItHint::CreateReplacement(SourceRange(NameLoc),
CorrectedStr);
if (NamedDecl *FirstDecl = Correction.getCorrectionDecl())
Diag(FirstDecl->getLocation(), diag::note_previous_decl)
<< CorrectedQuotedStr;
if (SS && NNS)
SS->MakeTrivial(Context, NNS, SourceRange(NameLoc));
*CorrectedII = NewII;
return Ty;
}
}
}
// If typo correction failed or was not performed, fall through
case LookupResult::FoundOverloaded:
case LookupResult::FoundUnresolvedValue:
Result.suppressDiagnostics();
return ParsedType();
case LookupResult::Ambiguous:
// Recover from type-hiding ambiguities by hiding the type. We'll
// do the lookup again when looking for an object, and we can
// diagnose the error then. If we don't do this, then the error
// about hiding the type will be immediately followed by an error
// that only makes sense if the identifier was treated like a type.
if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) {
Result.suppressDiagnostics();
return ParsedType();
}
// Look to see if we have a type anywhere in the list of results.
for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
Res != ResEnd; ++Res) {
if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
if (!IIDecl ||
(*Res)->getLocation().getRawEncoding() <
IIDecl->getLocation().getRawEncoding())
IIDecl = *Res;
}
}
if (!IIDecl) {
// None of the entities we found is a type, so there is no way
// to even assume that the result is a type. In this case, don't
// complain about the ambiguity. The parser will either try to
// perform this lookup again (e.g., as an object name), which
// will produce the ambiguity, or will complain that it expected
// a type name.
Result.suppressDiagnostics();
return ParsedType();
}
// We found a type within the ambiguous lookup; diagnose the
// ambiguity and then return that type. This might be the right
// answer, or it might not be, but it suppresses any attempt to
// perform the name lookup again.
break;
case LookupResult::Found:
IIDecl = Result.getFoundDecl();
break;
}
assert(IIDecl && "Didn't find decl");
QualType T;
if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
DiagnoseUseOfDecl(IIDecl, NameLoc);
if (T.isNull())
T = Context.getTypeDeclType(TD);
// NOTE: avoid constructing an ElaboratedType(Loc) if this is a
// constructor or destructor name (in such a case, the scope specifier
// will be attached to the enclosing Expr or Decl node).
if (SS && SS->isNotEmpty() && !IsCtorOrDtorName) {
if (WantNontrivialTypeSourceInfo) {
// Construct a type with type-source information.
TypeLocBuilder Builder;
Builder.pushTypeSpec(T).setNameLoc(NameLoc);
T = getElaboratedType(ETK_None, *SS, T);
ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
ElabTL.setElaboratedKeywordLoc(SourceLocation());
ElabTL.setQualifierLoc(SS->getWithLocInContext(Context));
return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
} else {
T = getElaboratedType(ETK_None, *SS, T);
}
}
} else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
(void)DiagnoseUseOfDecl(IDecl, NameLoc);
if (!HasTrailingDot)
T = Context.getObjCInterfaceType(IDecl);
}
if (T.isNull()) {
// If it's not plausibly a type, suppress diagnostics.
Result.suppressDiagnostics();
return ParsedType();
}
return ParsedType::make(T);
}
/// isTagName() - This method is called *for error recovery purposes only*
/// to determine if the specified name is a valid tag name ("struct foo"). If
/// so, this returns the TST for the tag corresponding to it (TST_enum,
/// TST_union, TST_struct, TST_interface, TST_class). This is used to diagnose
/// cases in C where the user forgot to specify the tag.
DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
// Do a tag name lookup in this scope.
LookupResult R(*this, &II, SourceLocation(), LookupTagName);
LookupName(R, S, false);
R.suppressDiagnostics();
if (R.getResultKind() == LookupResult::Found)
if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
switch (TD->getTagKind()) {
case TTK_Struct: return DeclSpec::TST_struct;
case TTK_Interface: return DeclSpec::TST_interface;
case TTK_Union: return DeclSpec::TST_union;
case TTK_Class: return DeclSpec::TST_class;
case TTK_Enum: return DeclSpec::TST_enum;
}
}
return DeclSpec::TST_unspecified;
}
/// isMicrosoftMissingTypename - In Microsoft mode, within class scope,
/// if a CXXScopeSpec's type is equal to the type of one of the base classes
/// then downgrade the missing typename error to a warning.
/// This is needed for MSVC compatibility; Example:
/// @code
/// template<class T> class A {
/// public:
/// typedef int TYPE;
/// };
/// template<class T> class B : public A<T> {
/// public:
/// A<T>::TYPE a; // no typename required because A<T> is a base class.
/// };
/// @endcode
bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) {
if (CurContext->isRecord()) {
const Type *Ty = SS->getScopeRep()->getAsType();
CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext);
for (CXXRecordDecl::base_class_const_iterator Base = RD->bases_begin(),
BaseEnd = RD->bases_end(); Base != BaseEnd; ++Base)
if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base->getType()))
return true;
return S->isFunctionPrototypeScope();
}
return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope();
}
bool Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II,
SourceLocation IILoc,
Scope *S,
CXXScopeSpec *SS,
ParsedType &SuggestedType) {
// We don't have anything to suggest (yet).
SuggestedType = ParsedType();
// There may have been a typo in the name of the type. Look up typo
// results, in case we have something that we can suggest.
TypeNameValidatorCCC Validator(false);
if (TypoCorrection Corrected = CorrectTypo(DeclarationNameInfo(II, IILoc),
LookupOrdinaryName, S, SS,
Validator)) {
std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOpts()));
if (Corrected.isKeyword()) {
// We corrected to a keyword.
IdentifierInfo *NewII = Corrected.getCorrectionAsIdentifierInfo();
if (!isSimpleTypeSpecifier(NewII->getTokenID()))
CorrectedQuotedStr = "the keyword " + CorrectedQuotedStr;
Diag(IILoc, diag::err_unknown_typename_suggest)
<< II << CorrectedQuotedStr
<< FixItHint::CreateReplacement(SourceRange(IILoc), CorrectedStr);
II = NewII;
} else {
NamedDecl *Result = Corrected.getCorrectionDecl();
// We found a similarly-named type or interface; suggest that.
if (!SS || !SS->isSet())
Diag(IILoc, diag::err_unknown_typename_suggest)
<< II << CorrectedQuotedStr
<< FixItHint::CreateReplacement(SourceRange(IILoc), CorrectedStr);
else if (DeclContext *DC = computeDeclContext(*SS, false))
Diag(IILoc, diag::err_unknown_nested_typename_suggest)
<< II << DC << CorrectedQuotedStr << SS->getRange()
<< FixItHint::CreateReplacement(Corrected.getCorrectionRange(),
CorrectedStr);
else
llvm_unreachable("could not have corrected a typo here");
Diag(Result->getLocation(), diag::note_previous_decl)
<< CorrectedQuotedStr;
SuggestedType = getTypeName(*Result->getIdentifier(), IILoc, S, SS,
false, false, ParsedType(),
/*IsCtorOrDtorName=*/false,
/*NonTrivialTypeSourceInfo=*/true);
}
return true;
}
if (getLangOpts().CPlusPlus) {
// See if II is a class template that the user forgot to pass arguments to.
UnqualifiedId Name;
Name.setIdentifier(II, IILoc);
CXXScopeSpec EmptySS;
TemplateTy TemplateResult;
bool MemberOfUnknownSpecialization;
if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false,
Name, ParsedType(), true, TemplateResult,
MemberOfUnknownSpecialization) == TNK_Type_template) {
TemplateName TplName = TemplateResult.getAsVal<TemplateName>();
Diag(IILoc, diag::err_template_missing_args) << TplName;
if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) {
Diag(TplDecl->getLocation(), diag::note_template_decl_here)
<< TplDecl->getTemplateParameters()->getSourceRange();
}
return true;
}
}
// FIXME: Should we move the logic that tries to recover from a missing tag
// (struct, union, enum) from Parser::ParseImplicitInt here, instead?
if (!SS || (!SS->isSet() && !SS->isInvalid()))
Diag(IILoc, diag::err_unknown_typename) << II;
else if (DeclContext *DC = computeDeclContext(*SS, false))
Diag(IILoc, diag::err_typename_nested_not_found)
<< II << DC << SS->getRange();
else if (isDependentScopeSpecifier(*SS)) {
unsigned DiagID = diag::err_typename_missing;
if (getLangOpts().MicrosoftMode && isMicrosoftMissingTypename(SS, S))
DiagID = diag::warn_typename_missing;
Diag(SS->getRange().getBegin(), DiagID)
<< (NestedNameSpecifier *)SS->getScopeRep() << II->getName()
<< SourceRange(SS->getRange().getBegin(), IILoc)
<< FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename ");
SuggestedType = ActOnTypenameType(S, SourceLocation(),
*SS, *II, IILoc).get();
} else {
assert(SS && SS->isInvalid() &&
"Invalid scope specifier has already been diagnosed");
}
return true;
}
/// \brief Determine whether the given result set contains either a type name
/// or
static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) {
bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus &&
NextToken.is(tok::less);
for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) {
if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
return true;
if (CheckTemplate && isa<TemplateDecl>(*I))
return true;
}
return false;
}
static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result,
Scope *S, CXXScopeSpec &SS,
IdentifierInfo *&Name,
SourceLocation NameLoc) {
LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName);
SemaRef.LookupParsedName(R, S, &SS);
if (TagDecl *Tag = R.getAsSingle<TagDecl>()) {
const char *TagName = 0;
const char *FixItTagName = 0;
switch (Tag->getTagKind()) {
case TTK_Class:
TagName = "class";
FixItTagName = "class ";
break;
case TTK_Enum:
TagName = "enum";
FixItTagName = "enum ";
break;
case TTK_Struct:
TagName = "struct";
FixItTagName = "struct ";
break;
case TTK_Interface:
TagName = "__interface";
FixItTagName = "__interface ";
break;
case TTK_Union:
TagName = "union";
FixItTagName = "union ";
break;
}
SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
<< Name << TagName << SemaRef.getLangOpts().CPlusPlus
<< FixItHint::CreateInsertion(NameLoc, FixItTagName);
for (LookupResult::iterator I = Result.begin(), IEnd = Result.end();
I != IEnd; ++I)
SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
<< Name << TagName;
// Replace lookup results with just the tag decl.
Result.clear(Sema::LookupTagName);
SemaRef.LookupParsedName(Result, S, &SS);
return true;
}
return false;
}
/// Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS,
QualType T, SourceLocation NameLoc) {
ASTContext &Context = S.Context;
TypeLocBuilder Builder;
Builder.pushTypeSpec(T).setNameLoc(NameLoc);
T = S.getElaboratedType(ETK_None, SS, T);
ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
ElabTL.setElaboratedKeywordLoc(SourceLocation());
ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
}
Sema::NameClassification Sema::ClassifyName(Scope *S,
CXXScopeSpec &SS,
IdentifierInfo *&Name,
SourceLocation NameLoc,
const Token &NextToken,
bool IsAddressOfOperand,
CorrectionCandidateCallback *CCC) {
DeclarationNameInfo NameInfo(Name, NameLoc);
ObjCMethodDecl *CurMethod = getCurMethodDecl();
if (NextToken.is(tok::coloncolon)) {
BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(),
QualType(), false, SS, 0, false);
}
LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
LookupParsedName(Result, S, &SS, !CurMethod);
// Perform lookup for Objective-C instance variables (including automatically
// synthesized instance variables), if we're in an Objective-C method.
// FIXME: This lookup really, really needs to be folded in to the normal
// unqualified lookup mechanism.
if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
ExprResult E = LookupInObjCMethod(Result, S, Name, true);
if (E.get() || E.isInvalid())
return E;
}
bool SecondTry = false;
bool IsFilteredTemplateName = false;
Corrected:
switch (Result.getResultKind()) {
case LookupResult::NotFound:
// If an unqualified-id is followed by a '(', then we have a function
// call.
if (!SS.isSet() && NextToken.is(tok::l_paren)) {
// In C++, this is an ADL-only call.
// FIXME: Reference?
if (getLangOpts().CPlusPlus)
return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true);
// C90 6.3.2.2:
// If the expression that precedes the parenthesized argument list in a
// function call consists solely of an identifier, and if no
// declaration is visible for this identifier, the identifier is
// implicitly declared exactly as if, in the innermost block containing
// the function call, the declaration
//
// extern int identifier ();
//
// appeared.
//
// We also allow this in C99 as an extension.
if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) {
Result.addDecl(D);
Result.resolveKind();
return BuildDeclarationNameExpr(SS, Result, /*ADL=*/false);
}
}
// In C, we first see whether there is a tag type by the same name, in
// which case it's likely that the user just forget to write "enum",
// "struct", or "union".
if (!getLangOpts().CPlusPlus && !SecondTry &&
isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
break;
}
// Perform typo correction to determine if there is another name that is
// close to this name.
if (!SecondTry && CCC) {
SecondTry = true;
if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(),
Result.getLookupKind(), S,
&SS, *CCC)) {
unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
unsigned QualifiedDiag = diag::err_no_member_suggest;
std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
std::string CorrectedQuotedStr(Corrected.getQuoted(getLangOpts()));
NamedDecl *FirstDecl = Corrected.getCorrectionDecl();
NamedDecl *UnderlyingFirstDecl
= FirstDecl? FirstDecl->getUnderlyingDecl() : 0;
if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
UnqualifiedDiag = diag::err_no_template_suggest;
QualifiedDiag = diag::err_no_member_template_suggest;
} else if (UnderlyingFirstDecl &&
(isa<TypeDecl>(UnderlyingFirstDecl) ||
isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
UnqualifiedDiag = diag::err_unknown_typename_suggest;
QualifiedDiag = diag::err_unknown_nested_typename_suggest;
}
if (SS.isEmpty())
Diag(NameLoc, UnqualifiedDiag)
<< Name << CorrectedQuotedStr
<< FixItHint::CreateReplacement(NameLoc, CorrectedStr);
else // FIXME: is this even reachable? Test it.
Diag(NameLoc, QualifiedDiag)
<< Name << computeDeclContext(SS, false) << CorrectedQuotedStr
<< SS.getRange()
<< FixItHint::CreateReplacement(Corrected.getCorrectionRange(),
CorrectedStr);
// Update the name, so that the caller has the new name.
Name = Corrected.getCorrectionAsIdentifierInfo();
// Typo correction corrected to a keyword.
if (Corrected.isKeyword())
return Corrected.getCorrectionAsIdentifierInfo();
// Also update the LookupResult...
// FIXME: This should probably go away at some point
Result.clear();
Result.setLookupName(Corrected.getCorrection());
if (FirstDecl) {
Result.addDecl(FirstDecl);
Diag(FirstDecl->getLocation(), diag::note_previous_decl)
<< CorrectedQuotedStr;
}
// If we found an Objective-C instance variable, let
// LookupInObjCMethod build the appropriate expression to
// reference the ivar.
// FIXME: This is a gross hack.
if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
Result.clear();
ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier()));
return E;
}
goto Corrected;
}
}
// We failed to correct; just fall through and let the parser deal with it.
Result.suppressDiagnostics();
return NameClassification::Unknown();
case LookupResult::NotFoundInCurrentInstantiation: {
// We performed name lookup into the current instantiation, and there were
// dependent bases, so we treat this result the same way as any other
// dependent nested-name-specifier.
// C++ [temp.res]p2:
// A name used in a template declaration or definition and that is
// dependent on a template-parameter is assumed not to name a type
// unless the applicable name lookup finds a type name or the name is
// qualified by the keyword typename.
//
// FIXME: If the next token is '<', we might want to ask the parser to
// perform some heroics to see if we actually have a
// template-argument-list, which would indicate a missing 'template'
// keyword here.
return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(),
NameInfo, IsAddressOfOperand,
/*TemplateArgs=*/0);
}
case LookupResult::Found:
case LookupResult::FoundOverloaded:
case LookupResult::FoundUnresolvedValue:
break;
case LookupResult::Ambiguous:
if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
hasAnyAcceptableTemplateNames(Result)) {
// C++ [temp.local]p3:
// A lookup that finds an injected-class-name (10.2) can result in an
// ambiguity in certain cases (for example, if it is found in more than
// one base class). If all of the injected-class-names that are found
// refer to specializations of the same class template, and if the name
// is followed by a template-argument-list, the reference refers to the
// class template itself and not a specialization thereof, and is not
// ambiguous.
//
// This filtering can make an ambiguous result into an unambiguous one,
// so try again after filtering out template names.
FilterAcceptableTemplateNames(Result);
if (!Result.isAmbiguous()) {
IsFilteredTemplateName = true;
break;
}
}
// Diagnose the ambiguity and return an error.
return NameClassification::Error();
}
if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
(IsFilteredTemplateName || hasAnyAcceptableTemplateNames(Result))) {
// C++ [temp.names]p3:
// After name lookup (3.4) finds that a name is a template-name or that
// an operator-function-id or a literal- operator-id refers to a set of
// overloaded functions any member of which is a function template if
// this is followed by a <, the < is always taken as the delimiter of a
// template-argument-list and never as the less-than operator.
if (!IsFilteredTemplateName)
FilterAcceptableTemplateNames(Result);
if (!Result.empty()) {
bool IsFunctionTemplate;
TemplateName Template;
if (Result.end() - Result.begin() > 1) {
IsFunctionTemplate = true;
Template = Context.getOverloadedTemplateName(Result.begin(),
Result.end());
} else {
TemplateDecl *TD
= cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl());
IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
if (SS.isSet() && !SS.isInvalid())
Template = Context.getQualifiedTemplateName(SS.getScopeRep(),
/*TemplateKeyword=*/false,
TD);
else
Template = TemplateName(TD);
}
if (IsFunctionTemplate) {
// Function templates always go through overload resolution, at which
// point we'll perform the various checks (e.g., accessibility) we need
// to based on which function we selected.
Result.suppressDiagnostics();
return NameClassification::FunctionTemplate(Template);
}
return NameClassification::TypeTemplate(Template);
}
}
NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl();
if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) {
DiagnoseUseOfDecl(Type, NameLoc);
QualType T = Context.getTypeDeclType(Type);
if (SS.isNotEmpty())
return buildNestedType(*this, SS, T, NameLoc);
return ParsedType::make(T);
}
ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl);
if (!Class) {
// FIXME: It's unfortunate that we don't have a Type node for handling this.
if (ObjCCompatibleAliasDecl *Alias
= dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl))
Class = Alias->getClassInterface();
}
if (Class) {
DiagnoseUseOfDecl(Class, NameLoc);
if (NextToken.is(tok::period)) {
// Interface. <something> is parsed as a property reference expression.
// Just return "unknown" as a fall-through for now.
Result.suppressDiagnostics();
return NameClassification::Unknown();
}
QualType T = Context.getObjCInterfaceType(Class);
return ParsedType::make(T);
}
// We can have a type template here if we're classifying a template argument.
if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl))
return NameClassification::TypeTemplate(
TemplateName(cast<TemplateDecl>(FirstDecl)));
// Check for a tag type hidden by a non-type decl in a few cases where it
// seems likely a type is wanted instead of the non-type that was found.
if (!getLangOpts().ObjC1) {
bool NextIsOp = NextToken.is(tok::amp) || NextToken.is(tok::star);
if ((NextToken.is(tok::identifier) ||
(NextIsOp && FirstDecl->isFunctionOrFunctionTemplate())) &&
isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
TypeDecl *Type = Result.getAsSingle<TypeDecl>();
DiagnoseUseOfDecl(Type, NameLoc);
QualType T = Context.getTypeDeclType(Type);
if (SS.isNotEmpty())
return buildNestedType(*this, SS, T, NameLoc);
return ParsedType::make(T);
}
}
if (FirstDecl->isCXXClassMember())
return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result, 0);
bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
return BuildDeclarationNameExpr(SS, Result, ADL);
}
// Determines the context to return to after temporarily entering a
// context. This depends in an unnecessarily complicated way on the
// exact ordering of callbacks from the parser.
DeclContext *Sema::getContainingDC(DeclContext *DC) {
// Functions defined inline within classes aren't parsed until we've
// finished parsing the top-level class, so the top-level class is
// the context we'll need to return to.
if (isa<FunctionDecl>(DC)) {
DC = DC->getLexicalParent();
// A function not defined within a class will always return to its
// lexical context.
if (!isa<CXXRecordDecl>(DC))
return DC;
// A C++ inline method/friend is parsed *after* the topmost class
// it was declared in is fully parsed ("complete"); the topmost
// class is the context we need to return to.
while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
DC = RD;
// Return the declaration context of the topmost class the inline method is
// declared in.
return DC;
}
return DC->getLexicalParent();
}
void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
assert(getContainingDC(DC) == CurContext &&
"The next DeclContext should be lexically contained in the current one.");
CurContext = DC;
S->setEntity(DC);
}
void Sema::PopDeclContext() {
assert(CurContext && "DeclContext imbalance!");
CurContext = getContainingDC(CurContext);
assert(CurContext && "Popped translation unit!");
}
/// EnterDeclaratorContext - Used when we must lookup names in the context
/// of a declarator's nested name specifier.
///
void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
// C++0x [basic.lookup.unqual]p13:
// A name used in the definition of a static data member of class
// X (after the qualified-id of the static member) is looked up as
// if the name was used in a member function of X.
// C++0x [basic.lookup.unqual]p14:
// If a variable member of a namespace is defined outside of the
// scope of its namespace then any name used in the definition of
// the variable member (after the declarator-id) is looked up as
// if the definition of the variable member occurred in its
// namespace.
// Both of these imply that we should push a scope whose context
// is the semantic context of the declaration. We can't use
// PushDeclContext here because that context is not necessarily
// lexically contained in the current context. Fortunately,
// the containing scope should have the appropriate information.
assert(!S->getEntity() && "scope already has entity");
#ifndef NDEBUG
Scope *Ancestor = S->getParent();
while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
#endif
CurContext = DC;
S->setEntity(DC);
}
void Sema::ExitDeclaratorContext(Scope *S) {
assert(S->getEntity() == CurContext && "Context imbalance!");
// Switch back to the lexical context. The safety of this is
// enforced by an assert in EnterDeclaratorContext.
Scope *Ancestor = S->getParent();
while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
CurContext = (DeclContext*) Ancestor->getEntity();
// We don't need to do anything with the scope, which is going to
// disappear.
}
void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) {
FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
if (FunctionTemplateDecl *TFD = dyn_cast_or_null<FunctionTemplateDecl>(D)) {
// We assume that the caller has already called
// ActOnReenterTemplateScope
FD = TFD->getTemplatedDecl();
}
if (!FD)
return;
// Same implementation as PushDeclContext, but enters the context
// from the lexical parent, rather than the top-level class.
assert(CurContext == FD->getLexicalParent() &&
"The next DeclContext should be lexically contained in the current one.");
CurContext = FD;
S->setEntity(CurContext);
for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) {
ParmVarDecl *Param = FD->getParamDecl(P);
// If the parameter has an identifier, then add it to the scope
if (Param->getIdentifier()) {
S->AddDecl(Param);
IdResolver.AddDecl(Param);
}
}
}
void Sema::ActOnExitFunctionContext() {
// Same implementation as PopDeclContext, but returns to the lexical parent,
// rather than the top-level class.
assert(CurContext && "DeclContext imbalance!");
CurContext = CurContext->getLexicalParent();
assert(CurContext && "Popped translation unit!");
}
/// \brief Determine whether we allow overloading of the function
/// PrevDecl with another declaration.
///
/// This routine determines whether overloading is possible, not
/// whether some new function is actually an overload. It will return
/// true in C++ (where we can always provide overloads) or, as an
/// extension, in C when the previous function is already an
/// overloaded function declaration or has the "overloadable"
/// attribute.
static bool AllowOverloadingOfFunction(LookupResult &Previous,
ASTContext &Context) {
if (Context.getLangOpts().CPlusPlus)
return true;
if (Previous.getResultKind() == LookupResult::FoundOverloaded)
return true;
return (Previous.getResultKind() == LookupResult::Found
&& Previous.getFoundDecl()->hasAttr<OverloadableAttr>());
}
/// Add this decl to the scope shadowed decl chains.
void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
// Move up the scope chain until we find the nearest enclosing
// non-transparent context. The declaration will be introduced into this
// scope.
while (S->getEntity() &&
((DeclContext *)S->getEntity())->isTransparentContext())
S = S->getParent();
// Add scoped declarations into their context, so that they can be
// found later. Declarations without a context won't be inserted
// into any context.
if (AddToContext)
CurContext->addDecl(D);
// Out-of-line definitions shouldn't be pushed into scope in C++.
// Out-of-line variable and function definitions shouldn't even in C.
if ((getLangOpts().CPlusPlus || isa<VarDecl>(D) || isa<FunctionDecl>(D)) &&
D->isOutOfLine() &&
!D->getDeclContext()->getRedeclContext()->Equals(
D->getLexicalDeclContext()->getRedeclContext()))
return;
// Template instantiations should also not be pushed into scope.
if (isa<FunctionDecl>(D) &&
cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
return;
// If this replaces anything in the current scope,
IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
IEnd = IdResolver.end();
for (; I != IEnd; ++I) {
if (S->isDeclScope(*I) && D->declarationReplaces(*I)) {
S->RemoveDecl(*I);
IdResolver.RemoveDecl(*I);
// Should only need to replace one decl.
break;
}
}
S->AddDecl(D);
if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
// Implicitly-generated labels may end up getting generated in an order that
// isn't strictly lexical, which breaks name lookup. Be careful to insert
// the label at the appropriate place in the identifier chain.
for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) {
DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext();
if (IDC == CurContext) {
if (!S->isDeclScope(*I))
continue;
} else if (IDC->Encloses(CurContext))
break;
}
IdResolver.InsertDeclAfter(I, D);
} else {
IdResolver.AddDecl(D);
}
}
void Sema::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope)
TUScope->AddDecl(D);
}
bool Sema::isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S,
bool ExplicitInstantiationOrSpecialization) {
return IdResolver.isDeclInScope(D, Ctx, S,
ExplicitInstantiationOrSpecialization);
}
Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) {
DeclContext *TargetDC = DC->getPrimaryContext();
do {
if (DeclContext *ScopeDC = (DeclContext*) S->getEntity())
if (ScopeDC->getPrimaryContext() == TargetDC)
return S;
} while ((S = S->getParent()));
return 0;
}
static bool isOutOfScopePreviousDeclaration(NamedDecl *,
DeclContext*,
ASTContext&);
/// Filters out lookup results that don't fall within the given scope
/// as determined by isDeclInScope.
void Sema::FilterLookupForScope(LookupResult &R,
DeclContext *Ctx, Scope *S,
bool ConsiderLinkage,
bool ExplicitInstantiationOrSpecialization) {
LookupResult::Filter F = R.makeFilter();
while (F.hasNext()) {
NamedDecl *D = F.next();
if (isDeclInScope(D, Ctx, S, ExplicitInstantiationOrSpecialization))
continue;
if (ConsiderLinkage &&
isOutOfScopePreviousDeclaration(D, Ctx, Context))
continue;
F.erase();
}
F.done();
}
static bool isUsingDecl(NamedDecl *D) {
return isa<UsingShadowDecl>(D) ||
isa<UnresolvedUsingTypenameDecl>(D) ||
isa<UnresolvedUsingValueDecl>(D);
}
/// Removes using shadow declarations from the lookup results.
static void RemoveUsingDecls(LookupResult &R) {
LookupResult::Filter F = R.makeFilter();
while (F.hasNext())
if (isUsingDecl(F.next()))
F.erase();
F.done();
}
/// \brief Check for this common pattern:
/// @code
/// class S {
/// S(const S&); // DO NOT IMPLEMENT
/// void operator=(const S&); // DO NOT IMPLEMENT
/// };
/// @endcode
static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) {
// FIXME: Should check for private access too but access is set after we get
// the decl here.
if (D->doesThisDeclarationHaveABody())
return false;
if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
return CD->isCopyConstructor();
if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
return Method->isCopyAssignmentOperator();
return false;
}
// We need this to handle
//
// typedef struct {
// void *foo() { return 0; }
// } A;
//
// When we see foo we don't know if after the typedef we will get 'A' or '*A'
// for example. If 'A', foo will have external linkage. If we have '*A',
// foo will have no linkage. Since we can't know untill we get to the end
// of the typedef, this function finds out if D might have non external linkage.
// Callers should verify at the end of the TU if it D has external linkage or
// not.
bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) {
const DeclContext *DC = D->getDeclContext();
while (!DC->isTranslationUnit()) {
if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
if (!RD->hasNameForLinkage())
return true;
}
DC = DC->getParent();
}
return !D->hasExternalLinkage();
}
bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const {
assert(D);
if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>())
return false;
// Ignore class templates.
if (D->getDeclContext()->isDependentContext() ||
D->getLexicalDeclContext()->isDependentContext())
return false;
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
return false;
if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD))
return false;
} else {
// 'static inline' functions are used in headers; don't warn.
// Make sure we get the storage class from the canonical declaration,
// since otherwise we will get spurious warnings on specialized
// static template functions.
if (FD->getCanonicalDecl()->getStorageClass() == SC_Static &&
FD->isInlineSpecified())
return false;
}
if (FD->doesThisDeclarationHaveABody() &&
Context.DeclMustBeEmitted(FD))
return false;
} else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
// Don't warn on variables of const-qualified or reference type, since their
// values can be used even if though they're not odr-used, and because const
// qualified variables can appear in headers in contexts where they're not
// intended to be used.
// FIXME: Use more principled rules for these exemptions.
if (!VD->isFileVarDecl() ||
VD->getType().isConstQualified() ||
VD->getType()->isReferenceType() ||
Context.DeclMustBeEmitted(VD))
return false;
if (VD->isStaticDataMember() &&
VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
return false;
} else {
return false;
}
// Only warn for unused decls internal to the translation unit.
return mightHaveNonExternalLinkage(D);
}
void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) {
if (!D)
return;
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
const FunctionDecl *First = FD->getFirstDeclaration();
if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First))
return; // First should already be in the vector.
}
if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
const VarDecl *First = VD->getFirstDeclaration();
if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First))
return; // First should already be in the vector.
}
if (ShouldWarnIfUnusedFileScopedDecl(D))
UnusedFileScopedDecls.push_back(D);
}
static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
if (D->isInvalidDecl())
return false;
if (D->isReferenced() || D->isUsed() || D->hasAttr<UnusedAttr>())
return false;
if (isa<LabelDecl>(D))
return true;
// White-list anything that isn't a local variable.
if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) ||
!D->getDeclContext()->isFunctionOrMethod())
return false;
// Types of valid local variables should be complete, so this should succeed.
if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
// White-list anything with an __attribute__((unused)) type.
QualType Ty = VD->getType();
// Only look at the outermost level of typedef.
if (const TypedefType *TT = Ty->getAs<TypedefType>()) {
if (TT->getDecl()->hasAttr<UnusedAttr>())
return false;
}
// If we failed to complete the type for some reason, or if the type is
// dependent, don't diagnose the variable.
if (Ty->isIncompleteType() || Ty->isDependentType())
return false;
if (const TagType *TT = Ty->getAs<TagType>()) {
const TagDecl *Tag = TT->getDecl();
if (Tag->hasAttr<UnusedAttr>())
return false;
if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
if (!RD->hasTrivialDestructor())
return false;
if (const Expr *Init = VD->getInit()) {
if (const ExprWithCleanups *Cleanups = dyn_cast<ExprWithCleanups>(Init))
Init = Cleanups->getSubExpr();
const CXXConstructExpr *Construct =
dyn_cast<CXXConstructExpr>(Init);
if (Construct && !Construct->isElidable()) {
CXXConstructorDecl *CD = Construct->getConstructor();
if (!CD->isTrivial())
return false;
}
}
}
}
// TODO: __attribute__((unused)) templates?
}
return true;
}
static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx,
FixItHint &Hint) {
if (isa<LabelDecl>(D)) {
SourceLocation AfterColon = Lexer::findLocationAfterToken(D->getLocEnd(),
tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), true);
if (AfterColon.isInvalid())
return;
Hint = FixItHint::CreateRemoval(CharSourceRange::
getCharRange(D->getLocStart(), AfterColon));
}
return;
}
/// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
/// unless they are marked attr(unused).
void Sema::DiagnoseUnusedDecl(const NamedDecl *D) {
FixItHint Hint;
if (!ShouldDiagnoseUnusedDecl(D))
return;
GenerateFixForUnusedDecl(D, Context, Hint);
unsigned DiagID;
if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
DiagID = diag::warn_unused_exception_param;
else if (isa<LabelDecl>(D))
DiagID = diag::warn_unused_label;
else
DiagID = diag::warn_unused_variable;
Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint;
}
static void CheckPoppedLabel(LabelDecl *L, Sema &S) {
// Verify that we have no forward references left. If so, there was a goto
// or address of a label taken, but no definition of it. Label fwd
// definitions are indicated with a null substmt.
if (L->getStmt() == 0)
S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName();
}
void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
if (S->decl_empty()) return;
assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
"Scope shouldn't contain decls!");
for (Scope::decl_iterator I = S->decl_begin(), E = S->decl_end();
I != E; ++I) {
Decl *TmpD = (*I);
assert(TmpD && "This decl didn't get pushed??");
assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
NamedDecl *D = cast<NamedDecl>(TmpD);
if (!D->getDeclName()) continue;
// Diagnose unused variables in this scope.
if (!S->hasUnrecoverableErrorOccurred())
DiagnoseUnusedDecl(D);
// If this was a forward reference to a label, verify it was defined.
if (LabelDecl *LD = dyn_cast<LabelDecl>(D))
CheckPoppedLabel(LD, *this);
// Remove this name from our lexical scope.
IdResolver.RemoveDecl(D);
}
}
void Sema::ActOnStartFunctionDeclarator() {
++InFunctionDeclarator;
}
void Sema::ActOnEndFunctionDeclarator() {
assert(InFunctionDeclarator);
--InFunctionDeclarator;
}
/// \brief Look for an Objective-C class in the translation unit.
///
/// \param Id The name of the Objective-C class we're looking for. If
/// typo-correction fixes this name, the Id will be updated
/// to the fixed name.
///
/// \param IdLoc The location of the name in the translation unit.
///
/// \param DoTypoCorrection If true, this routine will attempt typo correction
/// if there is no class with the given name.
///
/// \returns The declaration of the named Objective-C class, or NULL if the
/// class could not be found.
ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id,
SourceLocation IdLoc,
bool DoTypoCorrection) {
// The third "scope" argument is 0 since we aren't enabling lazy built-in
// creation from this context.
NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName);
if (!IDecl && DoTypoCorrection) {
// Perform typo correction at the given location, but only if we
// find an Objective-C class name.
DeclFilterCCC<ObjCInterfaceDecl> Validator;
if (TypoCorrection C = CorrectTypo(DeclarationNameInfo(Id, IdLoc),
LookupOrdinaryName, TUScope, NULL,
Validator)) {
IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>();
Diag(IdLoc, diag::err_undef_interface_suggest)
<< Id << IDecl->getDeclName()
<< FixItHint::CreateReplacement(IdLoc, IDecl->getNameAsString());
Diag(IDecl->getLocation(), diag::note_previous_decl)
<< IDecl->getDeclName();
Id = IDecl->getIdentifier();
}
}
ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
// This routine must always return a class definition, if any.
if (Def && Def->getDefinition())
Def = Def->getDefinition();
return Def;
}
/// getNonFieldDeclScope - Retrieves the innermost scope, starting
/// from S, where a non-field would be declared. This routine copes
/// with the difference between C and C++ scoping rules in structs and
/// unions. For example, the following code is well-formed in C but
/// ill-formed in C++:
/// @code
/// struct S6 {
/// enum { BAR } e;
/// };
///
/// void test_S6() {
/// struct S6 a;
/// a.e = BAR;
/// }
/// @endcode
/// For the declaration of BAR, this routine will return a different
/// scope. The scope S will be the scope of the unnamed enumeration
/// within S6. In C++, this routine will return the scope associated
/// with S6, because the enumeration's scope is a transparent
/// context but structures can contain non-field names. In C, this
/// routine will return the translation unit scope, since the
/// enumeration's scope is a transparent context and structures cannot
/// contain non-field names.
Scope *Sema::getNonFieldDeclScope(Scope *S) {
while (((S->getFlags() & Scope::DeclScope) == 0) ||
(S->getEntity() &&
((DeclContext *)S->getEntity())->isTransparentContext()) ||
(S->isClassScope() && !getLangOpts().CPlusPlus))
S = S->getParent();
return S;
}
/// \brief Looks up the declaration of "struct objc_super" and
/// saves it for later use in building builtin declaration of
/// objc_msgSendSuper and objc_msgSendSuper_stret. If no such
/// pre-existing declaration exists no action takes place.
static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S,
IdentifierInfo *II) {
if (!II->isStr("objc_msgSendSuper"))
return;
ASTContext &Context = ThisSema.Context;
LookupResult Result(ThisSema, &Context.Idents.get("objc_super"),
SourceLocation(), Sema::LookupTagName);
ThisSema.LookupName(Result, S);
if (Result.getResultKind() == LookupResult::Found)
if (const TagDecl *TD = Result.getAsSingle<TagDecl>())
Context.setObjCSuperType(Context.getTagDeclType(TD));
}
/// LazilyCreateBuiltin - The specified Builtin-ID was first used at
/// file scope. lazily create a decl for it. ForRedeclaration is true
/// if we're creating this built-in in anticipation of redeclaring the
/// built-in.
NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
Scope *S, bool ForRedeclaration,
SourceLocation Loc) {
LookupPredefedObjCSuperType(*this, S, II);
Builtin::ID BID = (Builtin::ID)bid;
ASTContext::GetBuiltinTypeError Error;
QualType R = Context.GetBuiltinType(BID, Error);
switch (Error) {
case ASTContext::GE_None:
// Okay
break;
case ASTContext::GE_Missing_stdio:
if (ForRedeclaration)
Diag(Loc, diag::warn_implicit_decl_requires_stdio)
<< Context.BuiltinInfo.GetName(BID);
return 0;
case ASTContext::GE_Missing_setjmp:
if (ForRedeclaration)
Diag(Loc, diag::warn_implicit_decl_requires_setjmp)
<< Context.BuiltinInfo.GetName(BID);
return 0;
case ASTContext::GE_Missing_ucontext:
if (ForRedeclaration)
Diag(Loc, diag::warn_implicit_decl_requires_ucontext)
<< Context.BuiltinInfo.GetName(BID);
return 0;
}
if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
Diag(Loc, diag::ext_implicit_lib_function_decl)
<< Context.BuiltinInfo.GetName(BID)
<< R;
if (Context.BuiltinInfo.getHeaderName(BID) &&
Diags.getDiagnosticLevel(diag::ext_implicit_lib_function_decl, Loc)
!= DiagnosticsEngine::Ignored)
Diag(Loc, diag::note_please_include_header)
<< Context.BuiltinInfo.getHeaderName(BID)
<< Context.BuiltinInfo.GetName(BID);
}
FunctionDecl *New = FunctionDecl::Create(Context,
Context.getTranslationUnitDecl(),
Loc, Loc, II, R, /*TInfo=*/0,
SC_Extern,
false,
/*hasPrototype=*/true);
New->setImplicit();
// Create Decl objects for each parameter, adding them to the
// FunctionDecl.
if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
SmallVector<ParmVarDecl*, 16> Params;
for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) {
ParmVarDecl *parm =
ParmVarDecl::Create(Context, New, SourceLocation(),
SourceLocation(), 0,
FT->getArgType(i), /*TInfo=*/0,
SC_None, 0);
parm->setScopeInfo(0, i);
Params.push_back(parm);
}
New->setParams(Params);
}
AddKnownFunctionAttributes(New);
// TUScope is the translation-unit scope to insert this function into.
// FIXME: This is hideous. We need to teach PushOnScopeChains to
// relate Scopes to DeclContexts, and probably eliminate CurContext
// entirely, but we're not there yet.
DeclContext *SavedContext = CurContext;
CurContext = Context.getTranslationUnitDecl();
PushOnScopeChains(New, TUScope);
CurContext = SavedContext;
return New;
}
/// \brief Filter out any previous declarations that the given declaration
/// should not consider because they are not permitted to conflict, e.g.,
/// because they come from hidden sub-modules and do not refer to the same
/// entity.
static void filterNonConflictingPreviousDecls(ASTContext &context,
NamedDecl *decl,
LookupResult &previous){
// This is only interesting when modules are enabled.
if (!context.getLangOpts().Modules)
return;
// Empty sets are uninteresting.
if (previous.empty())
return;
LookupResult::Filter filter = previous.makeFilter();
while (filter.hasNext()) {
NamedDecl *old = filter.next();
// Non-hidden declarations are never ignored.
if (!old->isHidden())
continue;
if (old->getLinkage() != ExternalLinkage)
filter.erase();
}
filter.done();
}
bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) {
QualType OldType;
if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
OldType = OldTypedef->getUnderlyingType();
else
OldType = Context.getTypeDeclType(Old);
QualType NewType = New->getUnderlyingType();
if (NewType->isVariablyModifiedType()) {
// Must not redefine a typedef with a variably-modified type.
int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef)
<< Kind << NewType;
if (Old->getLocation().isValid())
Diag(Old->getLocation(), diag::note_previous_definition);
New->setInvalidDecl();
return true;
}
if (OldType != NewType &&
!OldType->isDependentType() &&
!NewType->isDependentType() &&
!Context.hasSameType(OldType, NewType)) {
int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
Diag(New->getLocation(), diag::err_redefinition_different_typedef)
<< Kind << NewType << OldType;
if (Old->getLocation().isValid())
Diag(Old->getLocation(), diag::note_previous_definition);
New->setInvalidDecl();
return true;
}
return false;
}
/// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the
/// same name and scope as a previous declaration 'Old'. Figure out
/// how to resolve this situation, merging decls or emitting
/// diagnostics as appropriate. If there was an error, set New to be invalid.
///
void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) {
// If the new decl is known invalid already, don't bother doing any
// merging checks.
if (New->isInvalidDecl()) return;
// Allow multiple definitions for ObjC built-in typedefs.
// FIXME: Verify the underlying types are equivalent!
if (getLangOpts().ObjC1) {
const IdentifierInfo *TypeID = New->getIdentifier();
switch (TypeID->getLength()) {
default: break;
case 2:
{
if (!TypeID->isStr("id"))
break;
QualType T = New->getUnderlyingType();
if (!T->isPointerType())
break;
if (!T->isVoidPointerType()) {
QualType PT = T->getAs<PointerType>()->getPointeeType();
if (!PT->isStructureType())
break;
}
Context.setObjCIdRedefinitionType(T);
// Install the built-in type for 'id', ignoring the current definition.
New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
return;
}
case 5:
if (!TypeID->isStr("Class"))
break;
Context.setObjCClassRedefinitionType(New->getUnderlyingType());
// Install the built-in type for 'Class', ignoring the current definition.
New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
return;
case 3:
if (!TypeID->isStr("SEL"))
break;
Context.setObjCSelRedefinitionType(New->getUnderlyingType());
// Install the built-in type for 'SEL', ignoring the current definition.
New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
return;
}
// Fall through - the typedef name was not a builtin type.
}
// Verify the old decl was also a type.
TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
if (!Old) {
Diag(New->getLocation(), diag::err_redefinition_different_kind)
<< New->getDeclName();
NamedDecl *OldD = OldDecls.getRepresentativeDecl();
if (OldD->getLocation().isValid())
Diag(OldD->getLocation(), diag::note_previous_definition);
return New->setInvalidDecl();
}
// If the old declaration is invalid, just give up here.
if (Old->isInvalidDecl())
return New->setInvalidDecl();
// If the typedef types are not identical, reject them in all languages and
// with any extensions enabled.
if (isIncompatibleTypedef(Old, New))
return;
// The types match. Link up the redeclaration chain if the old
// declaration was a typedef.
if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old))
New->setPreviousDeclaration(Typedef);
if (getLangOpts().MicrosoftExt)
return;
if (getLangOpts().CPlusPlus) {
// C++ [dcl.typedef]p2:
// In a given non-class scope, a typedef specifier can be used to
// redefine the name of any type declared in that scope to refer
// to the type to which it already refers.
if (!isa<CXXRecordDecl>(CurContext))
return;
// C++0x [dcl.typedef]p4:
// In a given class scope, a typedef specifier can be used to redefine
// any class-name declared in that scope that is not also a typedef-name
// to refer to the type to which it already refers.
//
// This wording came in via DR424, which was a correction to the
// wording in DR56, which accidentally banned code like:
//
// struct S {
// typedef struct A { } A;
// };
//
// in the C++03 standard. We implement the C++0x semantics, which
// allow the above but disallow
//
// struct S {
// typedef int I;
// typedef int I;
// };
//
// since that was the intent of DR56.
if (!isa<TypedefNameDecl>(Old))
return;
Diag(New->getLocation(), diag::err_redefinition)
<< New->getDeclName();
Diag(Old->getLocation(), diag::note_previous_definition);
return New->setInvalidDecl();
}
// Modules always permit redefinition of typedefs, as does C11.
if (getLangOpts().Modules || getLangOpts().C11)
return;
// If we have a redefinition of a typedef in C, emit a warning. This warning
// is normally mapped to an error, but can be controlled with
// -Wtypedef-redefinition. If either the original or the redefinition is
// in a system header, don't emit this for compatibility with GCC.
if (getDiagnostics().getSuppressSystemWarnings() &&
(Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
Context.getSourceManager().isInSystemHeader(New->getLocation())))
return;
Diag(New->getLocation(), diag::warn_redefinition_of_typedef)
<< New->getDeclName();
Diag(Old->getLocation(), diag::note_previous_definition);
return;
}
/// DeclhasAttr - returns true if decl Declaration already has the target
/// attribute.
static bool
DeclHasAttr(const Decl *D, const Attr *A) {
// There can be multiple AvailabilityAttr in a Decl. Make sure we copy
// all of them. It is mergeAvailabilityAttr in SemaDeclAttr.cpp that is
// responsible for making sure they are consistent.
const AvailabilityAttr *AA = dyn_cast<AvailabilityAttr>(A);
if (AA)
return false;
// The following thread safety attributes can also be duplicated.
switch (A->getKind()) {
case attr::ExclusiveLocksRequired:
case attr::SharedLocksRequired:
case attr::LocksExcluded:
case attr::ExclusiveLockFunction:
case attr::SharedLockFunction:
case attr::UnlockFunction:
case attr::ExclusiveTrylockFunction:
case attr::SharedTrylockFunction:
case attr::GuardedBy:
case attr::PtGuardedBy:
case attr::AcquiredBefore:
case attr::AcquiredAfter:
return false;
default:
;
}
const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
for (Decl::attr_iterator i = D->attr_begin(), e = D->attr_end(); i != e; ++i)
if ((*i)->getKind() == A->getKind()) {
if (Ann) {
if (Ann->getAnnotation() == cast<AnnotateAttr>(*i)->getAnnotation())
return true;
continue;
}
// FIXME: Don't hardcode this check
if (OA && isa<OwnershipAttr>(*i))
return OA->getOwnKind() == cast<OwnershipAttr>(*i)->getOwnKind();
return true;
}
return false;
}
static bool isAttributeTargetADefinition(Decl *D) {
if (VarDecl *VD = dyn_cast<VarDecl>(D))
return VD->isThisDeclarationADefinition();
if (TagDecl *TD = dyn_cast<TagDecl>(D))
return TD->isCompleteDefinition() || TD->isBeingDefined();
return true;
}
/// Merge alignment attributes from \p Old to \p New, taking into account the
/// special semantics of C11's _Alignas specifier and C++11's alignas attribute.
///
/// \return \c true if any attributes were added to \p New.
static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {
// Look for alignas attributes on Old, and pick out whichever attribute
// specifies the strictest alignment requirement.
AlignedAttr *OldAlignasAttr = 0;
AlignedAttr *OldStrictestAlignAttr = 0;
unsigned OldAlign = 0;
for (specific_attr_iterator<AlignedAttr>
I = Old->specific_attr_begin<AlignedAttr>(),
E = Old->specific_attr_end<AlignedAttr>(); I != E; ++I) {
// FIXME: We have no way of representing inherited dependent alignments
// in a case like:
// template<int A, int B> struct alignas(A) X;
// template<int A, int B> struct alignas(B) X {};
// For now, we just ignore any alignas attributes which are not on the
// definition in such a case.
if (I->isAlignmentDependent())
return false;
if (I->isAlignas())
OldAlignasAttr = *I;
unsigned Align = I->getAlignment(S.Context);
if (Align > OldAlign) {
OldAlign = Align;
OldStrictestAlignAttr = *I;
}
}
// Look for alignas attributes on New.
AlignedAttr *NewAlignasAttr = 0;
unsigned NewAlign = 0;
for (specific_attr_iterator<AlignedAttr>
I = New->specific_attr_begin<AlignedAttr>(),
E = New->specific_attr_end<AlignedAttr>(); I != E; ++I) {
if (I->isAlignmentDependent())
return false;
if (I->isAlignas())
NewAlignasAttr = *I;
unsigned Align = I->getAlignment(S.Context);
if (Align > NewAlign)
NewAlign = Align;
}
if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
// Both declarations have 'alignas' attributes. We require them to match.
// C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but
// fall short. (If two declarations both have alignas, they must both match
// every definition, and so must match each other if there is a definition.)
// If either declaration only contains 'alignas(0)' specifiers, then it
// specifies the natural alignment for the type.
if (OldAlign == 0 || NewAlign == 0) {
QualType Ty;
if (ValueDecl *VD = dyn_cast<ValueDecl>(New))
Ty = VD->getType();
else
Ty = S.Context.getTagDeclType(cast<TagDecl>(New));
if (OldAlign == 0)
OldAlign = S.Context.getTypeAlign(Ty);
if (NewAlign == 0)
NewAlign = S.Context.getTypeAlign(Ty);
}
if (OldAlign != NewAlign) {
S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
<< (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity()
<< (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();
S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
}
}
if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {
// C++11 [dcl.align]p6:
// if any declaration of an entity has an alignment-specifier,
// every defining declaration of that entity shall specify an
// equivalent alignment.
// C11 6.7.5/7:
// If the definition of an object does not have an alignment
// specifier, any other declaration of that object shall also
// have no alignment specifier.
S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition)
<< OldAlignasAttr->isC11();
S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
<< OldAlignasAttr->isC11();
}
bool AnyAdded = false;
// Ensure we have an attribute representing the strictest alignment.
if (OldAlign > NewAlign) {
AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context);
Clone->setInherited(true);
New->addAttr(Clone);
AnyAdded = true;
}
// Ensure we have an alignas attribute if the old declaration had one.
if (OldAlignasAttr && !NewAlignasAttr &&
!(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
AlignedAttr *Clone = OldAlignasAttr->clone(S.Context);
Clone->setInherited(true);
New->addAttr(Clone);
AnyAdded = true;
}
return AnyAdded;
}
static bool mergeDeclAttribute(Sema &S, NamedDecl *D, InheritableAttr *Attr,
bool Override) {
InheritableAttr *NewAttr = NULL;
unsigned AttrSpellingListIndex = Attr->getSpellingListIndex();
if (AvailabilityAttr *AA = dyn_cast<AvailabilityAttr>(Attr))
NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(),
AA->getIntroduced(), AA->getDeprecated(),
AA->getObsoleted(), AA->getUnavailable(),
AA->getMessage(), Override,
AttrSpellingListIndex);
else if (VisibilityAttr *VA = dyn_cast<VisibilityAttr>(Attr))
NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
AttrSpellingListIndex);
else if (TypeVisibilityAttr *VA = dyn_cast<TypeVisibilityAttr>(Attr))
NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
AttrSpellingListIndex);
else if (DLLImportAttr *ImportA = dyn_cast<DLLImportAttr>(Attr))
NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(),
AttrSpellingListIndex);
else if (DLLExportAttr *ExportA = dyn_cast<DLLExportAttr>(Attr))
NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(),
AttrSpellingListIndex);
else if (FormatAttr *FA = dyn_cast<FormatAttr>(Attr))
NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(),
FA->getFormatIdx(), FA->getFirstArg(),
AttrSpellingListIndex);
else if (SectionAttr *SA = dyn_cast<SectionAttr>(Attr))
NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(),
AttrSpellingListIndex);
else if (isa<AlignedAttr>(Attr))
// AlignedAttrs are handled separately, because we need to handle all
// such attributes on a declaration at the same time.
NewAttr = 0;
else if (!DeclHasAttr(D, Attr))
NewAttr = cast<InheritableAttr>(Attr->clone(S.Context));
if (NewAttr) {
NewAttr->setInherited(true);
D->addAttr(NewAttr);
return true;
}
return false;
}
static const Decl *getDefinition(const Decl *D) {
if (const TagDecl *TD = dyn_cast<TagDecl>(D))
return TD->getDefinition();
if (const VarDecl *VD = dyn_cast<VarDecl>(D))
return VD->getDefinition();
if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
const FunctionDecl* Def;
if (FD->hasBody(Def))
return Def;
}
return NULL;
}
static bool hasAttribute(const Decl *D, attr::Kind Kind) {
for (Decl::attr_iterator I = D->attr_begin(), E = D->attr_end();
I != E; ++I) {
Attr *Attribute = *I;
if (Attribute->getKind() == Kind)
return true;
}
return false;
}
/// checkNewAttributesAfterDef - If we already have a definition, check that
/// there are no new attributes in this declaration.
static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
if (!New->hasAttrs())
return;
const Decl *Def = getDefinition(Old);
if (!Def || Def == New)
return;
AttrVec &NewAttributes = New->getAttrs();
for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
const Attr *NewAttribute = NewAttributes[I];
if (hasAttribute(Def, NewAttribute->getKind())) {
++I;
continue; // regular attr merging will take care of validating this.
}
if (isa<C11NoReturnAttr>(NewAttribute)) {
// C's _Noreturn is allowed to be added to a function after it is defined.
++I;
continue;
} else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
if (AA->isAlignas()) {
// C++11 [dcl.align]p6:
// if any declaration of an entity has an alignment-specifier,
// every defining declaration of that entity shall specify an
// equivalent alignment.
// C11 6.7.5/7:
// If the definition of an object does not have an alignment
// specifier, any other declaration of that object shall also
// have no alignment specifier.
S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition)
<< AA->isC11();
S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration)
<< AA->isC11();
NewAttributes.erase(NewAttributes.begin() + I);
--E;
continue;
}
}
S.Diag(NewAttribute->getLocation(),
diag::warn_attribute_precede_definition);
S.Diag(Def->getLocation(), diag::note_previous_definition);
NewAttributes.erase(NewAttributes.begin() + I);
--E;
}
}
/// mergeDeclAttributes - Copy attributes from the Old decl to the New one.
void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old,
AvailabilityMergeKind AMK) {
if (!Old->hasAttrs() && !New->hasAttrs())
return;
// attributes declared post-definition are currently ignored
checkNewAttributesAfterDef(*this, New, Old);
if (!Old->hasAttrs())
return;
bool foundAny = New->hasAttrs();
// Ensure that any moving of objects within the allocated map is done before
// we process them.
if (!foundAny) New->setAttrs(AttrVec());
for (specific_attr_iterator<InheritableAttr>
i = Old->specific_attr_begin<InheritableAttr>(),
e = Old->specific_attr_end<InheritableAttr>();
i != e; ++i) {
bool Override = false;
// Ignore deprecated/unavailable/availability attributes if requested.
if (isa<DeprecatedAttr>(*i) ||
isa<UnavailableAttr>(*i) ||
isa<AvailabilityAttr>(*i)) {
switch (AMK) {
case AMK_None:
continue;
case AMK_Redeclaration:
break;
case AMK_Override:
Override = true;
break;
}
}
if (mergeDeclAttribute(*this, New, *i, Override))
foundAny = true;
}
if (mergeAlignedAttrs(*this, New, Old))
foundAny = true;
if (!foundAny) New->dropAttrs();
}
/// mergeParamDeclAttributes - Copy attributes from the old parameter
/// to the new one.
static void mergeParamDeclAttributes(ParmVarDecl *newDecl,
const ParmVarDecl *oldDecl,
Sema &S) {
// C++11 [dcl.attr.depend]p2:
// The first declaration of a function shall specify the
// carries_dependency attribute for its declarator-id if any declaration
// of the function specifies the carries_dependency attribute.
if (newDecl->hasAttr<CarriesDependencyAttr>() &&
!oldDecl->hasAttr<CarriesDependencyAttr>()) {
S.Diag(newDecl->getAttr<CarriesDependencyAttr>()->getLocation(),
diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/;
// Find the first declaration of the parameter.
// FIXME: Should we build redeclaration chains for function parameters?
const FunctionDecl *FirstFD =
cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDeclaration();
const ParmVarDecl *FirstVD =
FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex());
S.Diag(FirstVD->getLocation(),
diag::note_carries_dependency_missing_first_decl) << 1/*Param*/;
}
if (!oldDecl->hasAttrs())
return;
bool foundAny = newDecl->hasAttrs();
// Ensure that any moving of objects within the allocated map is
// done before we process them.
if (!foundAny) newDecl->setAttrs(AttrVec());
for (specific_attr_iterator<InheritableParamAttr>
i = oldDecl->specific_attr_begin<InheritableParamAttr>(),
e = oldDecl->specific_attr_end<InheritableParamAttr>(); i != e; ++i) {
if (!DeclHasAttr(newDecl, *i)) {
InheritableAttr *newAttr =
cast<InheritableParamAttr>((*i)->clone(S.Context));
newAttr->setInherited(true);
newDecl->addAttr(newAttr);
foundAny = true;
}
}
if (!foundAny) newDecl->dropAttrs();
}
namespace {
/// Used in MergeFunctionDecl to keep track of function parameters in
/// C.
struct GNUCompatibleParamWarning {
ParmVarDecl *OldParm;
ParmVarDecl *NewParm;
QualType PromotedType;
};
}
/// getSpecialMember - get the special member enum for a method.
Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) {
if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
if (Ctor->isDefaultConstructor())
return Sema::CXXDefaultConstructor;
if (Ctor->isCopyConstructor())
return Sema::CXXCopyConstructor;
if (Ctor->isMoveConstructor())
return Sema::CXXMoveConstructor;
} else if (isa<CXXDestructorDecl>(MD)) {
return Sema::CXXDestructor;
} else if (MD->isCopyAssignmentOperator()) {
return Sema::CXXCopyAssignment;
} else if (MD->isMoveAssignmentOperator()) {
return Sema::CXXMoveAssignment;
}
return Sema::CXXInvalid;
}
/// canRedefineFunction - checks if a function can be redefined. Currently,
/// only extern inline functions can be redefined, and even then only in
/// GNU89 mode.
static bool canRedefineFunction(const FunctionDecl *FD,
const LangOptions& LangOpts) {
return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
!LangOpts.CPlusPlus &&
FD->isInlineSpecified() &&
FD->getStorageClass() == SC_Extern);
}
/// Is the given calling convention the ABI default for the given
/// declaration?
static bool isABIDefaultCC(Sema &S, CallingConv CC, FunctionDecl *D) {
CallingConv ABIDefaultCC;
if (isa<CXXMethodDecl>(D) && cast<CXXMethodDecl>(D)->isInstance()) {
ABIDefaultCC = S.Context.getDefaultCXXMethodCallConv(D->isVariadic());
} else {
// Free C function or a static method.
ABIDefaultCC = (S.Context.getLangOpts().MRTD ? CC_X86StdCall : CC_C);
}
return ABIDefaultCC == CC;
}
template <typename T>
static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) {
const DeclContext *DC = Old->getDeclContext();
if (DC->isRecord())
return false;
LanguageLinkage OldLinkage = Old->getLanguageLinkage();
if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext())
return true;
if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext())
return true;
return false;
}
/// MergeFunctionDecl - We just parsed a function 'New' from
/// declarator D which has the same name and scope as a previous
/// declaration 'Old'. Figure out how to resolve this situation,
/// merging decls or emitting diagnostics as appropriate.
///
/// In C++, New and Old must be declarations that are not
/// overloaded. Use IsOverload to determine whether New and Old are
/// overloaded, and to select the Old declaration that New should be
/// merged with.
///
/// Returns true if there was an error, false otherwise.
bool Sema::MergeFunctionDecl(FunctionDecl *New, Decl *OldD, Scope *S) {
// Verify the old decl was also a function.
FunctionDecl *Old = 0;
if (FunctionTemplateDecl *OldFunctionTemplate
= dyn_cast<FunctionTemplateDecl>(OldD))
Old = OldFunctionTemplate->getTemplatedDecl();
else
Old = dyn_cast<FunctionDecl>(OldD);
if (!Old) {
if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
if (New->getFriendObjectKind()) {
Diag(New->getLocation(), diag::err_using_decl_friend);
Diag(Shadow->getTargetDecl()->getLocation(),
diag::note_using_decl_target);
Diag(Shadow->getUsingDecl()->getLocation(),
diag::note_using_decl) << 0;
return true;
}
Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
Diag(Shadow->getTargetDecl()->getLocation(),
diag::note_using_decl_target);
Diag(Shadow->getUsingDecl()->getLocation(),
diag::note_using_decl) << 0;
return true;
}
Diag(New->getLocation(), diag::err_redefinition_different_kind)
<< New->getDeclName();
Diag(OldD->getLocation(), diag::note_previous_definition);
return true;
}
// Determine whether the previous declaration was a definition,
// implicit declaration, or a declaration.
diag::kind PrevDiag;
if (Old->isThisDeclarationADefinition())
PrevDiag = diag::note_previous_definition;
else if (Old->isImplicit())
PrevDiag = diag::note_previous_implicit_declaration;
else
PrevDiag = diag::note_previous_declaration;
QualType OldQType = Context.getCanonicalType(Old->getType());
QualType NewQType = Context.getCanonicalType(New->getType());
// Don't complain about this if we're in GNU89 mode and the old function
// is an extern inline function.
// Don't complain about specializations. They are not supposed to have
// storage classes.
if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
New->getStorageClass() == SC_Static &&
isExternalLinkage(Old->getLinkage()) &&
!New->getTemplateSpecializationInfo() &&
!canRedefineFunction(Old, getLangOpts())) {
if (getLangOpts().MicrosoftExt) {
Diag(New->getLocation(), diag::warn_static_non_static) << New;
Diag(Old->getLocation(), PrevDiag);
} else {
Diag(New->getLocation(), diag::err_static_non_static) << New;
Diag(Old->getLocation(), PrevDiag);
return true;
}
}
// If a function is first declared with a calling convention, but is
// later declared or defined without one, the second decl assumes the
// calling convention of the first.
//
// It's OK if a function is first declared without a calling convention,
// but is later declared or defined with the default calling convention.
//
// For the new decl, we have to look at the NON-canonical type to tell the
// difference between a function that really doesn't have a calling
// convention and one that is declared cdecl. That's because in
// canonicalization (see ASTContext.cpp), cdecl is canonicalized away
// because it is the default calling convention.
//
// Note also that we DO NOT return at this point, because we still have
// other tests to run.
const FunctionType *OldType = cast<FunctionType>(OldQType);
const FunctionType *NewType = New->getType()->getAs<FunctionType>();
FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
bool RequiresAdjustment = false;
if (OldTypeInfo.getCC() == NewTypeInfo.getCC()) {
// Fast path: nothing to do.
// Inherit the CC from the previous declaration if it was specified
// there but not here.
} else if (NewTypeInfo.getCC() == CC_Default) {
NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
RequiresAdjustment = true;
// Don't complain about mismatches when the default CC is
// effectively the same as the explict one. Only Old decl contains correct
// information about storage class of CXXMethod.
} else if (OldTypeInfo.getCC() == CC_Default &&
isABIDefaultCC(*this, NewTypeInfo.getCC(), Old)) {
NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
RequiresAdjustment = true;
} else if (!Context.isSameCallConv(OldTypeInfo.getCC(),
NewTypeInfo.getCC())) {
// Calling conventions really aren't compatible, so complain.
Diag(New->getLocation(), diag::err_cconv_change)
<< FunctionType::getNameForCallConv(NewTypeInfo.getCC())
<< (OldTypeInfo.getCC() == CC_Default)
<< (OldTypeInfo.getCC() == CC_Default ? "" :
FunctionType::getNameForCallConv(OldTypeInfo.getCC()));
Diag(Old->getLocation(), diag::note_previous_declaration);
return true;
}
// FIXME: diagnose the other way around?
if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) {
NewTypeInfo = NewTypeInfo.withNoReturn(true);
RequiresAdjustment = true;
}
// Merge regparm attribute.
if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() ||
OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
if (NewTypeInfo.getHasRegParm()) {
Diag(New->getLocation(), diag::err_regparm_mismatch)
<< NewType->getRegParmType()
<< OldType->getRegParmType();
Diag(Old->getLocation(), diag::note_previous_declaration);
return true;
}
NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm());
RequiresAdjustment = true;
}
// Merge ns_returns_retained attribute.
if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {
if (NewTypeInfo.getProducesResult()) {
Diag(New->getLocation(), diag::err_returns_retained_mismatch);
Diag(Old->getLocation(), diag::note_previous_declaration);
return true;
}
NewTypeInfo = NewTypeInfo.withProducesResult(true);
RequiresAdjustment = true;
}
if (RequiresAdjustment) {
NewType = Context.adjustFunctionType(NewType, NewTypeInfo);
New->setType(QualType(NewType, 0));
NewQType = Context.getCanonicalType(New->getType());
}
// If this redeclaration makes the function inline, we may need to add it to
// UndefinedButUsed.
if (!Old->isInlined() && New->isInlined() &&
!New->hasAttr<GNUInlineAttr>() &&
(getLangOpts().CPlusPlus || !getLangOpts().GNUInline) &&
Old->isUsed(false) &&
!Old->isDefined() && !New->isThisDeclarationADefinition())
UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
SourceLocation()));
// If this redeclaration makes it newly gnu_inline, we don't want to warn
// about it.
if (New->hasAttr<GNUInlineAttr>() &&
Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) {
UndefinedButUsed.erase(Old->getCanonicalDecl());
}
if (getLangOpts().CPlusPlus) {
// (C++98 13.1p2):
// Certain function declarations cannot be overloaded:
// -- Function declarations that differ only in the return type
// cannot be overloaded.
// Go back to the type source info to compare the declared return types,
// per C++1y [dcl.type.auto]p??:
// Redeclarations or specializations of a function or function template
// with a declared return type that uses a placeholder type shall also
// use that placeholder, not a deduced type.
QualType OldDeclaredReturnType = (Old->getTypeSourceInfo()
? Old->getTypeSourceInfo()->getType()->castAs<FunctionType>()
: OldType)->getResultType();
QualType NewDeclaredReturnType = (New->getTypeSourceInfo()
? New->getTypeSourceInfo()->getType()->castAs<FunctionType>()
: NewType)->getResultType();
QualType ResQT;
if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType)) {
if (NewDeclaredReturnType->isObjCObjectPointerType() &&
OldDeclaredReturnType->isObjCObjectPointerType())
ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
if (ResQT.isNull()) {
if (New->isCXXClassMember() && New->isOutOfLine())
Diag(New->getLocation(),
diag::err_member_def_does_not_match_ret_type) << New;
else
Diag(New->getLocation(), diag::err_ovl_diff_return_type);
Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
return true;
}
else
NewQType = ResQT;
}
QualType OldReturnType = OldType->getResultType();
QualType NewReturnType = cast<FunctionType>(NewQType)->getResultType();
if (OldReturnType != NewReturnType) {
// If this function has a deduced return type and has already been
// defined, copy the deduced value from the old declaration.
AutoType *OldAT = Old->getResultType()->getContainedAutoType();
if (OldAT && OldAT->isDeduced()) {
New->setType(SubstAutoType(New->getType(), OldAT->getDeducedType()));
NewQType = Context.getCanonicalType(
SubstAutoType(NewQType, OldAT->getDeducedType()));
}
}
const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
if (OldMethod && NewMethod) {
// Preserve triviality.
NewMethod->setTrivial(OldMethod->isTrivial());
// MSVC allows explicit template specialization at class scope:
// 2 CXMethodDecls referring to the same function will be injected.
// We don't want a redeclartion error.
bool IsClassScopeExplicitSpecialization =
OldMethod->isFunctionTemplateSpecialization() &&
NewMethod->isFunctionTemplateSpecialization();
bool isFriend = NewMethod->getFriendObjectKind();
if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
!IsClassScopeExplicitSpecialization) {
// -- Member function declarations with the same name and the
// same parameter types cannot be overloaded if any of them
// is a static member function declaration.
if (OldMethod->isStatic() || NewMethod->isStatic()) {
Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
return true;
}
// C++ [class.mem]p1:
// [...] A member shall not be declared twice in the
// member-specification, except that a nested class or member
// class template can be declared and then later defined.
if (ActiveTemplateInstantiations.empty()) {
unsigned NewDiag;
if (isa<CXXConstructorDecl>(OldMethod))
NewDiag = diag::err_constructor_redeclared;
else if (isa<CXXDestructorDecl>(NewMethod))
NewDiag = diag::err_destructor_redeclared;
else if (isa<CXXConversionDecl>(NewMethod))
NewDiag = diag::err_conv_function_redeclared;
else
NewDiag = diag::err_member_redeclared;
Diag(New->getLocation(), NewDiag);
} else {
Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
<< New << New->getType();
}
Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
// Complain if this is an explicit declaration of a special
// member that was initially declared implicitly.
//
// As an exception, it's okay to befriend such methods in order
// to permit the implicit constructor/destructor/operator calls.
} else if (OldMethod->isImplicit()) {
if (isFriend) {
NewMethod->setImplicit();
} else {
Diag(NewMethod->getLocation(),
diag::err_definition_of_implicitly_declared_member)
<< New << getSpecialMember(OldMethod);
return true;
}
} else if (OldMethod->isExplicitlyDefaulted() && !isFriend) {
Diag(NewMethod->getLocation(),
diag::err_definition_of_explicitly_defaulted_member)
<< getSpecialMember(OldMethod);
return true;
}
}
// C++11 [dcl.attr.noreturn]p1:
// The first declaration of a function shall specify the noreturn
// attribute if any declaration of that function specifies the noreturn
// attribute.
if (New->hasAttr<CXX11NoReturnAttr>() &&
!Old->hasAttr<CXX11NoReturnAttr>()) {
Diag(New->getAttr<CXX11NoReturnAttr>()->getLocation(),
diag::err_noreturn_missing_on_first_decl);
Diag(Old->getFirstDeclaration()->getLocation(),
diag::note_noreturn_missing_first_decl);
}
// C++11 [dcl.attr.depend]p2:
// The first declaration of a function shall specify the
// carries_dependency attribute for its declarator-id if any declaration
// of the function specifies the carries_dependency attribute.
if (New->hasAttr<CarriesDependencyAttr>() &&
!Old->hasAttr<CarriesDependencyAttr>()) {
Diag(New->getAttr<CarriesDependencyAttr>()->getLocation(),
diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/;
Diag(Old->getFirstDeclaration()->getLocation(),
diag::note_carries_dependency_missing_first_decl) << 0/*Function*/;
}
// (C++98 8.3.5p3):
// All declarations for a function shall agree exactly in both the
// return type and the parameter-type-list.
// We also want to respect all the extended bits except noreturn.
// noreturn should now match unless the old type info didn't have it.
QualType OldQTypeForComparison = OldQType;
if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) {
assert(OldQType == QualType(OldType, 0));
const FunctionType *OldTypeForComparison
= Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true));
OldQTypeForComparison = QualType(OldTypeForComparison, 0);
assert(OldQTypeForComparison.isCanonical());
}
if (haveIncompatibleLanguageLinkages(Old, New)) {
Diag(New->getLocation(), diag::err_different_language_linkage) << New;
Diag(Old->getLocation(), PrevDiag);
return true;
}
if (OldQTypeForComparison == NewQType)
return MergeCompatibleFunctionDecls(New, Old, S);
// Fall through for conflicting redeclarations and redefinitions.
}
// C: Function types need to be compatible, not identical. This handles
// duplicate function decls like "void f(int); void f(enum X);" properly.
if (!getLangOpts().CPlusPlus &&
Context.typesAreCompatible(OldQType, NewQType)) {
const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
const FunctionProtoType *OldProto = 0;
if (isa<FunctionNoProtoType>(NewFuncType) &&
(OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
// The old declaration provided a function prototype, but the
// new declaration does not. Merge in the prototype.
assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
SmallVector<QualType, 16> ParamTypes(OldProto->arg_type_begin(),
OldProto->arg_type_end());
NewQType = Context.getFunctionType(NewFuncType->getResultType(),
ParamTypes,
OldProto->getExtProtoInfo());
New->setType(NewQType);
New->setHasInheritedPrototype();
// Synthesize a parameter for each argument type.
SmallVector<ParmVarDecl*, 16> Params;
for (FunctionProtoType::arg_type_iterator
ParamType = OldProto->arg_type_begin(),
ParamEnd = OldProto->arg_type_end();
ParamType != ParamEnd; ++ParamType) {
ParmVarDecl *Param = ParmVarDecl::Create(Context, New,
SourceLocation(),
SourceLocation(), 0,
*ParamType, /*TInfo=*/0,
SC_None,
0);
Param->setScopeInfo(0, Params.size());
Param->setImplicit();
Params.push_back(Param);
}
New->setParams(Params);
}
return MergeCompatibleFunctionDecls(New, Old, S);
}
// GNU C permits a K&R definition to follow a prototype declaration
// if the declared types of the parameters in the K&R definition
// match the types in the prototype declaration, even when the
// promoted types of the parameters from the K&R definition differ
// from the types in the prototype. GCC then keeps the types from
// the prototype.
//
// If a variadic prototype is followed by a non-variadic K&R definition,
// the K&R definition becomes variadic. This is sort of an edge case, but
// it's legal per the standard depending on how you read C99 6.7.5.3p15 and
// C99 6.9.1p8.
if (!getLangOpts().CPlusPlus &&
Old->hasPrototype() && !New->hasPrototype() &&
New->getType()->getAs<FunctionProtoType>() &&
Old->getNumParams() == New->getNumParams()) {
SmallVector<QualType, 16> ArgTypes;
SmallVector<GNUCompatibleParamWarning, 16> Warnings;
const FunctionProtoType *OldProto
= Old->getType()->getAs<FunctionProtoType>();
const FunctionProtoType *NewProto
= New->getType()->getAs<FunctionProtoType>();
// Determine whether this is the GNU C extension.
QualType MergedReturn = Context.mergeTypes(OldProto->getResultType(),
NewProto->getResultType());
bool LooseCompatible = !MergedReturn.isNull();
for (unsigned Idx = 0, End = Old->getNumParams();
LooseCompatible && Idx != End; ++Idx) {
ParmVarDecl *OldParm = Old->getParamDecl(Idx);
ParmVarDecl *NewParm = New->getParamDecl(Idx);
if (Context.typesAreCompatible(OldParm->getType(),
NewProto->getArgType(Idx))) {
ArgTypes.push_back(NewParm->getType());
} else if (Context.typesAreCompatible(OldParm->getType(),
NewParm->getType(),
/*CompareUnqualified=*/true)) {
GNUCompatibleParamWarning Warn
= { OldParm, NewParm, NewProto->getArgType(Idx) };
Warnings.push_back(Warn);
ArgTypes.push_back(NewParm->getType());
} else
LooseCompatible = false;
}
if (LooseCompatible) {
for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
Diag(Warnings[Warn].NewParm->getLocation(),
diag::ext_param_promoted_not_compatible_with_prototype)
<< Warnings[Warn].PromotedType
<< Warnings[Warn].OldParm->getType();
if (Warnings[Warn].OldParm->getLocation().isValid())
Diag(Warnings[Warn].OldParm->getLocation(),
diag::note_previous_declaration);
}
New->setType(Context.getFunctionType(MergedReturn, ArgTypes,
OldProto->getExtProtoInfo()));
return MergeCompatibleFunctionDecls(New, Old, S);
}
// Fall through to diagnose conflicting types.
}
// A function that has already been declared has been redeclared or
// defined with a different type; show an appropriate diagnostic.
// If the previous declaration was an implicitly-generated builtin
// declaration, then at the very least we should use a specialized note.
unsigned BuiltinID;
if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {
// If it's actually a library-defined builtin function like 'malloc'
// or 'printf', just warn about the incompatible redeclaration.
if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
<< Old << Old->getType();
// If this is a global redeclaration, just forget hereafter
// about the "builtin-ness" of the function.
//
// Doing this for local extern declarations is problematic. If
// the builtin declaration remains visible, a second invalid
// local declaration will produce a hard error; if it doesn't
// remain visible, a single bogus local redeclaration (which is
// actually only a warning) could break all the downstream code.
if (!New->getDeclContext()->isFunctionOrMethod())
New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
return false;
}
PrevDiag = diag::note_previous_builtin_declaration;
}
Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
Diag(Old->getLocation(), PrevDiag) << Old << Old->getType();
return true;
}
/// \brief Completes the merge of two function declarations that are
/// known to be compatible.
///
/// This routine handles the merging of attributes and other
/// properties of function declarations form the old declaration to
/// the new declaration, once we know that New is in fact a
/// redeclaration of Old.
///
/// \returns false
bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
Scope *S) {
// Merge the attributes
mergeDeclAttributes(New, Old);
// Merge "pure" flag.
if (Old->isPure())
New->setPure();
// Merge "used" flag.
if (Old->isUsed(false))
New->setUsed();
// Merge attributes from the parameters. These can mismatch with K&R
// declarations.
if (New->getNumParams() == Old->getNumParams())
for (unsigned i = 0, e = New->getNumParams(); i != e; ++i)
mergeParamDeclAttributes(New->getParamDecl(i), Old->getParamDecl(i),
*this);
if (getLangOpts().CPlusPlus)
return MergeCXXFunctionDecl(New, Old, S);
// Merge the function types so the we get the composite types for the return
// and argument types.
QualType Merged = Context.mergeTypes(Old->getType(), New->getType());
if (!Merged.isNull())
New->setType(Merged);
return false;
}
void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod,
ObjCMethodDecl *oldMethod) {
// Merge the attributes, including deprecated/unavailable
AvailabilityMergeKind MergeKind =
isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration
: AMK_Override;
mergeDeclAttributes(newMethod, oldMethod, MergeKind);
// Merge attributes from the parameters.
ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(),
oe = oldMethod->param_end();
for (ObjCMethodDecl::param_iterator
ni = newMethod->param_begin(), ne = newMethod->param_end();
ni != ne && oi != oe; ++ni, ++oi)
mergeParamDeclAttributes(*ni, *oi, *this);
CheckObjCMethodOverride(newMethod, oldMethod);
}
/// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
/// scope as a previous declaration 'Old'. Figure out how to merge their types,
/// emitting diagnostics as appropriate.
///
/// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back
/// to here in AddInitializerToDecl. We can't check them before the initializer
/// is attached.
void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old, bool OldWasHidden) {
if (New->isInvalidDecl() || Old->isInvalidDecl())
return;
QualType MergedT;
if (getLangOpts().CPlusPlus) {
if (New->getType()->isUndeducedType()) {
// We don't know what the new type is until the initializer is attached.
return;
} else if (Context.hasSameType(New->getType(), Old->getType())) {
// These could still be something that needs exception specs checked.
return MergeVarDeclExceptionSpecs(New, Old);
}
// C++ [basic.link]p10:
// [...] the types specified by all declarations referring to a given
// object or function shall be identical, except that declarations for an
// array object can specify array types that differ by the presence or
// absence of a major array bound (8.3.4).
else if (Old->getType()->isIncompleteArrayType() &&
New->getType()->isArrayType()) {
const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
const ArrayType *NewArray = Context.getAsArrayType(New->getType());
if (Context.hasSameType(OldArray->getElementType(),
NewArray->getElementType()))
MergedT = New->getType();
} else if (Old->getType()->isArrayType() &&
New->getType()->isIncompleteArrayType()) {
const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
const ArrayType *NewArray = Context.getAsArrayType(New->getType());
if (Context.hasSameType(OldArray->getElementType(),
NewArray->getElementType()))
MergedT = Old->getType();
} else if (New->getType()->isObjCObjectPointerType()
&& Old->getType()->isObjCObjectPointerType()) {
MergedT = Context.mergeObjCGCQualifiers(New->getType(),
Old->getType());
}
} else {
MergedT = Context.mergeTypes(New->getType(), Old->getType());
}
if (MergedT.isNull()) {
Diag(New->getLocation(), diag::err_redefinition_different_type)
<< New->getDeclName() << New->getType() << Old->getType();
Diag(Old->getLocation(), diag::note_previous_definition);
return New->setInvalidDecl();
}
// Don't actually update the type on the new declaration if the old
// declaration was a extern declaration in a different scope.
if (!OldWasHidden)
New->setType(MergedT);
}
/// MergeVarDecl - We just parsed a variable 'New' which has the same name
/// and scope as a previous declaration 'Old'. Figure out how to resolve this
/// situation, merging decls or emitting diagnostics as appropriate.
///
/// Tentative definition rules (C99 6.9.2p2) are checked by
/// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
/// definitions here, since the initializer hasn't been attached.
///
void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous,
bool PreviousWasHidden) {
// If the new decl is already invalid, don't do any other checking.
if (New->isInvalidDecl())
return;
// Verify the old decl was also a variable.
VarDecl *Old = 0;
if (!Previous.isSingleResult() ||
!(Old = dyn_cast<VarDecl>(Previous.getFoundDecl()))) {
Diag(New->getLocation(), diag::err_redefinition_different_kind)
<< New->getDeclName();
Diag(Previous.getRepresentativeDecl()->getLocation(),
diag::note_previous_definition);
return New->setInvalidDecl();
}
if (!shouldLinkPossiblyHiddenDecl(Old, New))
return;
// C++ [class.mem]p1:
// A member shall not be declared twice in the member-specification [...]
//
// Here, we need only consider static data members.
if (Old->isStaticDataMember() && !New->isOutOfLine()) {
Diag(New->getLocation(), diag::err_duplicate_member)
<< New->getIdentifier();
Diag(Old->getLocation(), diag::note_previous_declaration);
New->setInvalidDecl();
}
mergeDeclAttributes(New, Old);
// Warn if an already-declared variable is made a weak_import in a subsequent
// declaration
if (New->getAttr<WeakImportAttr>() &&
Old->getStorageClass() == SC_None &&
!Old->getAttr<WeakImportAttr>()) {
Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
Diag(Old->getLocation(), diag::note_previous_definition);
// Remove weak_import attribute on new declaration.
New->dropAttr<WeakImportAttr>();
}
// Merge the types.
MergeVarDeclTypes(New, Old, PreviousWasHidden);
if (New->isInvalidDecl())
return;
// [dcl.stc]p8: Check if we have a non-static decl followed by a static.
if (New->getStorageClass() == SC_Static &&
!New->isStaticDataMember() &&
isExternalLinkage(Old->getLinkage())) {
Diag(New->getLocation(), diag::err_static_non_static) << New->getDeclName();
Diag(Old->getLocation(), diag::note_previous_definition);
return New->setInvalidDecl();
}
// C99 6.2.2p4:
// For an identifier declared with the storage-class specifier
// extern in a scope in which a prior declaration of that
// identifier is visible,23) if the prior declaration specifies
// internal or external linkage, the linkage of the identifier at
// the later declaration is the same as the linkage specified at
// the prior declaration. If no prior declaration is visible, or
// if the prior declaration specifies no linkage, then the
// identifier has external linkage.
if (New->hasExternalStorage() && Old->hasLinkage())
/* Okay */;
else if (New->getCanonicalDecl()->getStorageClass() != SC_Static &&
!New->isStaticDataMember() &&
Old->getCanonicalDecl()->getStorageClass() == SC_Static) {
Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
Diag(Old->getLocation(), diag::note_previous_definition);
return New->setInvalidDecl();
}
// Check if extern is followed by non-extern and vice-versa.
if (New->hasExternalStorage() &&
!Old->hasLinkage() && Old->isLocalVarDecl()) {
Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName();
Diag(Old->getLocation(), diag::note_previous_definition);
return New->setInvalidDecl();
}
if (Old->hasLinkage() && New->isLocalVarDecl() &&
!New->hasExternalStorage()) {
Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName();
Diag(Old->getLocation(), diag::note_previous_definition);
return New->setInvalidDecl();
}
// Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
// FIXME: The test for external storage here seems wrong? We still
// need to check for mismatches.
if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
// Don't complain about out-of-line definitions of static members.
!(Old->getLexicalDeclContext()->isRecord() &&
!New->getLexicalDeclContext()->isRecord())) {
Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
Diag(Old->getLocation(), diag::note_previous_definition);
return New->setInvalidDecl();
}
if (New->getTLSKind() != Old->getTLSKind()) {
if (!Old->getTLSKind()) {
Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
Diag(Old->getLocation(), diag::note_previous_declaration);
} else if (!New->getTLSKind()) {
Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
Diag(Old->getLocation(), diag::note_previous_declaration);
} else {
// Do not allow redeclaration to change the variable between requiring
// static and dynamic initialization.
// FIXME: GCC allows this, but uses the TLS keyword on the first
// declaration to determine the kind. Do we need to be compatible here?
Diag(New->getLocation(), diag::err_thread_thread_different_kind)
<< New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic);
Diag(Old->getLocation(), diag::note_previous_declaration);
}
}
// C++ doesn't have tentative definitions, so go right ahead and check here.
const VarDecl *Def;
if (getLangOpts().CPlusPlus &&
New->isThisDeclarationADefinition() == VarDecl::Definition &&
(Def = Old->getDefinition())) {
Diag(New->getLocation(), diag::err_redefinition)
<< New->getDeclName();
Diag(Def->getLocation(), diag::note_previous_definition);
New->setInvalidDecl();
return;
}
if (haveIncompatibleLanguageLinkages(Old, New)) {
Diag(New->getLocation(), diag::err_different_language_linkage) << New;
Diag(Old->getLocation(), diag::note_previous_definition);
New->setInvalidDecl();
return;
}
// Merge "used" flag.
if (Old->isUsed(false))
New->setUsed();
// Keep a chain of previous declarations.
New->setPreviousDeclaration(Old);
// Inherit access appropriately.
New->setAccess(Old->getAccess());
}
/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
/// no declarator (e.g. "struct foo;") is parsed.
Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
DeclSpec &DS) {
return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg());
}
/// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
/// no declarator (e.g. "struct foo;") is parsed. It also accepts template
/// parameters to cope with template friend declarations.
Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
DeclSpec &DS,
MultiTemplateParamsArg TemplateParams,
bool IsExplicitInstantiation) {
Decl *TagD = 0;
TagDecl *Tag = 0;
if (DS.getTypeSpecType() == DeclSpec::TST_class ||
DS.getTypeSpecType() == DeclSpec::TST_struct ||
DS.getTypeSpecType() == DeclSpec::TST_interface ||
DS.getTypeSpecType() == DeclSpec::TST_union ||
DS.getTypeSpecType() == DeclSpec::TST_enum) {
TagD = DS.getRepAsDecl();
if (!TagD) // We probably had an error
return 0;
// Note that the above type specs guarantee that the
// type rep is a Decl, whereas in many of the others
// it's a Type.
if (isa<TagDecl>(TagD))
Tag = cast<TagDecl>(TagD);
else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD))
Tag = CTD->getTemplatedDecl();
}
if (Tag) {
getASTContext().addUnnamedTag(Tag);
Tag->setFreeStanding();
if (Tag->isInvalidDecl())
return Tag;
}
if (unsigned TypeQuals = DS.getTypeQualifiers()) {
// Enforce C99 6.7.3p2: "Types other than pointer types derived from object
// or incomplete types shall not be restrict-qualified."
if (TypeQuals & DeclSpec::TQ_restrict)
Diag(DS.getRestrictSpecLoc(),
diag::err_typecheck_invalid_restrict_not_pointer_noarg)
<< DS.getSourceRange();
}
if (DS.isConstexprSpecified()) {
// C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations
// and definitions of functions and variables.
if (Tag)
Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
<< (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 :
DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 :
DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 :
DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4);
else
Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators);
// Don't emit warnings after this error.
return TagD;
}
DiagnoseFunctionSpecifiers(DS);
if (DS.isFriendSpecified()) {
// If we're dealing with a decl but not a TagDecl, assume that
// whatever routines created it handled the friendship aspect.
if (TagD && !Tag)
return 0;
return ActOnFriendTypeDecl(S, DS, TemplateParams);
}
CXXScopeSpec &SS = DS.getTypeSpecScope();
bool IsExplicitSpecialization =
!TemplateParams.empty() && TemplateParams.back()->size() == 0;
if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() &&
!IsExplicitInstantiation && !IsExplicitSpecialization) {
// Per C++ [dcl.type.elab]p1, a class declaration cannot have a
// nested-name-specifier unless it is an explicit instantiation
// or an explicit specialization.
// Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either.
Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
<< (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 :
DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 :
DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 :
DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4)
<< SS.getRange();
return 0;
}
// Track whether this decl-specifier declares anything.
bool DeclaresAnything = true;
// Handle anonymous struct definitions.
if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
if (!Record->getDeclName() && Record->isCompleteDefinition() &&
DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
if (getLangOpts().CPlusPlus ||
Record->getDeclContext()->isRecord())
return BuildAnonymousStructOrUnion(S, DS, AS, Record);
DeclaresAnything = false;
}
}
// Check for Microsoft C extension: anonymous struct member.
if (getLangOpts().MicrosoftExt && !getLangOpts().CPlusPlus &&
CurContext->isRecord() &&
DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) {
// Handle 2 kinds of anonymous struct:
// struct STRUCT;
// and
// STRUCT_TYPE; <- where STRUCT_TYPE is a typedef struct.
RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag);
if ((Record && Record->getDeclName() && !Record->isCompleteDefinition()) ||
(DS.getTypeSpecType() == DeclSpec::TST_typename &&
DS.getRepAsType().get()->isStructureType())) {
Diag(DS.getLocStart(), diag::ext_ms_anonymous_struct)
<< DS.getSourceRange();
return BuildMicrosoftCAnonymousStruct(S, DS, Record);
}
}
// Skip all the checks below if we have a type error.
if (DS.getTypeSpecType() == DeclSpec::TST_error ||
(TagD && TagD->isInvalidDecl()))
return TagD;
if (getLangOpts().CPlusPlus &&
DS.getStorageClassSpec() != DeclSpec::SCS_typedef)
if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag))
if (Enum->enumerator_begin() == Enum->enumerator_end() &&
!Enum->getIdentifier() && !Enum->isInvalidDecl())
DeclaresAnything = false;
if (!DS.isMissingDeclaratorOk()) {
// Customize diagnostic for a typedef missing a name.
if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
Diag(DS.getLocStart(), diag::ext_typedef_without_a_name)
<< DS.getSourceRange();
else
DeclaresAnything = false;
}
if (DS.isModulePrivateSpecified() &&
Tag && Tag->getDeclContext()->isFunctionOrMethod())
Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class)
<< Tag->getTagKind()
<< FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc());
ActOnDocumentableDecl(TagD);
// C 6.7/2:
// A declaration [...] shall declare at least a declarator [...], a tag,
// or the members of an enumeration.
// C++ [dcl.dcl]p3:
// [If there are no declarators], and except for the declaration of an
// unnamed bit-field, the decl-specifier-seq shall introduce one or more
// names into the program, or shall redeclare a name introduced by a
// previous declaration.
if (!DeclaresAnything) {
// In C, we allow this as a (popular) extension / bug. Don't bother
// producing further diagnostics for redundant qualifiers after this.
Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange();
return TagD;
}
// C++ [dcl.stc]p1:
// If a storage-class-specifier appears in a decl-specifier-seq, [...] the
// init-declarator-list of the declaration shall not be empty.
// C++ [dcl.fct.spec]p1:
// If a cv-qualifier appears in a decl-specifier-seq, the
// init-declarator-list of the declaration shall not be empty.
//
// Spurious qualifiers here appear to be valid in C.
unsigned DiagID = diag::warn_standalone_specifier;
if (getLangOpts().CPlusPlus)
DiagID = diag::ext_standalone_specifier;
// Note that a linkage-specification sets a storage class, but
// 'extern "C" struct foo;' is actually valid and not theoretically
// useless.
if (DeclSpec::SCS SCS = DS.getStorageClassSpec())
if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef)
Diag(DS.getStorageClassSpecLoc(), DiagID)
<< DeclSpec::getSpecifierName(SCS);
if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
Diag(DS.getThreadStorageClassSpecLoc(), DiagID)
<< DeclSpec::getSpecifierName(TSCS);
if (DS.getTypeQualifiers()) {
if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
Diag(DS.getConstSpecLoc(), DiagID) << "const";
if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
Diag(DS.getConstSpecLoc(), DiagID) << "volatile";
// Restrict is covered above.
if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic";
}
// Warn about ignored type attributes, for example:
// __attribute__((aligned)) struct A;
// Attributes should be placed after tag to apply to type declaration.
if (!DS.getAttributes().empty()) {
DeclSpec::TST TypeSpecType = DS.getTypeSpecType();
if (TypeSpecType == DeclSpec::TST_class ||
TypeSpecType == DeclSpec::TST_struct ||
TypeSpecType == DeclSpec::TST_interface ||
TypeSpecType == DeclSpec::TST_union ||
TypeSpecType == DeclSpec::TST_enum) {
AttributeList* attrs = DS.getAttributes().getList();
while (attrs) {
Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored)
<< attrs->getName()
<< (TypeSpecType == DeclSpec::TST_class ? 0 :
TypeSpecType == DeclSpec::TST_struct ? 1 :
TypeSpecType == DeclSpec::TST_union ? 2 :
TypeSpecType == DeclSpec::TST_interface ? 3 : 4);
attrs = attrs->getNext();
}
}
}
return TagD;
}
/// We are trying to inject an anonymous member into the given scope;
/// check if there's an existing declaration that can't be overloaded.
///
/// \return true if this is a forbidden redeclaration
static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
Scope *S,
DeclContext *Owner,
DeclarationName Name,
SourceLocation NameLoc,
unsigned diagnostic) {
LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
Sema::ForRedeclaration);
if (!SemaRef.LookupName(R, S)) return false;
if (R.getAsSingle<TagDecl>())
return false;
// Pick a representative declaration.
NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
assert(PrevDecl && "Expected a non-null Decl");
if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
return false;
SemaRef.Diag(NameLoc, diagnostic) << Name;
SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
return true;
}
/// InjectAnonymousStructOrUnionMembers - Inject the members of the
/// anonymous struct or union AnonRecord into the owning context Owner
/// and scope S. This routine will be invoked just after we realize
/// that an unnamed union or struct is actually an anonymous union or
/// struct, e.g.,
///
/// @code
/// union {
/// int i;
/// float f;
/// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
/// // f into the surrounding scope.x
/// @endcode
///
/// This routine is recursive, injecting the names of nested anonymous
/// structs/unions into the owning context and scope as well.
static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S,
DeclContext *Owner,
RecordDecl *AnonRecord,
AccessSpecifier AS,
SmallVector<NamedDecl*, 2> &Chaining,
bool MSAnonStruct) {
unsigned diagKind
= AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl
: diag::err_anonymous_struct_member_redecl;
bool Invalid = false;
// Look every FieldDecl and IndirectFieldDecl with a name.
for (RecordDecl::decl_iterator D = AnonRecord->decls_begin(),
DEnd = AnonRecord->decls_end();
D != DEnd; ++D) {
if ((isa<FieldDecl>(*D) || isa<IndirectFieldDecl>(*D)) &&
cast<NamedDecl>(*D)->getDeclName()) {
ValueDecl *VD = cast<ValueDecl>(*D);
if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(),
VD->getLocation(), diagKind)) {
// C++ [class.union]p2:
// The names of the members of an anonymous union shall be
// distinct from the names of any other entity in the
// scope in which the anonymous union is declared.
Invalid = true;
} else {
// C++ [class.union]p2:
// For the purpose of name lookup, after the anonymous union
// definition, the members of the anonymous union are
// considered to have been defined in the scope in which the
// anonymous union is declared.
unsigned OldChainingSize = Chaining.size();
if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD))
for (IndirectFieldDecl::chain_iterator PI = IF->chain_begin(),
PE = IF->chain_end(); PI != PE; ++PI)
Chaining.push_back(*PI);
else
Chaining.push_back(VD);
assert(Chaining.size() >= 2);
NamedDecl **NamedChain =
new (SemaRef.Context)NamedDecl*[Chaining.size()];
for (unsigned i = 0; i < Chaining.size(); i++)
NamedChain[i] = Chaining[i];
IndirectFieldDecl* IndirectField =
IndirectFieldDecl::Create(SemaRef.Context, Owner, VD->getLocation(),
VD->getIdentifier(), VD->getType(),
NamedChain, Chaining.size());
IndirectField->setAccess(AS);
IndirectField->setImplicit();
SemaRef.PushOnScopeChains(IndirectField, S);
// That includes picking up the appropriate access specifier.
if (AS != AS_none) IndirectField->setAccess(AS);
Chaining.resize(OldChainingSize);
}
}
}
return Invalid;
}
/// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to
/// a VarDecl::StorageClass. Any error reporting is up to the caller:
/// illegal input values are mapped to SC_None.
static StorageClass
StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) {
DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec();
assert(StorageClassSpec != DeclSpec::SCS_typedef &&
"Parser allowed 'typedef' as storage class VarDecl.");
switch (StorageClassSpec) {
case DeclSpec::SCS_unspecified: return SC_None;
case DeclSpec::SCS_extern:
if (DS.isExternInLinkageSpec())
return SC_None;
return SC_Extern;
case DeclSpec::SCS_static: return SC_Static;
case DeclSpec::SCS_auto: return SC_Auto;
case DeclSpec::SCS_register: return SC_Register;
case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
// Illegal SCSs map to None: error reporting is up to the caller.
case DeclSpec::SCS_mutable: // Fall through.
case DeclSpec::SCS_typedef: return SC_None;
}
llvm_unreachable("unknown storage class specifier");
}
/// BuildAnonymousStructOrUnion - Handle the declaration of an
/// anonymous structure or union. Anonymous unions are a C++ feature
/// (C++ [class.union]) and a C11 feature; anonymous structures
/// are a C11 feature and GNU C++ extension.
Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
AccessSpecifier AS,
RecordDecl *Record) {
DeclContext *Owner = Record->getDeclContext();
// Diagnose whether this anonymous struct/union is an extension.
if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11)
Diag(Record->getLocation(), diag::ext_anonymous_union);
else if (!Record->isUnion() && getLangOpts().CPlusPlus)
Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct);
else if (!Record->isUnion() && !getLangOpts().C11)
Diag(Record->getLocation(), diag::ext_c11_anonymous_struct);
// C and C++ require different kinds of checks for anonymous
// structs/unions.
bool Invalid = false;
if (getLangOpts().CPlusPlus) {
const char* PrevSpec = 0;
unsigned DiagID;
if (Record->isUnion()) {
// C++ [class.union]p6:
// Anonymous unions declared in a named namespace or in the
// global namespace shall be declared static.
if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
(isa<TranslationUnitDecl>(Owner) ||
(isa<NamespaceDecl>(Owner) &&
cast<NamespaceDecl>(Owner)->getDeclName()))) {
Diag(Record->getLocation(), diag::err_anonymous_union_not_static)
<< FixItHint::CreateInsertion(Record->getLocation(), "static ");
// Recover by adding 'static'.
DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(),
PrevSpec, DiagID);
}
// C++ [class.union]p6:
// A storage class is not allowed in a declaration of an
// anonymous union in a class scope.
else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
isa<RecordDecl>(Owner)) {
Diag(DS.getStorageClassSpecLoc(),
diag::err_anonymous_union_with_storage_spec)
<< FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
// Recover by removing the storage specifier.
DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified,
SourceLocation(),
PrevSpec, DiagID);
}
}
// Ignore const/volatile/restrict qualifiers.
if (DS.getTypeQualifiers()) {
if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified)
<< Record->isUnion() << "const"
<< FixItHint::CreateRemoval(DS.getConstSpecLoc());
if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
Diag(DS.getVolatileSpecLoc(),
diag::ext_anonymous_struct_union_qualified)
<< Record->isUnion() << "volatile"
<< FixItHint::CreateRemoval(DS.getVolatileSpecLoc());
if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
Diag(DS.getRestrictSpecLoc(),
diag::ext_anonymous_struct_union_qualified)
<< Record->isUnion() << "restrict"
<< FixItHint::CreateRemoval(DS.getRestrictSpecLoc());
if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
Diag(DS.getAtomicSpecLoc(),
diag::ext_anonymous_struct_union_qualified)
<< Record->isUnion() << "_Atomic"
<< FixItHint::CreateRemoval(DS.getAtomicSpecLoc());
DS.ClearTypeQualifiers();
}
// C++ [class.union]p2:
// The member-specification of an anonymous union shall only
// define non-static data members. [Note: nested types and
// functions cannot be declared within an anonymous union. ]
for (DeclContext::decl_iterator Mem = Record->decls_begin(),
MemEnd = Record->decls_end();
Mem != MemEnd; ++Mem) {
if (FieldDecl *FD = dyn_cast<FieldDecl>(*Mem)) {
// C++ [class.union]p3:
// An anonymous union shall not have private or protected
// members (clause 11).
assert(FD->getAccess() != AS_none);
if (FD->getAccess() != AS_public) {
Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
<< (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
Invalid = true;
}
// C++ [class.union]p1
// An object of a class with a non-trivial constructor, a non-trivial
// copy constructor, a non-trivial destructor, or a non-trivial copy
// assignment operator cannot be a member of a union, nor can an
// array of such objects.
if (CheckNontrivialField(FD))
Invalid = true;
} else if ((*Mem)->isImplicit()) {
// Any implicit members are fine.
} else if (isa<TagDecl>(*Mem) && (*Mem)->getDeclContext() != Record) {
// This is a type that showed up in an
// elaborated-type-specifier inside the anonymous struct or
// union, but which actually declares a type outside of the
// anonymous struct or union. It's okay.
} else if (RecordDecl *MemRecord = dyn_cast<RecordDecl>(*Mem)) {
if (!MemRecord->isAnonymousStructOrUnion() &&
MemRecord->getDeclName()) {
// Visual C++ allows type definition in anonymous struct or union.
if (getLangOpts().MicrosoftExt)
Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
<< (int)Record->isUnion();
else {
// This is a nested type declaration.
Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
<< (int)Record->isUnion();
Invalid = true;
}
} else {
// This is an anonymous type definition within another anonymous type.
// This is a popular extension, provided by Plan9, MSVC and GCC, but
// not part of standard C++.
Diag(MemRecord->getLocation(),
diag::ext_anonymous_record_with_anonymous_type)
<< (int)Record->isUnion();
}
} else if (isa<AccessSpecDecl>(*Mem)) {
// Any access specifier is fine.
} else {
// We have something that isn't a non-static data
// member. Complain about it.
unsigned DK = diag::err_anonymous_record_bad_member;
if (isa<TypeDecl>(*Mem))
DK = diag::err_anonymous_record_with_type;
else if (isa<FunctionDecl>(*Mem))
DK = diag::err_anonymous_record_with_function;
else if (isa<VarDecl>(*Mem))
DK = diag::err_anonymous_record_with_static;
// Visual C++ allows type definition in anonymous struct or union.
if (getLangOpts().MicrosoftExt &&
DK == diag::err_anonymous_record_with_type)
Diag((*Mem)->getLocation(), diag::ext_anonymous_record_with_type)
<< (int)Record->isUnion();
else {
Diag((*Mem)->getLocation(), DK)
<< (int)Record->isUnion();
Invalid = true;
}
}
}
}
if (!Record->isUnion() && !Owner->isRecord()) {
Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
<< (int)getLangOpts().CPlusPlus;
Invalid = true;
}
// Mock up a declarator.
Declarator Dc(DS, Declarator::MemberContext);
TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
assert(TInfo && "couldn't build declarator info for anonymous struct/union");
// Create a declaration for this anonymous struct/union.
NamedDecl *Anon = 0;
if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
Anon = FieldDecl::Create(Context, OwningClass,
DS.getLocStart(),
Record->getLocation(),
/*IdentifierInfo=*/0,
Context.getTypeDeclType(Record),
TInfo,
/*BitWidth=*/0, /*Mutable=*/false,
/*InitStyle=*/ICIS_NoInit);
Anon->setAccess(AS);
if (getLangOpts().CPlusPlus)
FieldCollector->Add(cast<FieldDecl>(Anon));
} else {
DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS);
if (SCSpec == DeclSpec::SCS_mutable) {
// mutable can only appear on non-static class members, so it's always
// an error here
Diag(Record->getLocation(), diag::err_mutable_nonmember);
Invalid = true;
SC = SC_None;
}
Anon = VarDecl::Create(Context, Owner,
DS.getLocStart(),
Record->getLocation(), /*IdentifierInfo=*/0,
Context.getTypeDeclType(Record),
TInfo, SC);
// Default-initialize the implicit variable. This initialization will be
// trivial in almost all cases, except if a union member has an in-class
// initializer:
// union { int n = 0; };
ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false);
}
Anon->setImplicit();
// Add the anonymous struct/union object to the current
// context. We'll be referencing this object when we refer to one of
// its members.
Owner->addDecl(Anon);
// Inject the members of the anonymous struct/union into the owning
// context and into the identifier resolver chain for name lookup
// purposes.
SmallVector<NamedDecl*, 2> Chain;
Chain.push_back(Anon);
if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS,
Chain, false))
Invalid = true;
// Mark this as an anonymous struct/union type. Note that we do not
// do this until after we have already checked and injected the
// members of this anonymous struct/union type, because otherwise
// the members could be injected twice: once by DeclContext when it
// builds its lookup table, and once by
// InjectAnonymousStructOrUnionMembers.
Record->setAnonymousStructOrUnion(true);
if (Invalid)
Anon->setInvalidDecl();
return Anon;
}
/// BuildMicrosoftCAnonymousStruct - Handle the declaration of an
/// Microsoft C anonymous structure.
/// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx
/// Example:
///
/// struct A { int a; };
/// struct B { struct A; int b; };
///
/// void foo() {
/// B var;
/// var.a = 3;
/// }
///
Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
RecordDecl *Record) {
// If there is no Record, get the record via the typedef.
if (!Record)
Record = DS.getRepAsType().get()->getAsStructureType()->getDecl();
// Mock up a declarator.
Declarator Dc(DS, Declarator::TypeNameContext);
TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
assert(TInfo && "couldn't build declarator info for anonymous struct");
// Create a declaration for this anonymous struct.
NamedDecl* Anon = FieldDecl::Create(Context,
cast<RecordDecl>(CurContext),
DS.getLocStart(),
DS.getLocStart(),
/*IdentifierInfo=*/0,
Context.getTypeDeclType(Record),
TInfo,
/*BitWidth=*/0, /*Mutable=*/false,
/*InitStyle=*/ICIS_NoInit);
Anon->setImplicit();
// Add the anonymous struct object to the current context.
CurContext->addDecl(Anon);
// Inject the members of the anonymous struct into the current
// context and into the identifier resolver chain for name lookup
// purposes.
SmallVector<NamedDecl*, 2> Chain;
Chain.push_back(Anon);
RecordDecl *RecordDef = Record->getDefinition();
if (!RecordDef || InjectAnonymousStructOrUnionMembers(*this, S, CurContext,
RecordDef, AS_none,
Chain, true))
Anon->setInvalidDecl();
return Anon;
}
/// GetNameForDeclarator - Determine the full declaration name for the
/// given Declarator.
DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) {
return GetNameFromUnqualifiedId(D.getName());
}
/// \brief Retrieves the declaration name from a parsed unqualified-id.
DeclarationNameInfo
Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
DeclarationNameInfo NameInfo;
NameInfo.setLoc(Name.StartLocation);
switch (Name.getKind()) {
case UnqualifiedId::IK_ImplicitSelfParam:
case UnqualifiedId::IK_Identifier:
NameInfo.setName(Name.Identifier);
NameInfo.setLoc(Name.StartLocation);
return NameInfo;
case UnqualifiedId::IK_OperatorFunctionId:
NameInfo.setName(Context.DeclarationNames.getCXXOperatorName(
Name.OperatorFunctionId.Operator));
NameInfo.setLoc(Name.StartLocation);
NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc
= Name.OperatorFunctionId.SymbolLocations[0];
NameInfo.getInfo().CXXOperatorName.EndOpNameLoc
= Name.EndLocation.getRawEncoding();
return NameInfo;
case UnqualifiedId::IK_LiteralOperatorId:
NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName(
Name.Identifier));
NameInfo.setLoc(Name.StartLocation);
NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation);
return NameInfo;
case UnqualifiedId::IK_ConversionFunctionId: {
TypeSourceInfo *TInfo;
QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo);
if (Ty.isNull())
return DeclarationNameInfo();
NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName(
Context.getCanonicalType(Ty)));
NameInfo.setLoc(Name.StartLocation);
NameInfo.setNamedTypeInfo(TInfo);
return NameInfo;
}
case UnqualifiedId::IK_ConstructorName: {
TypeSourceInfo *TInfo;
QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo);
if (Ty.isNull())
return DeclarationNameInfo();
NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
Context.getCanonicalType(Ty)));
NameInfo.setLoc(Name.StartLocation);
NameInfo.setNamedTypeInfo(TInfo);
return NameInfo;
}
case UnqualifiedId::IK_ConstructorTemplateId: {
// In well-formed code, we can only have a constructor
// template-id that refers to the current context, so go there
// to find the actual type being constructed.
CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
return DeclarationNameInfo();
// Determine the type of the class being constructed.
QualType CurClassType = Context.getTypeDeclType(CurClass);
// FIXME: Check two things: that the template-id names the same type as
// CurClassType, and that the template-id does not occur when the name
// was qualified.
NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
Context.getCanonicalType(CurClassType)));
NameInfo.setLoc(Name.StartLocation);
// FIXME: should we retrieve TypeSourceInfo?
NameInfo.setNamedTypeInfo(0);
return NameInfo;
}
case UnqualifiedId::IK_DestructorName: {
TypeSourceInfo *TInfo;
QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo);
if (Ty.isNull())
return DeclarationNameInfo();
NameInfo.setName(Context.DeclarationNames.getCXXDestructorName(
Context.getCanonicalType(Ty)));
NameInfo.setLoc(Name.StartLocation);
NameInfo.setNamedTypeInfo(TInfo);
return NameInfo;
}
case UnqualifiedId::IK_TemplateId: {
TemplateName TName = Name.TemplateId->Template.get();
SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
return Context.getNameForTemplate(TName, TNameLoc);
}
} // switch (Name.getKind())
llvm_unreachable("Unknown name kind");
}
static QualType getCoreType(QualType Ty) {
do {
if (Ty->isPointerType() || Ty->isReferenceType())
Ty = Ty->getPointeeType();
else if (Ty->isArrayType())
Ty = Ty->castAsArrayTypeUnsafe()->getElementType();
else
return Ty.withoutLocalFastQualifiers();
} while (true);
}
/// hasSimilarParameters - Determine whether the C++ functions Declaration
/// and Definition have "nearly" matching parameters. This heuristic is
/// used to improve diagnostics in the case where an out-of-line function
/// definition doesn't match any declaration within the class or namespace.
/// Also sets Params to the list of indices to the parameters that differ
/// between the declaration and the definition. If hasSimilarParameters
/// returns true and Params is empty, then all of the parameters match.
static bool hasSimilarParameters(ASTContext &Context,
FunctionDecl *Declaration,
FunctionDecl *Definition,
SmallVectorImpl<unsigned> &Params) {
Params.clear();
if (Declaration->param_size() != Definition->param_size())
return false;
for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
// The parameter types are identical
if (Context.hasSameType(DefParamTy, DeclParamTy))
continue;
QualType DeclParamBaseTy = getCoreType(DeclParamTy);
QualType DefParamBaseTy = getCoreType(DefParamTy);
const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier();
const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier();
if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) ||
(DeclTyName && DeclTyName == DefTyName))
Params.push_back(Idx);
else // The two parameters aren't even close
return false;
}
return true;
}
/// NeedsRebuildingInCurrentInstantiation - Checks whether the given
/// declarator needs to be rebuilt in the current instantiation.
/// Any bits of declarator which appear before the name are valid for
/// consideration here. That's specifically the type in the decl spec
/// and the base type in any member-pointer chunks.
static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D,
DeclarationName Name) {
// The types we specifically need to rebuild are:
// - typenames, typeofs, and decltypes
// - types which will become injected class names
// Of course, we also need to rebuild any type referencing such a
// type. It's safest to just say "dependent", but we call out a
// few cases here.
DeclSpec &DS = D.getMutableDeclSpec();
switch (DS.getTypeSpecType()) {
case DeclSpec::TST_typename:
case DeclSpec::TST_typeofType:
case DeclSpec::TST_underlyingType:
case DeclSpec::TST_atomic: {
// Grab the type from the parser.
TypeSourceInfo *TSI = 0;
QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
if (T.isNull() || !T->isDependentType()) break;
// Make sure there's a type source info. This isn't really much
// of a waste; most dependent types should have type source info
// attached already.
if (!TSI)
TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc());
// Rebuild the type in the current instantiation.
TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name);
if (!TSI) return true;
// Store the new type back in the decl spec.
ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI);
DS.UpdateTypeRep(LocType);
break;
}
case DeclSpec::TST_decltype:
case DeclSpec::TST_typeofExpr: {
Expr *E = DS.getRepAsExpr();
ExprResult Result = S.RebuildExprInCurrentInstantiation(E);
if (Result.isInvalid()) return true;
DS.UpdateExprRep(Result.get());
break;
}
default:
// Nothing to do for these decl specs.
break;
}
// It doesn't matter what order we do this in.
for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
DeclaratorChunk &Chunk = D.getTypeObject(I);
// The only type information in the declarator which can come
// before the declaration name is the base type of a member
// pointer.
if (Chunk.Kind != DeclaratorChunk::MemberPointer)
continue;
// Rebuild the scope specifier in-place.
CXXScopeSpec &SS = Chunk.Mem.Scope();
if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS))
return true;
}
return false;
}
Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) {
D.setFunctionDefinitionKind(FDK_Declaration);
Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg());
if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() &&
Dcl && Dcl->getDeclContext()->isFileContext())
Dcl->setTopLevelDeclInObjCContainer();
return Dcl;
}
/// DiagnoseClassNameShadow - Implement C++ [class.mem]p13:
/// If T is the name of a class, then each of the following shall have a
/// name different from T:
/// - every static data member of class T;
/// - every member function of class T
/// - every member of class T that is itself a type;
/// \returns true if the declaration name violates these rules.
bool Sema::DiagnoseClassNameShadow(DeclContext *DC,
DeclarationNameInfo NameInfo) {
DeclarationName Name = NameInfo.getName();
if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
if (Record->getIdentifier() && Record->getDeclName() == Name) {
Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name;
return true;
}
return false;
}
/// \brief Diagnose a declaration whose declarator-id has the given
/// nested-name-specifier.
///
/// \param SS The nested-name-specifier of the declarator-id.
///
/// \param DC The declaration context to which the nested-name-specifier
/// resolves.
///
/// \param Name The name of the entity being declared.
///
/// \param Loc The location of the name of the entity being declared.
///
/// \returns true if we cannot safely recover from this error, false otherwise.
bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
DeclarationName Name,
SourceLocation Loc) {
DeclContext *Cur = CurContext;
while (isa<LinkageSpecDecl>(Cur))
Cur = Cur->getParent();
// C++ [dcl.meaning]p1:
// A declarator-id shall not be qualified except for the definition
// of a member function (9.3) or static data member (9.4) outside of
// its class, the definition or explicit instantiation of a function
// or variable member of a namespace outside of its namespace, or the
// definition of an explicit specialization outside of its namespace,
// or the declaration of a friend function that is a member of
// another class or namespace (11.3). [...]
// The user provided a superfluous scope specifier that refers back to the
// class or namespaces in which the entity is already declared.
//
// class X {
// void X::f();
// };
if (Cur->Equals(DC)) {
Diag(Loc, LangOpts.MicrosoftExt? diag::warn_member_extra_qualification
: diag::err_member_extra_qualification)
<< Name << FixItHint::CreateRemoval(SS.getRange());
SS.clear();
return false;
}
// Check whether the qualifying scope encloses the scope of the original
// declaration.
if (!Cur->Encloses(DC)) {
if (Cur->isRecord())
Diag(Loc, diag::err_member_qualification)
<< Name << SS.getRange();
else if (isa<TranslationUnitDecl>(DC))
Diag(Loc, diag::err_invalid_declarator_global_scope)
<< Name << SS.getRange();
else if (isa<FunctionDecl>(Cur))
Diag(Loc, diag::err_invalid_declarator_in_function)
<< Name << SS.getRange();
else
Diag(Loc, diag::err_invalid_declarator_scope)
<< Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange();
return true;
}
if (Cur->isRecord()) {
// Cannot qualify members within a class.
Diag(Loc, diag::err_member_qualification)
<< Name << SS.getRange();
SS.clear();
// C++ constructors and destructors with incorrect scopes can break
// our AST invariants by having the wrong underlying types. If
// that's the case, then drop this declaration entirely.
if ((Name.getNameKind() == DeclarationName::CXXConstructorName ||
Name.getNameKind() == DeclarationName::CXXDestructorName) &&
!Context.hasSameType(Name.getCXXNameType(),
Context.getTypeDeclType(cast<CXXRecordDecl>(Cur))))
return true;
return false;
}
// C++11 [dcl.meaning]p1:
// [...] "The nested-name-specifier of the qualified declarator-id shall
// not begin with a decltype-specifer"
NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data());
while (SpecLoc.getPrefix())
SpecLoc = SpecLoc.getPrefix();
if (dyn_cast_or_null<DecltypeType>(
SpecLoc.getNestedNameSpecifier()->getAsType()))
Diag(Loc, diag::err_decltype_in_declarator)
<< SpecLoc.getTypeLoc().getSourceRange();
return false;
}
NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D,
MultiTemplateParamsArg TemplateParamLists) {
// TODO: consider using NameInfo for diagnostic.
DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
DeclarationName Name = NameInfo.getName();
// All of these full declarators require an identifier. If it doesn't have
// one, the ParsedFreeStandingDeclSpec action should be used.
if (!Name) {
if (!D.isInvalidType()) // Reject this if we think it is valid.
Diag(D.getDeclSpec().getLocStart(),
diag::err_declarator_need_ident)
<< D.getDeclSpec().getSourceRange() << D.getSourceRange();
return 0;
} else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType))
return 0;
// The scope passed in may not be a decl scope. Zip up the scope tree until
// we find one that is.
while ((S->getFlags() & Scope::DeclScope) == 0 ||
(S->getFlags() & Scope::TemplateParamScope) != 0)
S = S->getParent();
DeclContext *DC = CurContext;
if (D.getCXXScopeSpec().isInvalid())
D.setInvalidType();
else if (D.getCXXScopeSpec().isSet()) {
if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(),
UPPC_DeclarationQualifier))
return 0;
bool EnteringContext = !D.getDeclSpec().isFriendSpecified();
DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext);
if (!DC) {
// If we could not compute the declaration context, it's because the
// declaration context is dependent but does not refer to a class,
// class template, or class template partial specialization. Complain
// and return early, to avoid the coming semantic disaster.
Diag(D.getIdentifierLoc(),
diag::err_template_qualified_declarator_no_match)
<< (NestedNameSpecifier*)D.getCXXScopeSpec().getScopeRep()
<< D.getCXXScopeSpec().getRange();
return 0;
}
bool IsDependentContext = DC->isDependentContext();
if (!IsDependentContext &&
RequireCompleteDeclContext(D.getCXXScopeSpec(), DC))
return 0;
if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
Diag(D.getIdentifierLoc(),
diag::err_member_def_undefined_record)
<< Name << DC << D.getCXXScopeSpec().getRange();
D.setInvalidType();
} else if (!D.getDeclSpec().isFriendSpecified()) {
if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC,
Name, D.getIdentifierLoc())) {
if (DC->isRecord())
return 0;
D.setInvalidType();
}
}
// Check whether we need to rebuild the type of the given
// declaration in the current instantiation.
if (EnteringContext && IsDependentContext &&
TemplateParamLists.size() != 0) {
ContextRAII SavedContext(*this, DC);
if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name))
D.setInvalidType();
}
}
if (DiagnoseClassNameShadow(DC, NameInfo))
// If this is a typedef, we'll end up spewing multiple diagnostics.
// Just return early; it's safer.
if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
return 0;
TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
QualType R = TInfo->getType();
if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
UPPC_DeclarationType))
D.setInvalidType();
LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
ForRedeclaration);
// See if this is a redefinition of a variable in the same scope.
if (!D.getCXXScopeSpec().isSet()) {
bool IsLinkageLookup = false;
// If the declaration we're planning to build will be a function
// or object with linkage, then look for another declaration with
// linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
/* Do nothing*/;
else if (R->isFunctionType()) {
if (CurContext->isFunctionOrMethod() ||
D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
IsLinkageLookup = true;
} else if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern)
IsLinkageLookup = true;
else if (CurContext->getRedeclContext()->isTranslationUnit() &&
D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
IsLinkageLookup = true;
if (IsLinkageLookup)
Previous.clear(LookupRedeclarationWithLinkage);
LookupName(Previous, S, /* CreateBuiltins = */ IsLinkageLookup);
} else { // Something like "int foo::x;"
LookupQualifiedName(Previous, DC);
// C++ [dcl.meaning]p1:
// When the declarator-id is qualified, the declaration shall refer to a
// previously declared member of the class or namespace to which the
// qualifier refers (or, in the case of a namespace, of an element of the
// inline namespace set of that namespace (7.3.1)) or to a specialization
// thereof; [...]
//
// Note that we already checked the context above, and that we do not have
// enough information to make sure that Previous contains the declaration
// we want to match. For example, given:
//
// class X {
// void f();
// void f(float);
// };
//
// void X::f(int) { } // ill-formed
//
// In this case, Previous will point to the overload set
// containing the two f's declared in X, but neither of them
// matches.
// C++ [dcl.meaning]p1:
// [...] the member shall not merely have been introduced by a
// using-declaration in the scope of the class or namespace nominated by
// the nested-name-specifier of the declarator-id.
RemoveUsingDecls(Previous);
}
if (Previous.isSingleResult() &&
Previous.getFoundDecl()->isTemplateParameter()) {
// Maybe we will complain about the shadowed template parameter.
if (!D.isInvalidType())
DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
Previous.getFoundDecl());
// Just pretend that we didn't see the previous declaration.
Previous.clear();
}
// In C++, the previous declaration we find might be a tag type
// (class or enum). In this case, the new declaration will hide the
// tag type. Note that this does does not apply if we're declaring a
// typedef (C++ [dcl.typedef]p4).
if (Previous.isSingleTagDecl() &&
D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
Previous.clear();
// Check that there are no default arguments other than in the parameters
// of a function declaration (C++ only).
if (getLangOpts().CPlusPlus)
CheckExtraCXXDefaultArguments(D);
NamedDecl *New;
bool AddToScope = true;
if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
if (TemplateParamLists.size()) {
Diag(D.getIdentifierLoc(), diag::err_template_typedef);
return 0;
}
New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous);
} else if (R->isFunctionType()) {
New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous,
TemplateParamLists,
AddToScope);
} else {
New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous,
TemplateParamLists);
}
if (New == 0)
return 0;
// If this has an identifier and is not an invalid redeclaration or
// function template specialization, add it to the scope stack.
if (New->getDeclName() && AddToScope &&
!(D.isRedeclaration() && New->isInvalidDecl()))
PushOnScopeChains(New, S);
return New;
}
/// Helper method to turn variable array types into constant array
/// types in certain situations which would otherwise be errors (for
/// GCC compatibility).
static QualType TryToFixInvalidVariablyModifiedType(QualType T,
ASTContext &Context,
bool &SizeIsNegative,
llvm::APSInt &Oversized) {
// This method tries to turn a variable array into a constant
// array even when the size isn't an ICE. This is necessary
// for compatibility with code that depends on gcc's buggy
// constant expression folding, like struct {char x[(int)(char*)2];}
SizeIsNegative = false;
Oversized = 0;
if (T->isDependentType())
return QualType();
QualifierCollector Qs;
const Type *Ty = Qs.strip(T);
if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
QualType Pointee = PTy->getPointeeType();
QualType FixedType =
TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative,
Oversized);
if (FixedType.isNull()) return FixedType;
FixedType = Context.getPointerType(FixedType);
return Qs.apply(Context, FixedType);
}
if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
QualType Inner = PTy->getInnerType();
QualType FixedType =
TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative,
Oversized);
if (FixedType.isNull()) return FixedType;
FixedType = Context.getParenType(FixedType);
return Qs.apply(Context, FixedType);
}
const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
if (!VLATy)
return QualType();
// FIXME: We should probably handle this case
if (VLATy->getElementType()->isVariablyModifiedType())
return QualType();
llvm::APSInt Res;
if (!VLATy->getSizeExpr() ||
!VLATy->getSizeExpr()->EvaluateAsInt(Res, Context))
return QualType();
// Check whether the array size is negative.
if (Res.isSigned() && Res.isNegative()) {
SizeIsNegative = true;
return QualType();
}
// Check whether the array is too large to be addressed.
unsigned ActiveSizeBits
= ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(),
Res);
if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
Oversized = Res;
return QualType();
}
return Context.getConstantArrayType(VLATy->getElementType(),
Res, ArrayType::Normal, 0);
}
static void
FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) {
if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) {
PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>();
FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(),
DstPTL.getPointeeLoc());
DstPTL.setStarLoc(SrcPTL.getStarLoc());
return;
}
if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) {
ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>();
FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(),
DstPTL.getInnerLoc());
DstPTL.setLParenLoc(SrcPTL.getLParenLoc());
DstPTL.setRParenLoc(SrcPTL.getRParenLoc());
return;
}
ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>();
ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>();
TypeLoc SrcElemTL = SrcATL.getElementLoc();
TypeLoc DstElemTL = DstATL.getElementLoc();
DstElemTL.initializeFullCopy(SrcElemTL);
DstATL.setLBracketLoc(SrcATL.getLBracketLoc());
DstATL.setSizeExpr(SrcATL.getSizeExpr());
DstATL.setRBracketLoc(SrcATL.getRBracketLoc());
}
/// Helper method to turn variable array types into constant array
/// types in certain situations which would otherwise be errors (for
/// GCC compatibility).
static TypeSourceInfo*
TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo,
ASTContext &Context,
bool &SizeIsNegative,
llvm::APSInt &Oversized) {
QualType FixedTy
= TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context,
SizeIsNegative, Oversized);
if (FixedTy.isNull())
return 0;
TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy);
FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(),
FixedTInfo->getTypeLoc());
return FixedTInfo;
}
/// \brief Register the given locally-scoped extern "C" declaration so
/// that it can be found later for redeclarations
void
Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND,
const LookupResult &Previous,
Scope *S) {
assert(ND->getLexicalDeclContext()->isFunctionOrMethod() &&
"Decl is not a locally-scoped decl!");
// Note that we have a locally-scoped external with this name.
LocallyScopedExternCDecls[ND->getDeclName()] = ND;
}
llvm::DenseMap<DeclarationName, NamedDecl *>::iterator
Sema::findLocallyScopedExternCDecl(DeclarationName Name) {
if (ExternalSource) {
// Load locally-scoped external decls from the external source.
SmallVector<NamedDecl *, 4> Decls;
ExternalSource->ReadLocallyScopedExternCDecls(Decls);
for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
= LocallyScopedExternCDecls.find(Decls[I]->getDeclName());
if (Pos == LocallyScopedExternCDecls.end())
LocallyScopedExternCDecls[Decls[I]->getDeclName()] = Decls[I];
}
}
return LocallyScopedExternCDecls.find(Name);
}
/// \brief Diagnose function specifiers on a declaration of an identifier that
/// does not identify a function.
void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) {
// FIXME: We should probably indicate the identifier in question to avoid
// confusion for constructs like "inline int a(), b;"
if (DS.isInlineSpecified())
Diag(DS.getInlineSpecLoc(),
diag::err_inline_non_function);
if (DS.isVirtualSpecified())
Diag(DS.getVirtualSpecLoc(),
diag::err_virtual_non_function);
if (DS.isExplicitSpecified())
Diag(DS.getExplicitSpecLoc(),
diag::err_explicit_non_function);
if (DS.isNoreturnSpecified())
Diag(DS.getNoreturnSpecLoc(),
diag::err_noreturn_non_function);
}
NamedDecl*
Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
TypeSourceInfo *TInfo, LookupResult &Previous) {
// Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
if (D.getCXXScopeSpec().isSet()) {
Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
<< D.getCXXScopeSpec().getRange();
D.setInvalidType();
// Pretend we didn't see the scope specifier.
DC = CurContext;
Previous.clear();
}
DiagnoseFunctionSpecifiers(D.getDeclSpec());
if (D.getDeclSpec().isConstexprSpecified())
Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
<< 1;
if (D.getName().Kind != UnqualifiedId::IK_Identifier) {
Diag(D.getName().StartLocation, diag::err_typedef_not_identifier)
<< D.getName().getSourceRange();
return 0;
}
TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo);
if (!NewTD) return 0;
// Handle attributes prior to checking for duplicates in MergeVarDecl
ProcessDeclAttributes(S, NewTD, D);
CheckTypedefForVariablyModifiedType(S, NewTD);
bool Redeclaration = D.isRedeclaration();
NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration);
D.setRedeclaration(Redeclaration);
return ND;
}
void
Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) {
// C99 6.7.7p2: If a typedef name specifies a variably modified type
// then it shall have block scope.
// Note that variably modified types must be fixed before merging the decl so
// that redeclarations will match.
TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo();
QualType T = TInfo->getType();
if (T->isVariablyModifiedType()) {
getCurFunction()->setHasBranchProtectedScope();
if (S->getFnParent() == 0) {
bool SizeIsNegative;
llvm::APSInt Oversized;
TypeSourceInfo *FixedTInfo =
TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
SizeIsNegative,
Oversized);
if (FixedTInfo) {
Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size);
NewTD->setTypeSourceInfo(FixedTInfo);
} else {
if (SizeIsNegative)
Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size);
else if (T->isVariableArrayType())
Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope);
else if (Oversized.getBoolValue())
Diag(NewTD->getLocation(), diag::err_array_too_large)
<< Oversized.toString(10);
else
Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope);
NewTD->setInvalidDecl();
}
}
}
}
/// ActOnTypedefNameDecl - Perform semantic checking for a declaration which
/// declares a typedef-name, either using the 'typedef' type specifier or via
/// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'.
NamedDecl*
Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD,
LookupResult &Previous, bool &Redeclaration) {
// Merge the decl with the existing one if appropriate. If the decl is
// in an outer scope, it isn't the same thing.
FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/ false,
/*ExplicitInstantiationOrSpecialization=*/false);
filterNonConflictingPreviousDecls(Context, NewTD, Previous);
if (!Previous.empty()) {
Redeclaration = true;
MergeTypedefNameDecl(NewTD, Previous);
}
// If this is the C FILE type, notify the AST context.
if (IdentifierInfo *II = NewTD->getIdentifier())
if (!NewTD->isInvalidDecl() &&
NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
if (II->isStr("FILE"))
Context.setFILEDecl(NewTD);
else if (II->isStr("jmp_buf"))
Context.setjmp_bufDecl(NewTD);
else if (II->isStr("sigjmp_buf"))
Context.setsigjmp_bufDecl(NewTD);
else if (II->isStr("ucontext_t"))
Context.setucontext_tDecl(NewTD);
}
return NewTD;
}
/// \brief Determines whether the given declaration is an out-of-scope
/// previous declaration.
///
/// This routine should be invoked when name lookup has found a
/// previous declaration (PrevDecl) that is not in the scope where a
/// new declaration by the same name is being introduced. If the new
/// declaration occurs in a local scope, previous declarations with
/// linkage may still be considered previous declarations (C99
/// 6.2.2p4-5, C++ [basic.link]p6).
///
/// \param PrevDecl the previous declaration found by name
/// lookup
///
/// \param DC the context in which the new declaration is being
/// declared.
///
/// \returns true if PrevDecl is an out-of-scope previous declaration
/// for a new delcaration with the same name.
static bool
isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
ASTContext &Context) {
if (!PrevDecl)
return false;
if (!PrevDecl->hasLinkage())
return false;
if (Context.getLangOpts().CPlusPlus) {
// C++ [basic.link]p6:
// If there is a visible declaration of an entity with linkage
// having the same name and type, ignoring entities declared
// outside the innermost enclosing namespace scope, the block
// scope declaration declares that same entity and receives the
// linkage of the previous declaration.
DeclContext *OuterContext = DC->getRedeclContext();
if (!OuterContext->isFunctionOrMethod())
// This rule only applies to block-scope declarations.
return false;
DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
if (PrevOuterContext->isRecord())
// We found a member function: ignore it.
return false;
// Find the innermost enclosing namespace for the new and
// previous declarations.
OuterContext = OuterContext->getEnclosingNamespaceContext();
PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext();
// The previous declaration is in a different namespace, so it
// isn't the same function.
if (!OuterContext->Equals(PrevOuterContext))
return false;
}
return true;
}
static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) {
CXXScopeSpec &SS = D.getCXXScopeSpec();
if (!SS.isSet()) return;
DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext()));
}
bool Sema::inferObjCARCLifetime(ValueDecl *decl) {
QualType type = decl->getType();
Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
if (lifetime == Qualifiers::OCL_Autoreleasing) {
// Various kinds of declaration aren't allowed to be __autoreleasing.
unsigned kind = -1U;
if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
if (var->hasAttr<BlocksAttr>())
kind = 0; // __block
else if (!var->hasLocalStorage())
kind = 1; // global
} else if (isa<ObjCIvarDecl>(decl)) {
kind = 3; // ivar
} else if (isa<FieldDecl>(decl)) {
kind = 2; // field
}
if (kind != -1U) {
Diag(decl->getLocation(), diag::err_arc_autoreleasing_var)
<< kind;
}
} else if (lifetime == Qualifiers::OCL_None) {
// Try to infer lifetime.
if (!type->isObjCLifetimeType())
return false;
lifetime = type->getObjCARCImplicitLifetime();
type = Context.getLifetimeQualifiedType(type, lifetime);
decl->setType(type);
}
if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
// Thread-local variables cannot have lifetime.
if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone &&
var->getTLSKind()) {
Diag(var->getLocation(), diag::err_arc_thread_ownership)
<< var->getType();
return true;
}
}
return false;
}
static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) {
// 'weak' only applies to declarations with external linkage.
if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) {
if (ND.getLinkage() != ExternalLinkage) {
S.Diag(Attr->getLocation(), diag::err_attribute_weak_static);
ND.dropAttr<WeakAttr>();
}
}
if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) {
if (ND.hasExternalLinkage()) {
S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static);
ND.dropAttr<WeakRefAttr>();
}
}
}
/// Given that we are within the definition of the given function,
/// will that definition behave like C99's 'inline', where the
/// definition is discarded except for optimization purposes?
static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) {
// Try to avoid calling GetGVALinkageForFunction.
// All cases of this require the 'inline' keyword.
if (!FD->isInlined()) return false;
// This is only possible in C++ with the gnu_inline attribute.
if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>())
return false;
// Okay, go ahead and call the relatively-more-expensive function.
#ifndef NDEBUG
// AST quite reasonably asserts that it's working on a function
// definition. We don't really have a way to tell it that we're
// currently defining the function, so just lie to it in +Asserts
// builds. This is an awful hack.
FD->setLazyBody(1);
#endif
bool isC99Inline = (S.Context.GetGVALinkageForFunction(FD) == GVA_C99Inline);
#ifndef NDEBUG
FD->setLazyBody(0);
#endif
return isC99Inline;
}
static bool shouldConsiderLinkage(const VarDecl *VD) {
const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
if (DC->isFunctionOrMethod())
return VD->hasExternalStorage();
if (DC->isFileContext())
return true;
if (DC->isRecord())
return false;
llvm_unreachable("Unexpected context");
}
static bool shouldConsiderLinkage(const FunctionDecl *FD) {
const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
if (DC->isFileContext() || DC->isFunctionOrMethod())
return true;
if (DC->isRecord())
return false;
llvm_unreachable("Unexpected context");
}
NamedDecl*
Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
TypeSourceInfo *TInfo, LookupResult &Previous,
MultiTemplateParamsArg TemplateParamLists) {
QualType R = TInfo->getType();
DeclarationName Name = GetNameForDeclarator(D).getName();
DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
VarDecl::StorageClass SC =
StorageClassSpecToVarDeclStorageClass(D.getDeclSpec());
if (getLangOpts().OpenCL && !getOpenCLOptions().cl_khr_fp16) {
// OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and
// half array type (unless the cl_khr_fp16 extension is enabled).
if (Context.getBaseElementType(R)->isHalfType()) {
Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R;
D.setInvalidType();
}
}
if (SCSpec == DeclSpec::SCS_mutable) {
// mutable can only appear on non-static class members, so it's always
// an error here
Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
D.setInvalidType();
SC = SC_None;
}
// C++11 [dcl.stc]p4:
// When thread_local is applied to a variable of block scope the
// storage-class-specifier static is implied if it does not appear
// explicitly.
// Core issue: 'static' is not implied if the variable is declared 'extern'.
if (SCSpec == DeclSpec::SCS_unspecified &&
D.getDeclSpec().getThreadStorageClassSpec() ==
DeclSpec::TSCS_thread_local && DC->isFunctionOrMethod())
SC = SC_Static;
IdentifierInfo *II = Name.getAsIdentifierInfo();
if (!II) {
Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
<< Name;
return 0;
}
DiagnoseFunctionSpecifiers(D.getDeclSpec());
if (!DC->isRecord() && S->getFnParent() == 0) {
// C99 6.9p2: The storage-class specifiers auto and register shall not
// appear in the declaration specifiers in an external declaration.
if (SC == SC_Auto || SC == SC_Register) {
// If this is a register variable with an asm label specified, then this
// is a GNU extension.
if (SC == SC_Register && D.getAsmLabel())
Diag(D.getIdentifierLoc(), diag::err_unsupported_global_register);
else
Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
D.setInvalidType();
}
}
if (getLangOpts().OpenCL) {
// Set up the special work-group-local storage class for variables in the
// OpenCL __local address space.
if (R.getAddressSpace() == LangAS::opencl_local) {
SC = SC_OpenCLWorkGroupLocal;
}
// OpenCL v1.2 s6.9.b p4:
// The sampler type cannot be used with the __local and __global address
// space qualifiers.
if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local ||
R.getAddressSpace() == LangAS::opencl_global)) {
Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace);
}
// OpenCL 1.2 spec, p6.9 r:
// The event type cannot be used to declare a program scope variable.
// The event type cannot be used with the __local, __constant and __global
// address space qualifiers.
if (R->isEventT()) {
if (S->getParent() == 0) {
Diag(D.getLocStart(), diag::err_event_t_global_var);
D.setInvalidType();
}
if (R.getAddressSpace()) {
Diag(D.getLocStart(), diag::err_event_t_addr_space_qual);
D.setInvalidType();
}
}
}
bool isExplicitSpecialization = false;
VarDecl *NewVD;
if (!getLangOpts().CPlusPlus) {
NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
D.getIdentifierLoc(), II,
R, TInfo, SC);
if (D.isInvalidType())
NewVD->setInvalidDecl();
} else {
if (DC->isRecord() && !CurContext->isRecord()) {
// This is an out-of-line definition of a static data member.
if (SC == SC_Static) {
Diag(D.getDeclSpec().getStorageClassSpecLoc(),
diag::err_static_out_of_line)
<< FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
}
}
if (SC == SC_Static && CurContext->isRecord()) {
if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
if (RD->isLocalClass())
Diag(D.getIdentifierLoc(),
diag::err_static_data_member_not_allowed_in_local_class)
<< Name << RD->getDeclName();
// C++98 [class.union]p1: If a union contains a static data member,
// the program is ill-formed. C++11 drops this restriction.
if (RD->isUnion())
Diag(D.getIdentifierLoc(),
getLangOpts().CPlusPlus11
? diag::warn_cxx98_compat_static_data_member_in_union
: diag::ext_static_data_member_in_union) << Name;
// We conservatively disallow static data members in anonymous structs.
else if (!RD->getDeclName())
Diag(D.getIdentifierLoc(),
diag::err_static_data_member_not_allowed_in_anon_struct)
<< Name << RD->isUnion();
}
}
// Match up the template parameter lists with the scope specifier, then
// determine whether we have a template or a template specialization.
isExplicitSpecialization = false;
bool Invalid = false;
if (TemplateParameterList *TemplateParams
= MatchTemplateParametersToScopeSpecifier(
D.getDeclSpec().getLocStart(),
D.getIdentifierLoc(),
D.getCXXScopeSpec(),
TemplateParamLists.data(),
TemplateParamLists.size(),
/*never a friend*/ false,
isExplicitSpecialization,
Invalid)) {
if (TemplateParams->size() > 0) {
// There is no such thing as a variable template.
Diag(D.getIdentifierLoc(), diag::err_template_variable)
<< II
<< SourceRange(TemplateParams->getTemplateLoc(),
TemplateParams->getRAngleLoc());
return 0;
} else {
// There is an extraneous 'template<>' for this variable. Complain
// about it, but allow the declaration of the variable.
Diag(TemplateParams->getTemplateLoc(),
diag::err_template_variable_noparams)
<< II
<< SourceRange(TemplateParams->getTemplateLoc(),
TemplateParams->getRAngleLoc());
}
}
NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
D.getIdentifierLoc(), II,
R, TInfo, SC);
// If this decl has an auto type in need of deduction, make a note of the
// Decl so we can diagnose uses of it in its own initializer.
if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType())
ParsingInitForAutoVars.insert(NewVD);
if (D.isInvalidType() || Invalid)
NewVD->setInvalidDecl();
SetNestedNameSpecifier(NewVD, D);
if (TemplateParamLists.size() > 0 && D.getCXXScopeSpec().isSet()) {
NewVD->setTemplateParameterListsInfo(Context,
TemplateParamLists.size(),
TemplateParamLists.data());
}
if (D.getDeclSpec().isConstexprSpecified())
NewVD->setConstexpr(true);
}
// Set the lexical context. If the declarator has a C++ scope specifier, the
// lexical context will be different from the semantic context.
NewVD->setLexicalDeclContext(CurContext);
if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) {
if (NewVD->hasLocalStorage())
Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
diag::err_thread_non_global)
<< DeclSpec::getSpecifierName(TSCS);
else if (!Context.getTargetInfo().isTLSSupported())
Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
diag::err_thread_unsupported);
else
NewVD->setTSCSpec(TSCS);
}
// C99 6.7.4p3
// An inline definition of a function with external linkage shall
// not contain a definition of a modifiable object with static or
// thread storage duration...
// We only apply this when the function is required to be defined
// elsewhere, i.e. when the function is not 'extern inline'. Note
// that a local variable with thread storage duration still has to
// be marked 'static'. Also note that it's possible to get these
// semantics in C++ using __attribute__((gnu_inline)).
if (SC == SC_Static && S->getFnParent() != 0 &&
!NewVD->getType().isConstQualified()) {
FunctionDecl *CurFD = getCurFunctionDecl();
if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) {
Diag(D.getDeclSpec().getStorageClassSpecLoc(),
diag::warn_static_local_in_extern_inline);
MaybeSuggestAddingStaticToDecl(CurFD);
}
}
if (D.getDeclSpec().isModulePrivateSpecified()) {
if (isExplicitSpecialization)
Diag(NewVD->getLocation(), diag::err_module_private_specialization)
<< 2
<< FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
else if (NewVD->hasLocalStorage())
Diag(NewVD->getLocation(), diag::err_module_private_local)
<< 0 << NewVD->getDeclName()
<< SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
<< FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
else
NewVD->setModulePrivate();
}
// Handle attributes prior to checking for duplicates in MergeVarDecl
ProcessDeclAttributes(S, NewVD, D);
if (NewVD->hasAttrs())
CheckAlignasUnderalignment(NewVD);
if (getLangOpts().CUDA) {
// CUDA B.2.5: "__shared__ and __constant__ variables have implied static
// storage [duration]."
if (SC == SC_None && S->getFnParent() != 0 &&
(NewVD->hasAttr<CUDASharedAttr>() ||
NewVD->hasAttr<CUDAConstantAttr>())) {
NewVD->setStorageClass(SC_Static);
}
}
// In auto-retain/release, infer strong retension for variables of
// retainable type.
if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD))
NewVD->setInvalidDecl();
// Handle GNU asm-label extension (encoded as an attribute).
if (Expr *E = (Expr*)D.getAsmLabel()) {
// The parser guarantees this is a string.
StringLiteral *SE = cast<StringLiteral>(E);
StringRef Label = SE->getString();
if (S->getFnParent() != 0) {
switch (SC) {
case SC_None:
case SC_Auto:
Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;
break;
case SC_Register:
if (!Context.getTargetInfo().isValidGCCRegisterName(Label))
Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
break;
case SC_Static:
case SC_Extern:
case SC_PrivateExtern:
case SC_OpenCLWorkGroupLocal:
break;
}
}
NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0),
Context, Label));
} else if (!ExtnameUndeclaredIdentifiers.empty()) {
llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier());
if (I != ExtnameUndeclaredIdentifiers.end()) {
NewVD->addAttr(I->second);
ExtnameUndeclaredIdentifiers.erase(I);
}
}
// Diagnose shadowed variables before filtering for scope.
if (!D.getCXXScopeSpec().isSet())
CheckShadow(S, NewVD, Previous);
// Don't consider existing declarations that are in a different
// scope and are out-of-semantic-context declarations (if the new
// declaration has linkage).
FilterLookupForScope(Previous, DC, S, shouldConsiderLinkage(NewVD),
isExplicitSpecialization);
if (!getLangOpts().CPlusPlus) {
D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
} else {
// Merge the decl with the existing one if appropriate.
if (!Previous.empty()) {
if (Previous.isSingleResult() &&
isa<FieldDecl>(Previous.getFoundDecl()) &&
D.getCXXScopeSpec().isSet()) {
// The user tried to define a non-static data member
// out-of-line (C++ [dcl.meaning]p1).
Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
<< D.getCXXScopeSpec().getRange();
Previous.clear();
NewVD->setInvalidDecl();
}
} else if (D.getCXXScopeSpec().isSet()) {
// No previous declaration in the qualifying scope.
Diag(D.getIdentifierLoc(), diag::err_no_member)
<< Name << computeDeclContext(D.getCXXScopeSpec(), true)
<< D.getCXXScopeSpec().getRange();
NewVD->setInvalidDecl();
}
D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
// This is an explicit specialization of a static data member. Check it.
if (isExplicitSpecialization && !NewVD->isInvalidDecl() &&
CheckMemberSpecialization(NewVD, Previous))
NewVD->setInvalidDecl();
}
ProcessPragmaWeak(S, NewVD);
checkAttributesAfterMerging(*this, *NewVD);
// If this is a locally-scoped extern C variable, update the map of
// such variables.
if (CurContext->isFunctionOrMethod() && NewVD->isExternC() &&
!NewVD->isInvalidDecl())
RegisterLocallyScopedExternCDecl(NewVD, Previous, S);
return NewVD;
}
/// \brief Diagnose variable or built-in function shadowing. Implements
/// -Wshadow.
///
/// This method is called whenever a VarDecl is added to a "useful"
/// scope.
///
/// \param S the scope in which the shadowing name is being declared
/// \param R the lookup of the name
///
void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) {
// Return if warning is ignored.
if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, R.getNameLoc()) ==
DiagnosticsEngine::Ignored)
return;
// Don't diagnose declarations at file scope.
if (D->hasGlobalStorage())
return;
DeclContext *NewDC = D->getDeclContext();
// Only diagnose if we're shadowing an unambiguous field or variable.
if (R.getResultKind() != LookupResult::Found)
return;
NamedDecl* ShadowedDecl = R.getFoundDecl();
if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl))
return;
// Fields are not shadowed by variables in C++ static methods.
if (isa<FieldDecl>(ShadowedDecl))
if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC))
if (MD->isStatic())
return;
if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
if (shadowedVar->isExternC()) {
// For shadowing external vars, make sure that we point to the global
// declaration, not a locally scoped extern declaration.
for (VarDecl::redecl_iterator
I = shadowedVar->redecls_begin(), E = shadowedVar->redecls_end();
I != E; ++I)
if (I->isFileVarDecl()) {
ShadowedDecl = *I;
break;
}
}
DeclContext *OldDC = ShadowedDecl->getDeclContext();
// Only warn about certain kinds of shadowing for class members.
if (NewDC && NewDC->isRecord()) {
// In particular, don't warn about shadowing non-class members.
if (!OldDC->isRecord())
return;
// TODO: should we warn about static data members shadowing
// static data members from base classes?
// TODO: don't diagnose for inaccessible shadowed members.
// This is hard to do perfectly because we might friend the
// shadowing context, but that's just a false negative.
}
// Determine what kind of declaration we're shadowing.
unsigned Kind;
if (isa<RecordDecl>(OldDC)) {
if (isa<FieldDecl>(ShadowedDecl))
Kind = 3; // field
else
Kind = 2; // static data member
} else if (OldDC->isFileContext())
Kind = 1; // global
else
Kind = 0; // local
DeclarationName Name = R.getLookupName();
// Emit warning and note.
Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC;
Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
}
/// \brief Check -Wshadow without the advantage of a previous lookup.
void Sema::CheckShadow(Scope *S, VarDecl *D) {
if (Diags.getDiagnosticLevel(diag::warn_decl_shadow, D->getLocation()) ==
DiagnosticsEngine::Ignored)
return;
LookupResult R(*this, D->getDeclName(), D->getLocation(),
Sema::LookupOrdinaryName, Sema::ForRedeclaration);
LookupName(R, S);
CheckShadow(S, D, R);
}
template<typename T>
static bool mayConflictWithNonVisibleExternC(const T *ND) {
const DeclContext *DC = ND->getDeclContext();
if (DC->getRedeclContext()->isTranslationUnit())
return true;
// We know that is the first decl we see, other than function local
// extern C ones. If this is C++ and the decl is not in a extern C context
// it cannot have C language linkage. Avoid calling isExternC in that case.
// We need to this because of code like
//
// namespace { struct bar {}; }
// auto foo = bar();
//
// This code runs before the init of foo is set, and therefore before
// the type of foo is known. Not knowing the type we cannot know its linkage
// unless it is in an extern C block.
if (!ND->isInExternCContext()) {
const ASTContext &Context = ND->getASTContext();
if (Context.getLangOpts().CPlusPlus)
return false;
}
return ND->isExternC();
}
void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
// If the decl is already known invalid, don't check it.
if (NewVD->isInvalidDecl())
return;
TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo();
QualType T = TInfo->getType();
// Defer checking an 'auto' type until its initializer is attached.
if (T->isUndeducedType())
return;
if (T->isObjCObjectType()) {
Diag(NewVD->getLocation(), diag::err_statically_allocated_object)
<< FixItHint::CreateInsertion(NewVD->getLocation(), "*");
T = Context.getObjCObjectPointerType(T);
NewVD->setType(T);
}
// Emit an error if an address space was applied to decl with local storage.
// This includes arrays of objects with address space qualifiers, but not
// automatic variables that point to other address spaces.
// ISO/IEC TR 18037 S5.1.2
if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) {
Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
NewVD->setInvalidDecl();
return;
}
// OpenCL v1.2 s6.5 - All program scope variables must be declared in the
// __constant address space.
if (getLangOpts().OpenCL && NewVD->isFileVarDecl()
&& T.getAddressSpace() != LangAS::opencl_constant
&& !T->isSamplerT()){
Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space);
NewVD->setInvalidDecl();
return;
}
// OpenCL v1.2 s6.8 -- The static qualifier is valid only in program
// scope.
if ((getLangOpts().OpenCLVersion >= 120)
&& NewVD->isStaticLocal()) {
Diag(NewVD->getLocation(), diag::err_static_function_scope);
NewVD->setInvalidDecl();
return;
}
if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
&& !NewVD->hasAttr<BlocksAttr>()) {
if (getLangOpts().getGC() != LangOptions::NonGC)
Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local);
else {
assert(!getLangOpts().ObjCAutoRefCount);
Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
}
}
bool isVM = T->isVariablyModifiedType();
if (isVM || NewVD->hasAttr<CleanupAttr>() ||
NewVD->hasAttr<BlocksAttr>())
getCurFunction()->setHasBranchProtectedScope();
if ((isVM && NewVD->hasLinkage()) ||
(T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
bool SizeIsNegative;
llvm::APSInt Oversized;
TypeSourceInfo *FixedTInfo =
TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
SizeIsNegative, Oversized);
if (FixedTInfo == 0 && T->isVariableArrayType()) {
const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
// FIXME: This won't give the correct result for
// int a[10][n];
SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
if (NewVD->isFileVarDecl())
Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
<< SizeRange;
else if (NewVD->getStorageClass() == SC_Static)
Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
<< SizeRange;
else
Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
<< SizeRange;
NewVD->setInvalidDecl();
return;
}
if (FixedTInfo == 0) {
if (NewVD->isFileVarDecl())
Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
else
Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
NewVD->setInvalidDecl();
return;
}
Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
NewVD->setType(FixedTInfo->getType());
NewVD->setTypeSourceInfo(FixedTInfo);
}
if (T->isVoidType() && NewVD->isThisDeclarationADefinition()) {
Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
<< T;
NewVD->setInvalidDecl();
return;
}
if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
NewVD->setInvalidDecl();
return;
}
if (isVM && NewVD->hasAttr<BlocksAttr>()) {
Diag(NewVD->getLocation(), diag::err_block_on_vm);
NewVD->setInvalidDecl();
return;
}
if (NewVD->isConstexpr() && !T->isDependentType() &&
RequireLiteralType(NewVD->getLocation(), T,
diag::err_constexpr_var_non_literal)) {
// Can't perform this check until the type is deduced.
NewVD->setInvalidDecl();
return;
}
}
/// \brief Perform semantic checking on a newly-created variable
/// declaration.
///
/// This routine performs all of the type-checking required for a
/// variable declaration once it has been built. It is used both to
/// check variables after they have been parsed and their declarators
/// have been translated into a declaration, and to check variables
/// that have been instantiated from a template.
///
/// Sets NewVD->isInvalidDecl() if an error was encountered.
///
/// Returns true if the variable declaration is a redeclaration.
bool Sema::CheckVariableDeclaration(VarDecl *NewVD,
LookupResult &Previous) {
CheckVariableDeclarationType(NewVD);
// If the decl is already known invalid, don't check it.
if (NewVD->isInvalidDecl())
return false;
// If we did not find anything by this name, look for a non-visible
// extern "C" declaration with the same name.
//
// Clang has a lot of problems with extern local declarations.
// The actual standards text here is:
//
// C++11 [basic.link]p6:
// The name of a function declared in block scope and the name
// of a variable declared by a block scope extern declaration
// have linkage. If there is a visible declaration of an entity
// with linkage having the same name and type, ignoring entities
// declared outside the innermost enclosing namespace scope, the
// block scope declaration declares that same entity and
// receives the linkage of the previous declaration.
//
// C11 6.2.7p4:
// For an identifier with internal or external linkage declared
// in a scope in which a prior declaration of that identifier is
// visible, if the prior declaration specifies internal or
// external linkage, the type of the identifier at the later
// declaration becomes the composite type.
//
// The most important point here is that we're not allowed to
// update our understanding of the type according to declarations
// not in scope.
bool PreviousWasHidden = false;
if (Previous.empty() && mayConflictWithNonVisibleExternC(NewVD)) {
llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
= findLocallyScopedExternCDecl(NewVD->getDeclName());
if (Pos != LocallyScopedExternCDecls.end()) {
Previous.addDecl(Pos->second);
PreviousWasHidden = true;
}
}
// Filter out any non-conflicting previous declarations.
filterNonConflictingPreviousDecls(Context, NewVD, Previous);
if (!Previous.empty()) {
MergeVarDecl(NewVD, Previous, PreviousWasHidden);
return true;
}
return false;
}
/// \brief Data used with FindOverriddenMethod
struct FindOverriddenMethodData {
Sema *S;
CXXMethodDecl *Method;
};
/// \brief Member lookup function that determines whether a given C++
/// method overrides a method in a base class, to be used with
/// CXXRecordDecl::lookupInBases().
static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier,
CXXBasePath &Path,
void *UserData) {
RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
FindOverriddenMethodData *Data
= reinterpret_cast<FindOverriddenMethodData*>(UserData);
DeclarationName Name = Data->Method->getDeclName();
// FIXME: Do we care about other names here too?
if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
// We really want to find the base class destructor here.
QualType T = Data->S->Context.getTypeDeclType(BaseRecord);
CanQualType CT = Data->S->Context.getCanonicalType(T);
Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT);
}
for (Path.Decls = BaseRecord->lookup(Name);
!Path.Decls.empty();
Path.Decls = Path.Decls.slice(1)) {
NamedDecl *D = Path.Decls.front();
if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, false))
return true;
}
}
return false;
}
namespace {
enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted };
}
/// \brief Report an error regarding overriding, along with any relevant
/// overriden methods.
///
/// \param DiagID the primary error to report.
/// \param MD the overriding method.
/// \param OEK which overrides to include as notes.
static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD,
OverrideErrorKind OEK = OEK_All) {
S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
E = MD->end_overridden_methods();
I != E; ++I) {
// This check (& the OEK parameter) could be replaced by a predicate, but
// without lambdas that would be overkill. This is still nicer than writing
// out the diag loop 3 times.
if ((OEK == OEK_All) ||
(OEK == OEK_NonDeleted && !(*I)->isDeleted()) ||
(OEK == OEK_Deleted && (*I)->isDeleted()))
S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function);
}
}
/// AddOverriddenMethods - See if a method overrides any in the base classes,
/// and if so, check that it's a valid override and remember it.
bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
// Look for virtual methods in base classes that this method might override.
CXXBasePaths Paths;
FindOverriddenMethodData Data;
Data.Method = MD;
Data.S = this;
bool hasDeletedOverridenMethods = false;
bool hasNonDeletedOverridenMethods = false;
bool AddedAny = false;
if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) {
for (CXXBasePaths::decl_iterator I = Paths.found_decls_begin(),
E = Paths.found_decls_end(); I != E; ++I) {
if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(*I)) {
MD->addOverriddenMethod(OldMD->getCanonicalDecl());
if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
!CheckOverridingFunctionAttributes(MD, OldMD) &&
!CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
!CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) {
hasDeletedOverridenMethods |= OldMD->isDeleted();
hasNonDeletedOverridenMethods |= !OldMD->isDeleted();
AddedAny = true;
}
}
}
}
if (hasDeletedOverridenMethods && !MD->isDeleted()) {
ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted);
}
if (hasNonDeletedOverridenMethods && MD->isDeleted()) {
ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted);
}
return AddedAny;
}
namespace {
// Struct for holding all of the extra arguments needed by
// DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator.
struct ActOnFDArgs {
Scope *S;
Declarator &D;
MultiTemplateParamsArg TemplateParamLists;
bool AddToScope;
};
}
namespace {
// Callback to only accept typo corrections that have a non-zero edit distance.
// Also only accept corrections that have the same parent decl.
class DifferentNameValidatorCCC : public CorrectionCandidateCallback {
public:
DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD,
CXXRecordDecl *Parent)
: Context(Context), OriginalFD(TypoFD),
ExpectedParent(Parent ? Parent->getCanonicalDecl() : 0) {}
virtual bool ValidateCandidate(const TypoCorrection &candidate) {
if (candidate.getEditDistance() == 0)
return false;
SmallVector<unsigned, 1> MismatchedParams;
for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(),
CDeclEnd = candidate.end();
CDecl != CDeclEnd; ++CDecl) {
FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
if (FD && !FD->hasBody() &&
hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) {
if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
CXXRecordDecl *Parent = MD->getParent();
if (Parent && Parent->getCanonicalDecl() == ExpectedParent)
return true;
} else if (!ExpectedParent) {
return true;
}
}
}
return false;
}
private:
ASTContext &Context;
FunctionDecl *OriginalFD;
CXXRecordDecl *ExpectedParent;
};
}
/// \brief Generate diagnostics for an invalid function redeclaration.
///
/// This routine handles generating the diagnostic messages for an invalid
/// function redeclaration, including finding possible similar declarations
/// or performing typo correction if there are no previous declarations with
/// the same name.
///
/// Returns a NamedDecl iff typo correction was performed and substituting in
/// the new declaration name does not cause new errors.
static NamedDecl* DiagnoseInvalidRedeclaration(
Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
ActOnFDArgs &ExtraArgs) {
NamedDecl *Result = NULL;
DeclarationName Name = NewFD->getDeclName();
DeclContext *NewDC = NewFD->getDeclContext();
LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
Sema::LookupOrdinaryName, Sema::ForRedeclaration);
SmallVector<unsigned, 1> MismatchedParams;
SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches;
TypoCorrection Correction;
bool isFriendDecl = (SemaRef.getLangOpts().CPlusPlus &&
ExtraArgs.D.getDeclSpec().isFriendSpecified());
unsigned DiagMsg = isFriendDecl ? diag::err_no_matching_local_friend
: diag::err_member_def_does_not_match;
NewFD->setInvalidDecl();
SemaRef.LookupQualifiedName(Prev, NewDC);
assert(!Prev.isAmbiguous() &&
"Cannot have an ambiguity in previous-declaration lookup");
CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
DifferentNameValidatorCCC Validator(SemaRef.Context, NewFD,
MD ? MD->getParent() : 0);
if (!Prev.empty()) {
for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
Func != FuncEnd; ++Func) {
FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func);
if (FD &&
hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
// Add 1 to the index so that 0 can mean the mismatch didn't
// involve a parameter
unsigned ParamNum =
MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
NearMatches.push_back(std::make_pair(FD, ParamNum));
}
}
// If the qualified name lookup yielded nothing, try typo correction
} else if ((Correction = SemaRef.CorrectTypo(Prev.getLookupNameInfo(),
Prev.getLookupKind(), 0, 0,
Validator, NewDC))) {
// Trap errors.
Sema::SFINAETrap Trap(SemaRef);
// Set up everything for the call to ActOnFunctionDeclarator
ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(),
ExtraArgs.D.getIdentifierLoc());
Previous.clear();
Previous.setLookupName(Correction.getCorrection());
for (TypoCorrection::decl_iterator CDecl = Correction.begin(),
CDeclEnd = Correction.end();
CDecl != CDeclEnd; ++CDecl) {
FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
if (FD && !FD->hasBody() &&
hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
Previous.addDecl(FD);
}
}
bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
// TODO: Refactor ActOnFunctionDeclarator so that we can call only the
// pieces need to verify the typo-corrected C++ declaraction and hopefully
// eliminate the need for the parameter pack ExtraArgs.
Result = SemaRef.ActOnFunctionDeclarator(
ExtraArgs.S, ExtraArgs.D,
Correction.getCorrectionDecl()->getDeclContext(),
NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists,
ExtraArgs.AddToScope);
if (Trap.hasErrorOccurred()) {
// Pretend the typo correction never occurred
ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
ExtraArgs.D.getIdentifierLoc());
ExtraArgs.D.setRedeclaration(wasRedeclaration);
Previous.clear();
Previous.setLookupName(Name);
Result = NULL;
} else {
for (LookupResult::iterator Func = Previous.begin(),
FuncEnd = Previous.end();
Func != FuncEnd; ++Func) {
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func))
NearMatches.push_back(std::make_pair(FD, 0));
}
}
if (NearMatches.empty()) {
// Ignore the correction if it didn't yield any close FunctionDecl matches
Correction = TypoCorrection();
} else {
DiagMsg = isFriendDecl ? diag::err_no_matching_local_friend_suggest
: diag::err_member_def_does_not_match_suggest;
}
}
if (Correction) {
// FIXME: use Correction.getCorrectionRange() instead of computing the range
// here. This requires passing in the CXXScopeSpec to CorrectTypo which in
// turn causes the correction to fully qualify the name. If we fix
// CorrectTypo to minimally qualify then this change should be good.
SourceRange FixItLoc(NewFD->getLocation());
CXXScopeSpec &SS = ExtraArgs.D.getCXXScopeSpec();
if (Correction.getCorrectionSpecifier() && SS.isValid())
FixItLoc.setBegin(SS.getBeginLoc());
SemaRef.Diag(NewFD->getLocStart(), DiagMsg)
<< Name << NewDC << Correction.getQuoted(SemaRef.getLangOpts())
<< FixItHint::CreateReplacement(
FixItLoc, Correction.getAsString(SemaRef.getLangOpts()));
} else {
SemaRef.Diag(NewFD->getLocation(), DiagMsg)
<< Name << NewDC << NewFD->getLocation();
}
bool NewFDisConst = false;
if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD))
NewFDisConst = NewMD->isConst();
for (SmallVector<std::pair<FunctionDecl *, unsigned>, 1>::iterator
NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
NearMatch != NearMatchEnd; ++NearMatch) {
FunctionDecl *FD = NearMatch->first;
bool FDisConst = false;
if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD))
FDisConst = MD->isConst();
if (unsigned Idx = NearMatch->second) {
ParmVarDecl *FDParam = FD->getParamDecl(Idx-1);
SourceLocation Loc = FDParam->getTypeSpecStartLoc();
if (Loc.isInvalid()) Loc = FD->getLocation();
SemaRef.Diag(Loc, diag::note_member_def_close_param_match)
<< Idx << FDParam->getType() << NewFD->getParamDecl(Idx-1)->getType();
} else if (Correction) {
SemaRef.Diag(FD->getLocation(), diag::note_previous_decl)
<< Correction.getQuoted(SemaRef.getLangOpts());
} else if (FDisConst != NewFDisConst) {
SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match)
<< NewFDisConst << FD->getSourceRange().getEnd();
} else
SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_match);
}
return Result;
}
static FunctionDecl::StorageClass getFunctionStorageClass(Sema &SemaRef,
Declarator &D) {
switch (D.getDeclSpec().getStorageClassSpec()) {
default: llvm_unreachable("Unknown storage class!");
case DeclSpec::SCS_auto:
case DeclSpec::SCS_register:
case DeclSpec::SCS_mutable:
SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
diag::err_typecheck_sclass_func);
D.setInvalidType();
break;
case DeclSpec::SCS_unspecified: break;
case DeclSpec::SCS_extern:
if (D.getDeclSpec().isExternInLinkageSpec())
return SC_None;
return SC_Extern;
case DeclSpec::SCS_static: {
if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) {
// C99 6.7.1p5:
// The declaration of an identifier for a function that has
// block scope shall have no explicit storage-class specifier
// other than extern
// See also (C++ [dcl.stc]p4).
SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
diag::err_static_block_func);
break;
} else
return SC_Static;
}
case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
}
// No explicit storage class has already been returned
return SC_None;
}
static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
DeclContext *DC, QualType &R,
TypeSourceInfo *TInfo,
FunctionDecl::StorageClass SC,
bool &IsVirtualOkay) {
DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
DeclarationName Name = NameInfo.getName();
FunctionDecl *NewFD = 0;
bool isInline = D.getDeclSpec().isInlineSpecified();
if (!SemaRef.getLangOpts().CPlusPlus) {
// Determine whether the function was written with a
// prototype. This true when:
// - there is a prototype in the declarator, or
// - the type R of the function is some kind of typedef or other reference
// to a type name (which eventually refers to a function type).
bool HasPrototype =
(D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) ||
(!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
NewFD = FunctionDecl::Create(SemaRef.Context, DC,
D.getLocStart(), NameInfo, R,
TInfo, SC, isInline,
HasPrototype, false);
if (D.isInvalidType())
NewFD->setInvalidDecl();
// Set the lexical context.
NewFD->setLexicalDeclContext(SemaRef.CurContext);
return NewFD;
}
bool isExplicit = D.getDeclSpec().isExplicitSpecified();
bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
// Check that the return type is not an abstract class type.
// For record types, this is done by the AbstractClassUsageDiagnoser once
// the class has been completely parsed.
if (!DC->isRecord() &&
SemaRef.RequireNonAbstractType(D.getIdentifierLoc(),
R->getAs<FunctionType>()->getResultType(),
diag::err_abstract_type_in_decl,
SemaRef.AbstractReturnType))
D.setInvalidType();
if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
// This is a C++ constructor declaration.
assert(DC->isRecord() &&
"Constructors can only be declared in a member context");
R = SemaRef.CheckConstructorDeclarator(D, R, SC);
return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
D.getLocStart(), NameInfo,
R, TInfo, isExplicit, isInline,
/*isImplicitlyDeclared=*/false,
isConstexpr);
} else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
// This is a C++ destructor declaration.
if (DC->isRecord()) {
R = SemaRef.CheckDestructorDeclarator(D, R, SC);
CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
CXXDestructorDecl *NewDD = CXXDestructorDecl::Create(
SemaRef.Context, Record,
D.getLocStart(),
NameInfo, R, TInfo, isInline,
/*isImplicitlyDeclared=*/false);
// If the class is complete, then we now create the implicit exception
// specification. If the class is incomplete or dependent, we can't do
// it yet.
if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() &&
Record->getDefinition() && !Record->isBeingDefined() &&
R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) {
SemaRef.AdjustDestructorExceptionSpec(Record, NewDD);
}
IsVirtualOkay = true;
return NewDD;
} else {
SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
D.setInvalidType();
// Create a FunctionDecl to satisfy the function definition parsing
// code path.
return FunctionDecl::Create(SemaRef.Context, DC,
D.getLocStart(),
D.getIdentifierLoc(), Name, R, TInfo,
SC, isInline,
/*hasPrototype=*/true, isConstexpr);
}
} else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
if (!DC->isRecord()) {
SemaRef.Diag(D.getIdentifierLoc(),
diag::err_conv_function_not_member);
return 0;
}
SemaRef.CheckConversionDeclarator(D, R, SC);
IsVirtualOkay = true;
return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
D.getLocStart(), NameInfo,
R, TInfo, isInline, isExplicit,
isConstexpr, SourceLocation());
} else if (DC->isRecord()) {
// If the name of the function is the same as the name of the record,
// then this must be an invalid constructor that has a return type.
// (The parser checks for a return type and makes the declarator a
// constructor if it has no return type).
if (Name.getAsIdentifierInfo() &&
Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
<< SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
<< SourceRange(D.getIdentifierLoc());
return 0;
}
// This is a C++ method declaration.
CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context,
cast<CXXRecordDecl>(DC),
D.getLocStart(), NameInfo, R,
TInfo, SC, isInline,
isConstexpr, SourceLocation());
IsVirtualOkay = !Ret->isStatic();
return Ret;
} else {
// Determine whether the function was written with a
// prototype. This true when:
// - we're in C++ (where every function has a prototype),
return FunctionDecl::Create(SemaRef.Context, DC,
D.getLocStart(),
NameInfo, R, TInfo, SC, isInline,
true/*HasPrototype*/, isConstexpr);
}
}
void Sema::checkVoidParamDecl(ParmVarDecl *Param) {
// In C++, the empty parameter-type-list must be spelled "void"; a
// typedef of void is not permitted.
if (getLangOpts().CPlusPlus &&
Param->getType().getUnqualifiedType() != Context.VoidTy) {
bool IsTypeAlias = false;
if (const TypedefType *TT = Param->getType()->getAs<TypedefType>())
IsTypeAlias = isa<TypeAliasDecl>(TT->getDecl());
else if (const TemplateSpecializationType *TST =
Param->getType()->getAs<TemplateSpecializationType>())
IsTypeAlias = TST->isTypeAlias();
Diag(Param->getLocation(), diag::err_param_typedef_of_void)
<< IsTypeAlias;
}
}
NamedDecl*
Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
TypeSourceInfo *TInfo, LookupResult &Previous,
MultiTemplateParamsArg TemplateParamLists,
bool &AddToScope) {
QualType R = TInfo->getType();
assert(R.getTypePtr()->isFunctionType());
// TODO: consider using NameInfo for diagnostic.
DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
DeclarationName Name = NameInfo.getName();
FunctionDecl::StorageClass SC = getFunctionStorageClass(*this, D);
if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
diag::err_invalid_thread)
<< DeclSpec::getSpecifierName(TSCS);
// Do not allow returning a objc interface by-value.
if (R->getAs<FunctionType>()->getResultType()->isObjCObjectType()) {
Diag(D.getIdentifierLoc(),
diag::err_object_cannot_be_passed_returned_by_value) << 0
<< R->getAs<FunctionType>()->getResultType()
<< FixItHint::CreateInsertion(D.getIdentifierLoc(), "*");
QualType T = R->getAs<FunctionType>()->getResultType();
T = Context.getObjCObjectPointerType(T);
if (const FunctionProtoType *FPT = dyn_cast<FunctionProtoType>(R)) {
FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
R = Context.getFunctionType(T,
ArrayRef<QualType>(FPT->arg_type_begin(),
FPT->getNumArgs()),
EPI);
}
else if (isa<FunctionNoProtoType>(R))
R = Context.getFunctionNoProtoType(T);
}
bool isFriend = false;
FunctionTemplateDecl *FunctionTemplate = 0;
bool isExplicitSpecialization = false;
bool isFunctionTemplateSpecialization = false;
bool isDependentClassScopeExplicitSpecialization = false;
bool HasExplicitTemplateArgs = false;
TemplateArgumentListInfo TemplateArgs;
bool isVirtualOkay = false;
FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC,
isVirtualOkay);
if (!NewFD) return 0;
if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer())
NewFD->setTopLevelDeclInObjCContainer();
if (getLangOpts().CPlusPlus) {
bool isInline = D.getDeclSpec().isInlineSpecified();
bool isVirtual = D.getDeclSpec().isVirtualSpecified();
bool isExplicit = D.getDeclSpec().isExplicitSpecified();
bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
isFriend = D.getDeclSpec().isFriendSpecified();
if (isFriend && !isInline && D.isFunctionDefinition()) {
// C++ [class.friend]p5
// A function can be defined in a friend declaration of a
// class . . . . Such a function is implicitly inline.
NewFD->setImplicitlyInline();
}
// If this is a method defined in an __interface, and is not a constructor
// or an overloaded operator, then set the pure flag (isVirtual will already
// return true).
if (const CXXRecordDecl *Parent =
dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {
if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
NewFD->setPure(true);
}
SetNestedNameSpecifier(NewFD, D);
isExplicitSpecialization = false;
isFunctionTemplateSpecialization = false;
if (D.isInvalidType())
NewFD->setInvalidDecl();
// Set the lexical context. If the declarator has a C++
// scope specifier, or is the object of a friend declaration, the
// lexical context will be different from the semantic context.
NewFD->setLexicalDeclContext(CurContext);
// Match up the template parameter lists with the scope specifier, then
// determine whether we have a template or a template specialization.
bool Invalid = false;
if (TemplateParameterList *TemplateParams
= MatchTemplateParametersToScopeSpecifier(
D.getDeclSpec().getLocStart(),
D.getIdentifierLoc(),
D.getCXXScopeSpec(),
TemplateParamLists.data(),
TemplateParamLists.size(),
isFriend,
isExplicitSpecialization,
Invalid)) {
if (TemplateParams->size() > 0) {
// This is a function template
// Check that we can declare a template here.
if (CheckTemplateDeclScope(S, TemplateParams))
return 0;
// A destructor cannot be a template.
if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
Diag(NewFD->getLocation(), diag::err_destructor_template);
return 0;
}
// If we're adding a template to a dependent context, we may need to
// rebuilding some of the types used within the template parameter list,
// now that we know what the current instantiation is.
if (DC->isDependentContext()) {
ContextRAII SavedContext(*this, DC);
if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
Invalid = true;
}
FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
NewFD->getLocation(),
Name, TemplateParams,
NewFD);
FunctionTemplate->setLexicalDeclContext(CurContext);
NewFD->setDescribedFunctionTemplate(FunctionTemplate);
// For source fidelity, store the other template param lists.
if (TemplateParamLists.size() > 1) {
NewFD->setTemplateParameterListsInfo(Context,
TemplateParamLists.size() - 1,
TemplateParamLists.data());
}
} else {
// This is a function template specialization.
isFunctionTemplateSpecialization = true;
// For source fidelity, store all the template param lists.
NewFD->setTemplateParameterListsInfo(Context,
TemplateParamLists.size(),
TemplateParamLists.data());
// C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);".
if (isFriend) {
// We want to remove the "template<>", found here.
SourceRange RemoveRange = TemplateParams->getSourceRange();
// If we remove the template<> and the name is not a
// template-id, we're actually silently creating a problem:
// the friend declaration will refer to an untemplated decl,
// and clearly the user wants a template specialization. So
// we need to insert '<>' after the name.
SourceLocation InsertLoc;
if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
InsertLoc = D.getName().getSourceRange().getEnd();
InsertLoc = PP.getLocForEndOfToken(InsertLoc);
}
Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
<< Name << RemoveRange
<< FixItHint::CreateRemoval(RemoveRange)
<< FixItHint::CreateInsertion(InsertLoc, "<>");
}
}
}
else {
// All template param lists were matched against the scope specifier:
// this is NOT (an explicit specialization of) a template.
if (TemplateParamLists.size() > 0)
// For source fidelity, store all the template param lists.
NewFD->setTemplateParameterListsInfo(Context,
TemplateParamLists.size(),
TemplateParamLists.data());
}
if (Invalid) {
NewFD->setInvalidDecl();
if (FunctionTemplate)
FunctionTemplate->setInvalidDecl();
}
// C++ [dcl.fct.spec]p5:
// The virtual specifier shall only be used in declarations of
// nonstatic class member functions that appear within a
// member-specification of a class declaration; see 10.3.
//
if (isVirtual && !NewFD->isInvalidDecl()) {
if (!isVirtualOkay) {
Diag(D.getDeclSpec().getVirtualSpecLoc(),
diag::err_virtual_non_function);
} else if (!CurContext->isRecord()) {
// 'virtual' was specified outside of the class.
Diag(D.getDeclSpec().getVirtualSpecLoc(),
diag::err_virtual_out_of_class)
<< FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
} else if (NewFD->getDescribedFunctionTemplate()) {
// C++ [temp.mem]p3:
// A member function template shall not be virtual.
Diag(D.getDeclSpec().getVirtualSpecLoc(),
diag::err_virtual_member_function_template)
<< FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
} else {
// Okay: Add virtual to the method.
NewFD->setVirtualAsWritten(true);
}
if (getLangOpts().CPlusPlus1y &&
NewFD->getResultType()->isUndeducedType())
Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual);
}
// C++ [dcl.fct.spec]p3:
// The inline specifier shall not appear on a block scope function
// declaration.
if (isInline && !NewFD->isInvalidDecl()) {
if (CurContext->isFunctionOrMethod()) {
// 'inline' is not allowed on block scope function declaration.
Diag(D.getDeclSpec().getInlineSpecLoc(),
diag::err_inline_declaration_block_scope) << Name
<< FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
}
}
// C++ [dcl.fct.spec]p6:
// The explicit specifier shall be used only in the declaration of a
// constructor or conversion function within its class definition;
// see 12.3.1 and 12.3.2.
if (isExplicit && !NewFD->isInvalidDecl()) {
if (!CurContext->isRecord()) {
// 'explicit' was specified outside of the class.
Diag(D.getDeclSpec().getExplicitSpecLoc(),
diag::err_explicit_out_of_class)
<< FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
} else if (!isa<CXXConstructorDecl>(NewFD) &&
!isa<CXXConversionDecl>(NewFD)) {
// 'explicit' was specified on a function that wasn't a constructor
// or conversion function.
Diag(D.getDeclSpec().getExplicitSpecLoc(),
diag::err_explicit_non_ctor_or_conv_function)
<< FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
}
}
if (isConstexpr) {
// C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
// are implicitly inline.
NewFD->setImplicitlyInline();
// C++11 [dcl.constexpr]p3: functions declared constexpr are required to
// be either constructors or to return a literal type. Therefore,
// destructors cannot be declared constexpr.
if (isa<CXXDestructorDecl>(NewFD))
Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor);
}
// If __module_private__ was specified, mark the function accordingly.
if (D.getDeclSpec().isModulePrivateSpecified()) {
if (isFunctionTemplateSpecialization) {
SourceLocation ModulePrivateLoc
= D.getDeclSpec().getModulePrivateSpecLoc();
Diag(ModulePrivateLoc, diag::err_module_private_specialization)
<< 0
<< FixItHint::CreateRemoval(ModulePrivateLoc);
} else {
NewFD->setModulePrivate();
if (FunctionTemplate)
FunctionTemplate->setModulePrivate();
}
}
if (isFriend) {
// For now, claim that the objects have no previous declaration.
if (FunctionTemplate) {
FunctionTemplate->setObjectOfFriendDecl(false);
FunctionTemplate->setAccess(AS_public);
}
NewFD->setObjectOfFriendDecl(false);
NewFD->setAccess(AS_public);
}
// If a function is defined as defaulted or deleted, mark it as such now.
switch (D.getFunctionDefinitionKind()) {
case FDK_Declaration:
case FDK_Definition:
break;
case FDK_Defaulted:
NewFD->setDefaulted();
break;
case FDK_Deleted:
NewFD->setDeletedAsWritten();
break;
}
if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
D.isFunctionDefinition()) {
// C++ [class.mfct]p2:
// A member function may be defined (8.4) in its class definition, in
// which case it is an inline member function (7.1.2)
NewFD->setImplicitlyInline();
}
if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) &&
!CurContext->isRecord()) {
// C++ [class.static]p1:
// A data or function member of a class may be declared static
// in a class definition, in which case it is a static member of
// the class.
// Complain about the 'static' specifier if it's on an out-of-line
// member function definition.
Diag(D.getDeclSpec().getStorageClassSpecLoc(),
diag::err_static_out_of_line)
<< FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
}
// C++11 [except.spec]p15:
// A deallocation function with no exception-specification is treated
// as if it were specified with noexcept(true).
const FunctionProtoType *FPT = R->getAs<FunctionProtoType>();
if ((Name.getCXXOverloadedOperator() == OO_Delete ||
Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec()) {
FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
EPI.ExceptionSpecType = EST_BasicNoexcept;
NewFD->setType(Context.getFunctionType(FPT->getResultType(),
ArrayRef<QualType>(FPT->arg_type_begin(),
FPT->getNumArgs()),
EPI));
}
}
// Filter out previous declarations that don't match the scope.
FilterLookupForScope(Previous, DC, S, shouldConsiderLinkage(NewFD),
isExplicitSpecialization ||
isFunctionTemplateSpecialization);
// Handle GNU asm-label extension (encoded as an attribute).
if (Expr *E = (Expr*) D.getAsmLabel()) {
// The parser guarantees this is a string.
StringLiteral *SE = cast<StringLiteral>(E);
NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context,
SE->getString()));
} else if (!ExtnameUndeclaredIdentifiers.empty()) {
llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier());
if (I != ExtnameUndeclaredIdentifiers.end()) {
NewFD->addAttr(I->second);
ExtnameUndeclaredIdentifiers.erase(I);
}
}
// Copy the parameter declarations from the declarator D to the function
// declaration NewFD, if they are available. First scavenge them into Params.
SmallVector<ParmVarDecl*, 16> Params;
if (D.isFunctionDeclarator()) {
DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
// Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
// function that takes no arguments, not a function that takes a
// single void argument.
// We let through "const void" here because Sema::GetTypeForDeclarator
// already checks for that case.
if (FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 &&
FTI.ArgInfo[0].Param &&
cast<ParmVarDecl>(FTI.ArgInfo[0].Param)->getType()->isVoidType()) {
// Empty arg list, don't push any params.
checkVoidParamDecl(cast<ParmVarDecl>(FTI.ArgInfo[0].Param));
} else if (FTI.NumArgs > 0 && FTI.ArgInfo[0].Param != 0) {
for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
ParmVarDecl *Param = cast<ParmVarDecl>(FTI.ArgInfo[i].Param);
assert(Param->getDeclContext() != NewFD && "Was set before ?");
Param->setDeclContext(NewFD);
Params.push_back(Param);
if (Param->isInvalidDecl())
NewFD->setInvalidDecl();
}
}
} else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
// When we're declaring a function with a typedef, typeof, etc as in the
// following example, we'll need to synthesize (unnamed)
// parameters for use in the declaration.
//
// @code
// typedef void fn(int);
// fn f;
// @endcode
// Synthesize a parameter for each argument type.
for (FunctionProtoType::arg_type_iterator AI = FT->arg_type_begin(),
AE = FT->arg_type_end(); AI != AE; ++AI) {
ParmVarDecl *Param =
BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), *AI);
Param->setScopeInfo(0, Params.size());
Params.push_back(Param);
}
} else {
assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
"Should not need args for typedef of non-prototype fn");
}
// Finally, we know we have the right number of parameters, install them.
NewFD->setParams(Params);
// Find all anonymous symbols defined during the declaration of this function
// and add to NewFD. This lets us track decls such 'enum Y' in:
//
// void f(enum Y {AA} x) {}
//
// which would otherwise incorrectly end up in the translation unit scope.
NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope);
DeclsInPrototypeScope.clear();
if (D.getDeclSpec().isNoreturnSpecified())
NewFD->addAttr(
::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(),
Context));
// Process the non-inheritable attributes on this declaration.
ProcessDeclAttributes(S, NewFD, D,
/*NonInheritable=*/true, /*Inheritable=*/false);
// Functions returning a variably modified type violate C99 6.7.5.2p2
// because all functions have linkage.
if (!NewFD->isInvalidDecl() &&
NewFD->getResultType()->isVariablyModifiedType()) {
Diag(NewFD->getLocation(), diag::err_vm_func_decl);
NewFD->setInvalidDecl();
}
// Handle attributes.
ProcessDeclAttributes(S, NewFD, D,
/*NonInheritable=*/false, /*Inheritable=*/true);
QualType RetType = NewFD->getResultType();
const CXXRecordDecl *Ret = RetType->isRecordType() ?
RetType->getAsCXXRecordDecl() : RetType->getPointeeCXXRecordDecl();
if (!NewFD->isInvalidDecl() && !NewFD->hasAttr<WarnUnusedResultAttr>() &&
Ret && Ret->hasAttr<WarnUnusedResultAttr>()) {
const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
if (!(MD && MD->getCorrespondingMethodInClass(Ret, true))) {
NewFD->addAttr(new (Context) WarnUnusedResultAttr(SourceRange(),
Context));
}
}
if (!getLangOpts().CPlusPlus) {
// Perform semantic checking on the function declaration.
bool isExplicitSpecialization=false;
if (!NewFD->isInvalidDecl()) {
if (NewFD->isMain())
CheckMain(NewFD, D.getDeclSpec());
D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
isExplicitSpecialization));
}
// Make graceful recovery from an invalid redeclaration.
else if (!Previous.empty())
D.setRedeclaration(true);
assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
Previous.getResultKind() != LookupResult::FoundOverloaded) &&
"previous declaration set still overloaded");
} else {
// If the declarator is a template-id, translate the parser's template
// argument list into our AST format.
if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
TemplateId->NumArgs);
translateTemplateArguments(TemplateArgsPtr,
TemplateArgs);
HasExplicitTemplateArgs = true;
if (NewFD->isInvalidDecl()) {
HasExplicitTemplateArgs = false;
} else if (FunctionTemplate) {
// Function template with explicit template arguments.
Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec)
<< SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc);
HasExplicitTemplateArgs = false;
} else if (!isFunctionTemplateSpecialization &&
!D.getDeclSpec().isFriendSpecified()) {
// We have encountered something that the user meant to be a
// specialization (because it has explicitly-specified template
// arguments) but that was not introduced with a "template<>" (or had
// too few of them).
Diag(D.getIdentifierLoc(), diag::err_template_spec_needs_header)
<< SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc)
<< FixItHint::CreateInsertion(
D.getDeclSpec().getLocStart(),
"template<> ");
isFunctionTemplateSpecialization = true;
} else {
// "friend void foo<>(int);" is an implicit specialization decl.
isFunctionTemplateSpecialization = true;
}
} else if (isFriend && isFunctionTemplateSpecialization) {
// This combination is only possible in a recovery case; the user
// wrote something like:
// template <> friend void foo(int);
// which we're recovering from as if the user had written:
// friend void foo<>(int);
// Go ahead and fake up a template id.
HasExplicitTemplateArgs = true;
TemplateArgs.setLAngleLoc(D.getIdentifierLoc());
TemplateArgs.setRAngleLoc(D.getIdentifierLoc());
}
// If it's a friend (and only if it's a friend), it's possible
// that either the specialized function type or the specialized
// template is dependent, and therefore matching will fail. In
// this case, don't check the specialization yet.
bool InstantiationDependent = false;
if (isFunctionTemplateSpecialization && isFriend &&
(NewFD->getType()->isDependentType() || DC->isDependentContext() ||
TemplateSpecializationType::anyDependentTemplateArguments(
TemplateArgs.getArgumentArray(), TemplateArgs.size(),
InstantiationDependent))) {
assert(HasExplicitTemplateArgs &&
"friend function specialization without template args");
if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs,
Previous))
NewFD->setInvalidDecl();
} else if (isFunctionTemplateSpecialization) {
if (CurContext->isDependentContext() && CurContext->isRecord()
&& !isFriend) {
isDependentClassScopeExplicitSpecialization = true;
Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
diag::ext_function_specialization_in_class :
diag::err_function_specialization_in_class)
<< NewFD->getDeclName();
} else if (CheckFunctionTemplateSpecialization(NewFD,
(HasExplicitTemplateArgs ? &TemplateArgs : 0),
Previous))
NewFD->setInvalidDecl();
// C++ [dcl.stc]p1:
// A storage-class-specifier shall not be specified in an explicit
// specialization (14.7.3)
if (SC != SC_None) {
if (SC != NewFD->getTemplateSpecializationInfo()->getTemplate()->getTemplatedDecl()->getStorageClass())
Diag(NewFD->getLocation(),
diag::err_explicit_specialization_inconsistent_storage_class)
<< SC
<< FixItHint::CreateRemoval(
D.getDeclSpec().getStorageClassSpecLoc());
else
Diag(NewFD->getLocation(),
diag::ext_explicit_specialization_storage_class)
<< FixItHint::CreateRemoval(
D.getDeclSpec().getStorageClassSpecLoc());
}
} else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) {
if (CheckMemberSpecialization(NewFD, Previous))
NewFD->setInvalidDecl();
}
// Perform semantic checking on the function declaration.
if (!isDependentClassScopeExplicitSpecialization) {
if (NewFD->isInvalidDecl()) {
// If this is a class member, mark the class invalid immediately.
// This avoids some consistency errors later.
if (CXXMethodDecl* methodDecl = dyn_cast<CXXMethodDecl>(NewFD))
methodDecl->getParent()->setInvalidDecl();
} else {
if (NewFD->isMain())
CheckMain(NewFD, D.getDeclSpec());
D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
isExplicitSpecialization));
}
}
assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
Previous.getResultKind() != LookupResult::FoundOverloaded) &&
"previous declaration set still overloaded");
NamedDecl *PrincipalDecl = (FunctionTemplate
? cast<NamedDecl>(FunctionTemplate)
: NewFD);
if (isFriend && D.isRedeclaration()) {
AccessSpecifier Access = AS_public;
if (!NewFD->isInvalidDecl())
Access = NewFD->getPreviousDecl()->getAccess();
NewFD->setAccess(Access);
if (FunctionTemplate) FunctionTemplate->setAccess(Access);
PrincipalDecl->setObjectOfFriendDecl(true);
}
if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
PrincipalDecl->setNonMemberOperator();
// If we have a function template, check the template parameter
// list. This will check and merge default template arguments.
if (FunctionTemplate) {
FunctionTemplateDecl *PrevTemplate =
FunctionTemplate->getPreviousDecl();
CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
PrevTemplate ? PrevTemplate->getTemplateParameters() : 0,
D.getDeclSpec().isFriendSpecified()
? (D.isFunctionDefinition()
? TPC_FriendFunctionTemplateDefinition
: TPC_FriendFunctionTemplate)
: (D.getCXXScopeSpec().isSet() &&
DC && DC->isRecord() &&
DC->isDependentContext())
? TPC_ClassTemplateMember
: TPC_FunctionTemplate);
}
if (NewFD->isInvalidDecl()) {
// Ignore all the rest of this.
} else if (!D.isRedeclaration()) {
struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
AddToScope };
// Fake up an access specifier if it's supposed to be a class member.
if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
NewFD->setAccess(AS_public);
// Qualified decls generally require a previous declaration.
if (D.getCXXScopeSpec().isSet()) {
// ...with the major exception of templated-scope or
// dependent-scope friend declarations.
// TODO: we currently also suppress this check in dependent
// contexts because (1) the parameter depth will be off when
// matching friend templates and (2) we might actually be
// selecting a friend based on a dependent factor. But there
// are situations where these conditions don't apply and we
// can actually do this check immediately.
if (isFriend &&
(TemplateParamLists.size() ||
D.getCXXScopeSpec().getScopeRep()->isDependent() ||
CurContext->isDependentContext())) {
// ignore these
} else {
// The user tried to provide an out-of-line definition for a
// function that is a member of a class or namespace, but there
// was no such member function declared (C++ [class.mfct]p2,
// C++ [namespace.memdef]p2). For example:
//
// class X {
// void f() const;
// };
//
// void X::f() { } // ill-formed
//
// Complain about this problem, and attempt to suggest close
// matches (e.g., those that differ only in cv-qualifiers and
// whether the parameter types are references).
if (NamedDecl *Result = DiagnoseInvalidRedeclaration(*this, Previous,
NewFD,
ExtraArgs)) {
AddToScope = ExtraArgs.AddToScope;
return Result;
}
}
// Unqualified local friend declarations are required to resolve
// to something.
} else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) {
if (NamedDecl *Result = DiagnoseInvalidRedeclaration(*this, Previous,
NewFD,
ExtraArgs)) {
AddToScope = ExtraArgs.AddToScope;
return Result;
}
}
} else if (!D.isFunctionDefinition() && D.getCXXScopeSpec().isSet() &&
!isFriend && !isFunctionTemplateSpecialization &&
!isExplicitSpecialization) {
// An out-of-line member function declaration must also be a
// definition (C++ [dcl.meaning]p1).
// Note that this is not the case for explicit specializations of
// function templates or member functions of class templates, per
// C++ [temp.expl.spec]p2. We also allow these declarations as an
// extension for compatibility with old SWIG code which likes to
// generate them.
Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
<< D.getCXXScopeSpec().getRange();
}
}
ProcessPragmaWeak(S, NewFD);
checkAttributesAfterMerging(*this, *NewFD);
AddKnownFunctionAttributes(NewFD);
if (NewFD->hasAttr<OverloadableAttr>() &&
!NewFD->getType()->getAs<FunctionProtoType>()) {
Diag(NewFD->getLocation(),
diag::err_attribute_overloadable_no_prototype)
<< NewFD;
// Turn this into a variadic function with no parameters.
const FunctionType *FT = NewFD->getType()->getAs<FunctionType>();
FunctionProtoType::ExtProtoInfo EPI;
EPI.Variadic = true;
EPI.ExtInfo = FT->getExtInfo();
QualType R = Context.getFunctionType(FT->getResultType(), None, EPI);
NewFD->setType(R);
}
// If there's a #pragma GCC visibility in scope, and this isn't a class
// member, set the visibility of this function.
if (!DC->isRecord() && NewFD->hasExternalLinkage())
AddPushedVisibilityAttribute(NewFD);
// If there's a #pragma clang arc_cf_code_audited in scope, consider
// marking the function.
AddCFAuditedAttribute(NewFD);
// If this is a locally-scoped extern C function, update the
// map of such names.
if (CurContext->isFunctionOrMethod() && NewFD->isExternC()
&& !NewFD->isInvalidDecl())
RegisterLocallyScopedExternCDecl(NewFD, Previous, S);
// Set this FunctionDecl's range up to the right paren.
NewFD->setRangeEnd(D.getSourceRange().getEnd());
if (getLangOpts().CPlusPlus) {
if (FunctionTemplate) {
if (NewFD->isInvalidDecl())
FunctionTemplate->setInvalidDecl();
return FunctionTemplate;
}
}
if (NewFD->hasAttr<OpenCLKernelAttr>()) {
// OpenCL v1.2 s6.8 static is invalid for kernel functions.
if ((getLangOpts().OpenCLVersion >= 120)
&& (SC == SC_Static)) {
Diag(D.getIdentifierLoc(), diag::err_static_kernel);
D.setInvalidType();
}
// OpenCL v1.2, s6.9 -- Kernels can only have return type void.
if (!NewFD->getResultType()->isVoidType()) {
Diag(D.getIdentifierLoc(),
diag::err_expected_kernel_void_return_type);
D.setInvalidType();
}
for (FunctionDecl::param_iterator PI = NewFD->param_begin(),
PE = NewFD->param_end(); PI != PE; ++PI) {
ParmVarDecl *Param = *PI;
QualType PT = Param->getType();
// OpenCL v1.2 s6.9.a:
// A kernel function argument cannot be declared as a
// pointer to a pointer type.
if (PT->isPointerType() && PT->getPointeeType()->isPointerType()) {
Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_arg);
D.setInvalidType();
}
// OpenCL v1.2 s6.8 n:
// A kernel function argument cannot be declared
// of event_t type.
if (PT->isEventT()) {
Diag(Param->getLocation(), diag::err_event_t_kernel_arg);
D.setInvalidType();
}
}
}
MarkUnusedFileScopedDecl(NewFD);
if (getLangOpts().CUDA)
if (IdentifierInfo *II = NewFD->getIdentifier())
if (!NewFD->isInvalidDecl() &&
NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
if (II->isStr("cudaConfigureCall")) {
if (!R->getAs<FunctionType>()->getResultType()->isScalarType())
Diag(NewFD->getLocation(), diag::err_config_scalar_return);
Context.setcudaConfigureCallDecl(NewFD);
}
}
// Here we have an function template explicit specialization at class scope.
// The actually specialization will be postponed to template instatiation
// time via the ClassScopeFunctionSpecializationDecl node.
if (isDependentClassScopeExplicitSpecialization) {
ClassScopeFunctionSpecializationDecl *NewSpec =
ClassScopeFunctionSpecializationDecl::Create(
Context, CurContext, SourceLocation(),
cast<CXXMethodDecl>(NewFD),
HasExplicitTemplateArgs, TemplateArgs);
CurContext->addDecl(NewSpec);
AddToScope = false;
}
return NewFD;
}
/// \brief Perform semantic checking of a new function declaration.
///
/// Performs semantic analysis of the new function declaration
/// NewFD. This routine performs all semantic checking that does not
/// require the actual declarator involved in the declaration, and is
/// used both for the declaration of functions as they are parsed
/// (called via ActOnDeclarator) and for the declaration of functions
/// that have been instantiated via C++ template instantiation (called
/// via InstantiateDecl).
///
/// \param IsExplicitSpecialization whether this new function declaration is
/// an explicit specialization of the previous declaration.
///
/// This sets NewFD->isInvalidDecl() to true if there was an error.
///
/// \returns true if the function declaration is a redeclaration.
bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
LookupResult &Previous,
bool IsExplicitSpecialization) {
assert(!NewFD->getResultType()->isVariablyModifiedType()
&& "Variably modified return types are not handled here");
// Check for a previous declaration of this name.
if (Previous.empty() && mayConflictWithNonVisibleExternC(NewFD)) {
// Since we did not find anything by this name, look for a non-visible
// extern "C" declaration with the same name.
llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
= findLocallyScopedExternCDecl(NewFD->getDeclName());
if (Pos != LocallyScopedExternCDecls.end())
Previous.addDecl(Pos->second);
}
// Filter out any non-conflicting previous declarations.
filterNonConflictingPreviousDecls(Context, NewFD, Previous);
bool Redeclaration = false;
NamedDecl *OldDecl = 0;
// Merge or overload the declaration with an existing declaration of
// the same name, if appropriate.
if (!Previous.empty()) {
// Determine whether NewFD is an overload of PrevDecl or
// a declaration that requires merging. If it's an overload,
// there's no more work to do here; we'll just add the new
// function to the scope.
if (!AllowOverloadingOfFunction(Previous, Context)) {
NamedDecl *Candidate = Previous.getFoundDecl();
if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
Redeclaration = true;
OldDecl = Candidate;
}
} else {
switch (CheckOverload(S, NewFD, Previous, OldDecl,
/*NewIsUsingDecl*/ false)) {
case Ovl_Match:
Redeclaration = true;
break;
case Ovl_NonFunction:
Redeclaration = true;
break;
case Ovl_Overload:
Redeclaration = false;
break;
}
if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
// If a function name is overloadable in C, then every function
// with that name must be marked "overloadable".
Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
<< Redeclaration << NewFD;
NamedDecl *OverloadedDecl = 0;
if (Redeclaration)
OverloadedDecl = OldDecl;
else if (!Previous.empty())
OverloadedDecl = Previous.getRepresentativeDecl();
if (OverloadedDecl)
Diag(OverloadedDecl->getLocation(),
diag::note_attribute_overloadable_prev_overload);
NewFD->addAttr(::new (Context) OverloadableAttr(SourceLocation(),
Context));
}
}
}
// C++11 [dcl.constexpr]p8:
// A constexpr specifier for a non-static member function that is not
// a constructor declares that member function to be const.
//
// This needs to be delayed until we know whether this is an out-of-line
// definition of a static member function.
//
// This rule is not present in C++1y, so we produce a backwards
// compatibility warning whenever it happens in C++11.
CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
if (!getLangOpts().CPlusPlus1y && MD && MD->isConstexpr() &&
!MD->isStatic() && !isa<CXXConstructorDecl>(MD) &&
(MD->getTypeQualifiers() & Qualifiers::Const) == 0) {
CXXMethodDecl *OldMD = dyn_cast_or_null<CXXMethodDecl>(OldDecl);
if (FunctionTemplateDecl *OldTD =
dyn_cast_or_null<FunctionTemplateDecl>(OldDecl))
OldMD = dyn_cast<CXXMethodDecl>(OldTD->getTemplatedDecl());
if (!OldMD || !OldMD->isStatic()) {
const FunctionProtoType *FPT =
MD->getType()->castAs<FunctionProtoType>();
FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
EPI.TypeQuals |= Qualifiers::Const;
MD->setType(Context.getFunctionType(FPT->getResultType(),
ArrayRef<QualType>(FPT->arg_type_begin(),
FPT->getNumArgs()),
EPI));
// Warn that we did this, if we're not performing template instantiation.
// In that case, we'll have warned already when the template was defined.
if (ActiveTemplateInstantiations.empty()) {
SourceLocation AddConstLoc;
if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc()
.IgnoreParens().getAs<FunctionTypeLoc>())
AddConstLoc = PP.getLocForEndOfToken(FTL.getRParenLoc());
Diag(MD->getLocation(), diag::warn_cxx1y_compat_constexpr_not_const)
<< FixItHint::CreateInsertion(AddConstLoc, " const");
}
}
}
if (Redeclaration) {
// NewFD and OldDecl represent declarations that need to be
// merged.
if (MergeFunctionDecl(NewFD, OldDecl, S)) {
NewFD->setInvalidDecl();
return Redeclaration;
}
Previous.clear();
Previous.addDecl(OldDecl);
if (FunctionTemplateDecl *OldTemplateDecl
= dyn_cast<FunctionTemplateDecl>(OldDecl)) {
NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
FunctionTemplateDecl *NewTemplateDecl
= NewFD->getDescribedFunctionTemplate();
assert(NewTemplateDecl && "Template/non-template mismatch");
if (CXXMethodDecl *Method
= dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
Method->setAccess(OldTemplateDecl->getAccess());
NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
}
// If this is an explicit specialization of a member that is a function
// template, mark it as a member specialization.
if (IsExplicitSpecialization &&
NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
NewTemplateDecl->setMemberSpecialization();
assert(OldTemplateDecl->isMemberSpecialization());
}
} else {
// This needs to happen first so that 'inline' propagates.
NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
if (isa<CXXMethodDecl>(NewFD)) {
// A valid redeclaration of a C++ method must be out-of-line,
// but (unfortunately) it's not necessarily a definition
// because of templates, which means that the previous
// declaration is not necessarily from the class definition.
// For just setting the access, that doesn't matter.
CXXMethodDecl *oldMethod = cast<CXXMethodDecl>(OldDecl);
NewFD->setAccess(oldMethod->getAccess());
// Update the key-function state if necessary for this ABI.
if (NewFD->isInlined() &&
!Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
// setNonKeyFunction needs to work with the original
// declaration from the class definition, and isVirtual() is
// just faster in that case, so map back to that now.
oldMethod = cast<CXXMethodDecl>(oldMethod->getFirstDeclaration());
if (oldMethod->isVirtual()) {
Context.setNonKeyFunction(oldMethod);
}
}
}
}
}
// Semantic checking for this function declaration (in isolation).
if (getLangOpts().CPlusPlus) {
// C++-specific checks.
if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
CheckConstructor(Constructor);
} else if (CXXDestructorDecl *Destructor =
dyn_cast<CXXDestructorDecl>(NewFD)) {
CXXRecordDecl *Record = Destructor->getParent();
QualType ClassType = Context.getTypeDeclType(Record);
// FIXME: Shouldn't we be able to perform this check even when the class
// type is dependent? Both gcc and edg can handle that.
if (!ClassType->isDependentType()) {
DeclarationName Name
= Context.DeclarationNames.getCXXDestructorName(
Context.getCanonicalType(ClassType));
if (NewFD->getDeclName() != Name) {
Diag(NewFD->getLocation(), diag::err_destructor_name);
NewFD->setInvalidDecl();
return Redeclaration;
}
}
} else if (CXXConversionDecl *Conversion
= dyn_cast<CXXConversionDecl>(NewFD)) {
ActOnConversionDeclarator(Conversion);
}
// Find any virtual functions that this function overrides.
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
if (!Method->isFunctionTemplateSpecialization() &&
!Method->getDescribedFunctionTemplate() &&
Method->isCanonicalDecl()) {
if (AddOverriddenMethods(Method->getParent(), Method)) {
// If the function was marked as "static", we have a problem.
if (NewFD->getStorageClass() == SC_Static) {
ReportOverrides(*this, diag::err_static_overrides_virtual, Method);
}
}
}
if (Method->isStatic())
checkThisInStaticMemberFunctionType(Method);
}
// Extra checking for C++ overloaded operators (C++ [over.oper]).
if (NewFD->isOverloadedOperator() &&
CheckOverloadedOperatorDeclaration(NewFD)) {
NewFD->setInvalidDecl();
return Redeclaration;
}
// Extra checking for C++0x literal operators (C++0x [over.literal]).
if (NewFD->getLiteralIdentifier() &&
CheckLiteralOperatorDeclaration(NewFD)) {
NewFD->setInvalidDecl();
return Redeclaration;
}
// In C++, check default arguments now that we have merged decls. Unless
// the lexical context is the class, because in this case this is done
// during delayed parsing anyway.
if (!CurContext->isRecord())
CheckCXXDefaultArguments(NewFD);
// If this function declares a builtin function, check the type of this
// declaration against the expected type for the builtin.
if (unsigned BuiltinID = NewFD->getBuiltinID()) {
ASTContext::GetBuiltinTypeError Error;
LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier());
QualType T = Context.GetBuiltinType(BuiltinID, Error);
if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) {
// The type of this function differs from the type of the builtin,
// so forget about the builtin entirely.
Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents);
}
}
// If this function is declared as being extern "C", then check to see if
// the function returns a UDT (class, struct, or union type) that is not C
// compatible, and if it does, warn the user.
// But, issue any diagnostic on the first declaration only.
if (NewFD->isExternC() && Previous.empty()) {
QualType R = NewFD->getResultType();
if (R->isIncompleteType() && !R->isVoidType())
Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
<< NewFD << R;
else if (!R.isPODType(Context) && !R->isVoidType() &&
!R->isObjCObjectPointerType())
Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
}
}
return Redeclaration;
}
static SourceRange getResultSourceRange(const FunctionDecl *FD) {
const TypeSourceInfo *TSI = FD->getTypeSourceInfo();
if (!TSI)
return SourceRange();
TypeLoc TL = TSI->getTypeLoc();
FunctionTypeLoc FunctionTL = TL.getAs<FunctionTypeLoc>();
if (!FunctionTL)
return SourceRange();
TypeLoc ResultTL = FunctionTL.getResultLoc();
if (ResultTL.getUnqualifiedLoc().getAs<BuiltinTypeLoc>())
return ResultTL.getSourceRange();
return SourceRange();
}
void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) {
// C++11 [basic.start.main]p3: A program that declares main to be inline,
// static or constexpr is ill-formed.
// C11 6.7.4p4: In a hosted environment, no function specifier(s) shall
// appear in a declaration of main.
// static main is not an error under C99, but we should warn about it.
// We accept _Noreturn main as an extension.
if (FD->getStorageClass() == SC_Static)
Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus
? diag::err_static_main : diag::warn_static_main)
<< FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
if (FD->isInlineSpecified())
Diag(DS.getInlineSpecLoc(), diag::err_inline_main)
<< FixItHint::CreateRemoval(DS.getInlineSpecLoc());
if (DS.isNoreturnSpecified()) {
SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc();
SourceRange NoreturnRange(NoreturnLoc,
PP.getLocForEndOfToken(NoreturnLoc));
Diag(NoreturnLoc, diag::ext_noreturn_main);
Diag(NoreturnLoc, diag::note_main_remove_noreturn)
<< FixItHint::CreateRemoval(NoreturnRange);
}
if (FD->isConstexpr()) {
Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
<< FixItHint::CreateRemoval(DS.getConstexprSpecLoc());
FD->setConstexpr(false);
}
QualType T = FD->getType();
assert(T->isFunctionType() && "function decl is not of function type");
const FunctionType* FT = T->castAs<FunctionType>();
// All the standards say that main() should should return 'int'.
if (Context.hasSameUnqualifiedType(FT->getResultType(), Context.IntTy)) {
// In C and C++, main magically returns 0 if you fall off the end;
// set the flag which tells us that.
// This is C++ [basic.start.main]p5 and C99 5.1.2.2.3.
FD->setHasImplicitReturnZero(true);
// In C with GNU extensions we allow main() to have non-integer return
// type, but we should warn about the extension, and we disable the
// implicit-return-zero rule.
} else if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) {
Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint);
SourceRange ResultRange = getResultSourceRange(FD);
if (ResultRange.isValid())
Diag(ResultRange.getBegin(), diag::note_main_change_return_type)
<< FixItHint::CreateReplacement(ResultRange, "int");
// Otherwise, this is just a flat-out error.
} else {
SourceRange ResultRange = getResultSourceRange(FD);
if (ResultRange.isValid())
Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint)
<< FixItHint::CreateReplacement(ResultRange, "int");
else
Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint);
FD->setInvalidDecl(true);
}
// Treat protoless main() as nullary.
if (isa<FunctionNoProtoType>(FT)) return;
const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
unsigned nparams = FTP->getNumArgs();
assert(FD->getNumParams() == nparams);
bool HasExtraParameters = (nparams > 3);
// Darwin passes an undocumented fourth argument of type char**. If
// other platforms start sprouting these, the logic below will start
// getting shifty.
if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin())
HasExtraParameters = false;
if (HasExtraParameters) {
Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
FD->setInvalidDecl(true);
nparams = 3;
}
// FIXME: a lot of the following diagnostics would be improved
// if we had some location information about types.
QualType CharPP =
Context.getPointerType(Context.getPointerType(Context.CharTy));
QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
for (unsigned i = 0; i < nparams; ++i) {
QualType AT = FTP->getArgType(i);
bool mismatch = true;
if (Context.hasSameUnqualifiedType(AT, Expected[i]))
mismatch = false;
else if (Expected[i] == CharPP) {
// As an extension, the following forms are okay:
// char const **
// char const * const *
// char * const *
QualifierCollector qs;
const PointerType* PT;
if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
(PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0),
Context.CharTy)) {
qs.removeConst();
mismatch = !qs.empty();
}
}
if (mismatch) {
Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
// TODO: suggest replacing given type with expected type
FD->setInvalidDecl(true);
}
}
if (nparams == 1 && !FD->isInvalidDecl()) {
Diag(FD->getLocation(), diag::warn_main_one_arg);
}
if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
Diag(FD->getLocation(), diag::err_main_template_decl);
FD->setInvalidDecl();
}
}
bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
// FIXME: Need strict checking. In C89, we need to check for
// any assignment, increment, decrement, function-calls, or
// commas outside of a sizeof. In C99, it's the same list,
// except that the aforementioned are allowed in unevaluated
// expressions. Everything else falls under the
// "may accept other forms of constant expressions" exception.
// (We never end up here for C++, so the constant expression
// rules there don't matter.)
if (Init->isConstantInitializer(Context, false))
return false;
Diag(Init->getExprLoc(), diag::err_init_element_not_constant)
<< Init->getSourceRange();
return true;
}
namespace {
// Visits an initialization expression to see if OrigDecl is evaluated in
// its own initialization and throws a warning if it does.
class SelfReferenceChecker
: public EvaluatedExprVisitor<SelfReferenceChecker> {
Sema &S;
Decl *OrigDecl;
bool isRecordType;
bool isPODType;
bool isReferenceType;
public:
typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited;
SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context),
S(S), OrigDecl(OrigDecl) {
isPODType = false;
isRecordType = false;
isReferenceType = false;
if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
isPODType = VD->getType().isPODType(S.Context);
isRecordType = VD->getType()->isRecordType();
isReferenceType = VD->getType()->isReferenceType();
}
}
// For most expressions, the cast is directly above the DeclRefExpr.
// For conditional operators, the cast can be outside the conditional
// operator if both expressions are DeclRefExpr's.
void HandleValue(Expr *E) {
if (isReferenceType)
return;
E = E->IgnoreParenImpCasts();
if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
HandleDeclRefExpr(DRE);
return;
}
if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
HandleValue(CO->getTrueExpr());
HandleValue(CO->getFalseExpr());
return;
}
if (isa<MemberExpr>(E)) {
Expr *Base = E->IgnoreParenImpCasts();
while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
// Check for static member variables and don't warn on them.
if (!isa<FieldDecl>(ME->getMemberDecl()))
return;
Base = ME->getBase()->IgnoreParenImpCasts();
}
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base))
HandleDeclRefExpr(DRE);
return;
}
}
// Reference types are handled here since all uses of references are
// bad, not just r-value uses.
void VisitDeclRefExpr(DeclRefExpr *E) {
if (isReferenceType)
HandleDeclRefExpr(E);
}
void VisitImplicitCastExpr(ImplicitCastExpr *E) {
if (E->getCastKind() == CK_LValueToRValue ||
(isRecordType && E->getCastKind() == CK_NoOp))
HandleValue(E->getSubExpr());
Inherited::VisitImplicitCastExpr(E);
}
void VisitMemberExpr(MemberExpr *E) {
// Don't warn on arrays since they can be treated as pointers.
if (E->getType()->canDecayToPointerType()) return;
// Warn when a non-static method call is followed by non-static member
// field accesses, which is followed by a DeclRefExpr.
CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl());
bool Warn = (MD && !MD->isStatic());
Expr *Base = E->getBase()->IgnoreParenImpCasts();
while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
if (!isa<FieldDecl>(ME->getMemberDecl()))
Warn = false;
Base = ME->getBase()->IgnoreParenImpCasts();
}
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
if (Warn)
HandleDeclRefExpr(DRE);
return;
}
// The base of a MemberExpr is not a MemberExpr or a DeclRefExpr.
// Visit that expression.
Visit(Base);
}
void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
if (E->getNumArgs() > 0)
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->getArg(0)))
HandleDeclRefExpr(DRE);
Inherited::VisitCXXOperatorCallExpr(E);
}
void VisitUnaryOperator(UnaryOperator *E) {
// For POD record types, addresses of its own members are well-defined.
if (E->getOpcode() == UO_AddrOf && isRecordType &&
isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) {
if (!isPODType)
HandleValue(E->getSubExpr());
return;
}
Inherited::VisitUnaryOperator(E);
}
void VisitObjCMessageExpr(ObjCMessageExpr *E) { return; }
void HandleDeclRefExpr(DeclRefExpr *DRE) {
Decl* ReferenceDecl = DRE->getDecl();
if (OrigDecl != ReferenceDecl) return;
unsigned diag;
if (isReferenceType) {
diag = diag::warn_uninit_self_reference_in_reference_init;
} else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
diag = diag::warn_static_self_reference_in_init;
} else {
diag = diag::warn_uninit_self_reference_in_init;
}
S.DiagRuntimeBehavior(DRE->getLocStart(), DRE,
S.PDiag(diag)
<< DRE->getNameInfo().getName()
<< OrigDecl->getLocation()
<< DRE->getSourceRange());
}
};
/// CheckSelfReference - Warns if OrigDecl is used in expression E.
static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E,
bool DirectInit) {
// Parameters arguments are occassionially constructed with itself,
// for instance, in recursive functions. Skip them.
if (isa<ParmVarDecl>(OrigDecl))
return;
E = E->IgnoreParens();
// Skip checking T a = a where T is not a record or reference type.
// Doing so is a way to silence uninitialized warnings.
if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType())
if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
if (ICE->getCastKind() == CK_LValueToRValue)
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
if (DRE->getDecl() == OrigDecl)
return;
SelfReferenceChecker(S, OrigDecl).Visit(E);
}
}
/// AddInitializerToDecl - Adds the initializer Init to the
/// declaration dcl. If DirectInit is true, this is C++ direct
/// initialization rather than copy initialization.
void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init,
bool DirectInit, bool TypeMayContainAuto) {
// If there is no declaration, there was an error parsing it. Just ignore
// the initializer.
if (RealDecl == 0 || RealDecl->isInvalidDecl())
return;
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
// With declarators parsed the way they are, the parser cannot
// distinguish between a normal initializer and a pure-specifier.
// Thus this grotesque test.
IntegerLiteral *IL;
if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 &&
Context.getCanonicalType(IL->getType()) == Context.IntTy)
CheckPureMethod(Method, Init->getSourceRange());
else {
Diag(Method->getLocation(), diag::err_member_function_initialization)
<< Method->getDeclName() << Init->getSourceRange();
Method->setInvalidDecl();
}
return;
}
VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
if (!VDecl) {
assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here");
Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
RealDecl->setInvalidDecl();
return;
}
ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
// C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) {
Expr *DeduceInit = Init;
// Initializer could be a C++ direct-initializer. Deduction only works if it
// contains exactly one expression.
if (CXXDirectInit) {
if (CXXDirectInit->getNumExprs() == 0) {
// It isn't possible to write this directly, but it is possible to
// end up in this situation with "auto x(some_pack...);"
Diag(CXXDirectInit->getLocStart(),
diag::err_auto_var_init_no_expression)
<< VDecl->getDeclName() << VDecl->getType()
<< VDecl->getSourceRange();
RealDecl->setInvalidDecl();
return;
} else if (CXXDirectInit->getNumExprs() > 1) {
Diag(CXXDirectInit->getExpr(1)->getLocStart(),
diag::err_auto_var_init_multiple_expressions)
<< VDecl->getDeclName() << VDecl->getType()
<< VDecl->getSourceRange();
RealDecl->setInvalidDecl();
return;
} else {
DeduceInit = CXXDirectInit->getExpr(0);
}
}
// Expressions default to 'id' when we're in a debugger.
bool DefaultedToAuto = false;
if (getLangOpts().DebuggerCastResultToId &&
Init->getType() == Context.UnknownAnyTy) {
ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
if (Result.isInvalid()) {
VDecl->setInvalidDecl();
return;
}
Init = Result.take();
DefaultedToAuto = true;
}
QualType DeducedType;
if (DeduceAutoType(VDecl->getTypeSourceInfo(), DeduceInit, DeducedType) ==
DAR_Failed)
DiagnoseAutoDeductionFailure(VDecl, DeduceInit);
if (DeducedType.isNull()) {
RealDecl->setInvalidDecl();
return;
}
VDecl->setType(DeducedType);
assert(VDecl->isLinkageValid());
// In ARC, infer lifetime.
if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
VDecl->setInvalidDecl();
// Warn if we deduced 'id'. 'auto' usually implies type-safety, but using
// 'id' instead of a specific object type prevents most of our usual checks.
// We only want to warn outside of template instantiations, though:
// inside a template, the 'id' could have come from a parameter.
if (ActiveTemplateInstantiations.empty() && !DefaultedToAuto &&
DeducedType->isObjCIdType()) {
SourceLocation Loc =
VDecl->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
Diag(Loc, diag::warn_auto_var_is_id)
<< VDecl->getDeclName() << DeduceInit->getSourceRange();
}
// If this is a redeclaration, check that the type we just deduced matches
// the previously declared type.
if (VarDecl *Old = VDecl->getPreviousDecl())
MergeVarDeclTypes(VDecl, Old, /*OldWasHidden*/ false);
// Check the deduced type is valid for a variable declaration.
CheckVariableDeclarationType(VDecl);
if (VDecl->isInvalidDecl())
return;
}
if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) {
// C99 6.7.8p5. C++ has no such restriction, but that is a defect.
Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
VDecl->setInvalidDecl();
return;
}
if (!VDecl->getType()->isDependentType()) {
// A definition must end up with a complete type, which means it must be
// complete with the restriction that an array type might be completed by
// the initializer; note that later code assumes this restriction.
QualType BaseDeclType = VDecl->getType();
if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
BaseDeclType = Array->getElementType();
if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
diag::err_typecheck_decl_incomplete_type)) {
RealDecl->setInvalidDecl();
return;
}
// The variable can not have an abstract class type.
if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
diag::err_abstract_type_in_decl,
AbstractVariableType))
VDecl->setInvalidDecl();
}
const VarDecl *Def;
if ((Def = VDecl->getDefinition()) && Def != VDecl) {
Diag(VDecl->getLocation(), diag::err_redefinition)
<< VDecl->getDeclName();
Diag(Def->getLocation(), diag::note_previous_definition);
VDecl->setInvalidDecl();
return;
}
const VarDecl* PrevInit = 0;
if (getLangOpts().CPlusPlus) {
// C++ [class.static.data]p4
// If a static data member is of const integral or const
// enumeration type, its declaration in the class definition can
// specify a constant-initializer which shall be an integral
// constant expression (5.19). In that case, the member can appear
// in integral constant expressions. The member shall still be
// defined in a namespace scope if it is used in the program and the
// namespace scope definition shall not contain an initializer.
//
// We already performed a redefinition check above, but for static
// data members we also need to check whether there was an in-class
// declaration with an initializer.
if (VDecl->isStaticDataMember() && VDecl->getAnyInitializer(PrevInit)) {
Diag(VDecl->getLocation(), diag::err_redefinition)
<< VDecl->getDeclName();
Diag(PrevInit->getLocation(), diag::note_previous_definition);
return;
}
if (VDecl->hasLocalStorage())
getCurFunction()->setHasBranchProtectedScope();
if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) {
VDecl->setInvalidDecl();
return;
}
}
// OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside
// a kernel function cannot be initialized."
if (VDecl->getStorageClass() == SC_OpenCLWorkGroupLocal) {
Diag(VDecl->getLocation(), diag::err_local_cant_init);
VDecl->setInvalidDecl();
return;
}
// Get the decls type and save a reference for later, since
// CheckInitializerTypes may change it.
QualType DclT = VDecl->getType(), SavT = DclT;
// Expressions default to 'id' when we're in a debugger
// and we are assigning it to a variable of Objective-C pointer type.
if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() &&
Init->getType() == Context.UnknownAnyTy) {
ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
if (Result.isInvalid()) {
VDecl->setInvalidDecl();
return;
}
Init = Result.take();
}
// Perform the initialization.
if (!VDecl->isInvalidDecl()) {
InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
InitializationKind Kind
= DirectInit ?
CXXDirectInit ? InitializationKind::CreateDirect(VDecl->getLocation(),
Init->getLocStart(),
Init->getLocEnd())
: InitializationKind::CreateDirectList(
VDecl->getLocation())
: InitializationKind::CreateCopy(VDecl->getLocation(),
Init->getLocStart());
MultiExprArg Args = Init;
if (CXXDirectInit)
Args = MultiExprArg(CXXDirectInit->getExprs(),
CXXDirectInit->getNumExprs());
InitializationSequence InitSeq(*this, Entity, Kind, Args);
ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
if (Result.isInvalid()) {
VDecl->setInvalidDecl();
return;
}
Init = Result.takeAs<Expr>();
}
// Check for self-references within variable initializers.
// Variables declared within a function/method body (except for references)
// are handled by a dataflow analysis.
if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() ||
VDecl->getType()->isReferenceType()) {
CheckSelfReference(*this, RealDecl, Init, DirectInit);
}
// If the type changed, it means we had an incomplete type that was
// completed by the initializer. For example:
// int ary[] = { 1, 3, 5 };
// "ary" transitions from an IncompleteArrayType to a ConstantArrayType.
if (!VDecl->isInvalidDecl() && (DclT != SavT))
VDecl->setType(DclT);
if (!VDecl->isInvalidDecl()) {
checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init);
if (VDecl->hasAttr<BlocksAttr>())
checkRetainCycles(VDecl, Init);
// It is safe to assign a weak reference into a strong variable.
// Although this code can still have problems:
// id x = self.weakProp;
// id y = self.weakProp;
// we do not warn to warn spuriously when 'x' and 'y' are on separate
// paths through the function. This should be revisited if
// -Wrepeated-use-of-weak is made flow-sensitive.
if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong) {
DiagnosticsEngine::Level Level =
Diags.getDiagnosticLevel(diag::warn_arc_repeated_use_of_weak,
Init->getLocStart());
if (Level != DiagnosticsEngine::Ignored)
getCurFunction()->markSafeWeakUse(Init);
}
}
// The initialization is usually a full-expression.
//
// FIXME: If this is a braced initialization of an aggregate, it is not
// an expression, and each individual field initializer is a separate
// full-expression. For instance, in:
//
// struct Temp { ~Temp(); };
// struct S { S(Temp); };
// struct T { S a, b; } t = { Temp(), Temp() }
//
// we should destroy the first Temp before constructing the second.
ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(),
false,
VDecl->isConstexpr());
if (Result.isInvalid()) {
VDecl->setInvalidDecl();
return;
}
Init = Result.take();
// Attach the initializer to the decl.
VDecl->setInit(Init);
if (VDecl->isLocalVarDecl()) {
// C99 6.7.8p4: All the expressions in an initializer for an object that has
// static storage duration shall be constant expressions or string literals.
// C++ does not have this restriction.
if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl() &&
VDecl->getStorageClass() == SC_Static)
CheckForConstantInitializer(Init, DclT);
} else if (VDecl->isStaticDataMember() &&
VDecl->getLexicalDeclContext()->isRecord()) {
// This is an in-class initialization for a static data member, e.g.,
//
// struct S {
// static const int value = 17;
// };
// C++ [class.mem]p4:
// A member-declarator can contain a constant-initializer only
// if it declares a static member (9.4) of const integral or
// const enumeration type, see 9.4.2.
//
// C++11 [class.static.data]p3:
// If a non-volatile const static data member is of integral or
// enumeration type, its declaration in the class definition can
// specify a brace-or-equal-initializer in which every initalizer-clause
// that is an assignment-expression is a constant expression. A static
// data member of literal type can be declared in the class definition
// with the constexpr specifier; if so, its declaration shall specify a
// brace-or-equal-initializer in which every initializer-clause that is
// an assignment-expression is a constant expression.
// Do nothing on dependent types.
if (DclT->isDependentType()) {
// Allow any 'static constexpr' members, whether or not they are of literal
// type. We separately check that every constexpr variable is of literal
// type.
} else if (VDecl->isConstexpr()) {
// Require constness.
} else if (!DclT.isConstQualified()) {
Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
<< Init->getSourceRange();
VDecl->setInvalidDecl();
// We allow integer constant expressions in all cases.
} else if (DclT->isIntegralOrEnumerationType()) {
// Check whether the expression is a constant expression.
SourceLocation Loc;
if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified())
// In C++11, a non-constexpr const static data member with an
// in-class initializer cannot be volatile.
Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile);
else if (Init->isValueDependent())
; // Nothing to check.
else if (Init->isIntegerConstantExpr(Context, &Loc))
; // Ok, it's an ICE!
else if (Init->isEvaluatable(Context)) {
// If we can constant fold the initializer through heroics, accept it,
// but report this as a use of an extension for -pedantic.
Diag(Loc, diag::ext_in_class_initializer_non_constant)
<< Init->getSourceRange();
} else {
// Otherwise, this is some crazy unknown case. Report the issue at the
// location provided by the isIntegerConstantExpr failed check.
Diag(Loc, diag::err_in_class_initializer_non_constant)
<< Init->getSourceRange();
VDecl->setInvalidDecl();
}
// We allow foldable floating-point constants as an extension.
} else if (DclT->isFloatingType()) { // also permits complex, which is ok
// In C++98, this is a GNU extension. In C++11, it is not, but we support
// it anyway and provide a fixit to add the 'constexpr'.
if (getLangOpts().CPlusPlus11) {
Diag(VDecl->getLocation(),
diag::ext_in_class_initializer_float_type_cxx11)
<< DclT << Init->getSourceRange();
Diag(VDecl->getLocStart(),
diag::note_in_class_initializer_float_type_cxx11)
<< FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
} else {
Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type)
<< DclT << Init->getSourceRange();
if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) {
Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
<< Init->getSourceRange();
VDecl->setInvalidDecl();
}
}
// Suggest adding 'constexpr' in C++11 for literal types.
} else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) {
Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type)
<< DclT << Init->getSourceRange()
<< FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
VDecl->setConstexpr(true);
} else {
Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
<< DclT << Init->getSourceRange();
VDecl->setInvalidDecl();
}
} else if (VDecl->isFileVarDecl()) {
if (VDecl->getStorageClass() == SC_Extern &&
(!getLangOpts().CPlusPlus ||
!(Context.getBaseElementType(VDecl->getType()).isConstQualified() ||
VDecl->isExternC())))
Diag(VDecl->getLocation(), diag::warn_extern_init);
// C99 6.7.8p4. All file scoped initializers need to be constant.
if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl())
CheckForConstantInitializer(Init, DclT);
else if (VDecl->getTLSKind() == VarDecl::TLS_Static &&
!VDecl->isInvalidDecl() && !DclT->isDependentType() &&
!Init->isValueDependent() && !VDecl->isConstexpr() &&
!Init->isConstantInitializer(
Context, VDecl->getType()->isReferenceType())) {
// GNU C++98 edits for __thread, [basic.start.init]p4:
// An object of thread storage duration shall not require dynamic
// initialization.
// FIXME: Need strict checking here.
Diag(VDecl->getLocation(), diag::err_thread_dynamic_init);
if (getLangOpts().CPlusPlus11)
Diag(VDecl->getLocation(), diag::note_use_thread_local);
}
}
// We will represent direct-initialization similarly to copy-initialization:
// int x(1); -as-> int x = 1;
// ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
//
// Clients that want to distinguish between the two forms, can check for
// direct initializer using VarDecl::getInitStyle().
// A major benefit is that clients that don't particularly care about which
// exactly form was it (like the CodeGen) can handle both cases without
// special case code.
// C++ 8.5p11:
// The form of initialization (using parentheses or '=') is generally
// insignificant, but does matter when the entity being initialized has a
// class type.
if (CXXDirectInit) {
assert(DirectInit && "Call-style initializer must be direct init.");
VDecl->setInitStyle(VarDecl::CallInit);
} else if (DirectInit) {
// This must be list-initialization. No other way is direct-initialization.
VDecl->setInitStyle(VarDecl::ListInit);
}
CheckCompleteVariableDeclaration(VDecl);
}
/// ActOnInitializerError - Given that there was an error parsing an
/// initializer for the given declaration, try to return to some form
/// of sanity.
void Sema::ActOnInitializerError(Decl *D) {
// Our main concern here is re-establishing invariants like "a
// variable's type is either dependent or complete".
if (!D || D->isInvalidDecl()) return;
VarDecl *VD = dyn_cast<VarDecl>(D);
if (!VD) return;
// Auto types are meaningless if we can't make sense of the initializer.
if (ParsingInitForAutoVars.count(D)) {
D->setInvalidDecl();
return;
}
QualType Ty = VD->getType();
if (Ty->isDependentType()) return;
// Require a complete type.
if (RequireCompleteType(VD->getLocation(),
Context.getBaseElementType(Ty),
diag::err_typecheck_decl_incomplete_type)) {
VD->setInvalidDecl();
return;
}
// Require an abstract type.
if (RequireNonAbstractType(VD->getLocation(), Ty,
diag::err_abstract_type_in_decl,
AbstractVariableType)) {
VD->setInvalidDecl();
return;
}
// Don't bother complaining about constructors or destructors,
// though.
}
void Sema::ActOnUninitializedDecl(Decl *RealDecl,
bool TypeMayContainAuto) {
// If there is no declaration, there was an error parsing it. Just ignore it.
if (RealDecl == 0)
return;
if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
QualType Type = Var->getType();
// C++11 [dcl.spec.auto]p3
if (TypeMayContainAuto && Type->getContainedAutoType()) {
Diag(Var->getLocation(), diag::err_auto_var_requires_init)
<< Var->getDeclName() << Type;
Var->setInvalidDecl();
return;
}
// C++11 [class.static.data]p3: A static data member can be declared with
// the constexpr specifier; if so, its declaration shall specify
// a brace-or-equal-initializer.
// C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to
// the definition of a variable [...] or the declaration of a static data
// member.
if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) {
if (Var->isStaticDataMember())
Diag(Var->getLocation(),
diag::err_constexpr_static_mem_var_requires_init)
<< Var->getDeclName();
else
Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
Var->setInvalidDecl();
return;
}
switch (Var->isThisDeclarationADefinition()) {
case VarDecl::Definition:
if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
break;
// We have an out-of-line definition of a static data member
// that has an in-class initializer, so we type-check this like
// a declaration.
//
// Fall through
case VarDecl::DeclarationOnly:
// It's only a declaration.
// Block scope. C99 6.7p7: If an identifier for an object is
// declared with no linkage (C99 6.2.2p6), the type for the
// object shall be complete.
if (!Type->isDependentType() && Var->isLocalVarDecl() &&
!Var->getLinkage() && !Var->isInvalidDecl() &&
RequireCompleteType(Var->getLocation(), Type,
diag::err_typecheck_decl_incomplete_type))
Var->setInvalidDecl();
// Make sure that the type is not abstract.
if (!Type->isDependentType() && !Var->isInvalidDecl() &&
RequireNonAbstractType(Var->getLocation(), Type,
diag::err_abstract_type_in_decl,
AbstractVariableType))
Var->setInvalidDecl();
if (!Type->isDependentType() && !Var->isInvalidDecl() &&
Var->getStorageClass() == SC_PrivateExtern) {
Diag(Var->getLocation(), diag::warn_private_extern);
Diag(Var->getLocation(), diag::note_private_extern);
}
return;
case VarDecl::TentativeDefinition:
// File scope. C99 6.9.2p2: A declaration of an identifier for an
// object that has file scope without an initializer, and without a
// storage-class specifier or with the storage-class specifier "static",
// constitutes a tentative definition. Note: A tentative definition with
// external linkage is valid (C99 6.2.2p5).
if (!Var->isInvalidDecl()) {
if (const IncompleteArrayType *ArrayT
= Context.getAsIncompleteArrayType(Type)) {
if (RequireCompleteType(Var->getLocation(),
ArrayT->getElementType(),
diag::err_illegal_decl_array_incomplete_type))
Var->setInvalidDecl();
} else if (Var->getStorageClass() == SC_Static) {
// C99 6.9.2p3: If the declaration of an identifier for an object is
// a tentative definition and has internal linkage (C99 6.2.2p3), the
// declared type shall not be an incomplete type.
// NOTE: code such as the following
// static struct s;
// struct s { int a; };
// is accepted by gcc. Hence here we issue a warning instead of
// an error and we do not invalidate the static declaration.
// NOTE: to avoid multiple warnings, only check the first declaration.
if (Var->getPreviousDecl() == 0)
RequireCompleteType(Var->getLocation(), Type,
diag::ext_typecheck_decl_incomplete_type);
}
}
// Record the tentative definition; we're done.
if (!Var->isInvalidDecl())
TentativeDefinitions.push_back(Var);
return;
}
// Provide a specific diagnostic for uninitialized variable
// definitions with incomplete array type.
if (Type->isIncompleteArrayType()) {
Diag(Var->getLocation(),
diag::err_typecheck_incomplete_array_needs_initializer);
Var->setInvalidDecl();
return;
}
// Provide a specific diagnostic for uninitialized variable
// definitions with reference type.
if (Type->isReferenceType()) {
Diag(Var->getLocation(), diag::err_reference_var_requires_init)
<< Var->getDeclName()
<< SourceRange(Var->getLocation(), Var->getLocation());
Var->setInvalidDecl();
return;
}
// Do not attempt to type-check the default initializer for a
// variable with dependent type.
if (Type->isDependentType())
return;
if (Var->isInvalidDecl())
return;
if (RequireCompleteType(Var->getLocation(),
Context.getBaseElementType(Type),
diag::err_typecheck_decl_incomplete_type)) {
Var->setInvalidDecl();
return;
}
// The variable can not have an abstract class type.
if (RequireNonAbstractType(Var->getLocation(), Type,
diag::err_abstract_type_in_decl,
AbstractVariableType)) {
Var->setInvalidDecl();
return;
}
// Check for jumps past the implicit initializer. C++0x
// clarifies that this applies to a "variable with automatic
// storage duration", not a "local variable".
// C++11 [stmt.dcl]p3
// A program that jumps from a point where a variable with automatic
// storage duration is not in scope to a point where it is in scope is
// ill-formed unless the variable has scalar type, class type with a
// trivial default constructor and a trivial destructor, a cv-qualified
// version of one of these types, or an array of one of the preceding
// types and is declared without an initializer.
if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) {
if (const RecordType *Record
= Context.getBaseElementType(Type)->getAs<RecordType>()) {
CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl());
// Mark the function for further checking even if the looser rules of
// C++11 do not require such checks, so that we can diagnose
// incompatibilities with C++98.
if (!CXXRecord->isPOD())
getCurFunction()->setHasBranchProtectedScope();
}
}
// C++03 [dcl.init]p9:
// If no initializer is specified for an object, and the
// object is of (possibly cv-qualified) non-POD class type (or
// array thereof), the object shall be default-initialized; if
// the object is of const-qualified type, the underlying class
// type shall have a user-declared default
// constructor. Otherwise, if no initializer is specified for
// a non- static object, the object and its subobjects, if
// any, have an indeterminate initial value); if the object
// or any of its subobjects are of const-qualified type, the
// program is ill-formed.
// C++0x [dcl.init]p11:
// If no initializer is specified for an object, the object is
// default-initialized; [...].
InitializedEntity Entity = InitializedEntity::InitializeVariable(Var);
InitializationKind Kind
= InitializationKind::CreateDefault(Var->getLocation());
InitializationSequence InitSeq(*this, Entity, Kind, None);
ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None);
if (Init.isInvalid())
Var->setInvalidDecl();
else if (Init.get()) {
Var->setInit(MaybeCreateExprWithCleanups(Init.get()));
// This is important for template substitution.
Var->setInitStyle(VarDecl::CallInit);
}
CheckCompleteVariableDeclaration(Var);
}
}
void Sema::ActOnCXXForRangeDecl(Decl *D) {
VarDecl *VD = dyn_cast<VarDecl>(D);
if (!VD) {
Diag(D->getLocation(), diag::err_for_range_decl_must_be_var);
D->setInvalidDecl();
return;
}
VD->setCXXForRangeDecl(true);
// for-range-declaration cannot be given a storage class specifier.
int Error = -1;
switch (VD->getStorageClass()) {
case SC_None:
break;
case SC_Extern:
Error = 0;
break;
case SC_Static:
Error = 1;
break;
case SC_PrivateExtern:
Error = 2;
break;
case SC_Auto:
Error = 3;
break;
case SC_Register:
Error = 4;
break;
case SC_OpenCLWorkGroupLocal:
llvm_unreachable("Unexpected storage class");
}
if (VD->isConstexpr())
Error = 5;
if (Error != -1) {
Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class)
<< VD->getDeclName() << Error;
D->setInvalidDecl();
}
}
void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {
if (var->isInvalidDecl()) return;
// In ARC, don't allow jumps past the implicit initialization of a
// local retaining variable.
if (getLangOpts().ObjCAutoRefCount &&
var->hasLocalStorage()) {
switch (var->getType().getObjCLifetime()) {
case Qualifiers::OCL_None:
case Qualifiers::OCL_ExplicitNone:
case Qualifiers::OCL_Autoreleasing:
break;
case Qualifiers::OCL_Weak:
case Qualifiers::OCL_Strong:
getCurFunction()->setHasBranchProtectedScope();
break;
}
}
if (var->isThisDeclarationADefinition() &&
var->hasExternalLinkage() &&
getDiagnostics().getDiagnosticLevel(
diag::warn_missing_variable_declarations,
var->getLocation())) {
// Find a previous declaration that's not a definition.
VarDecl *prev = var->getPreviousDecl();
while (prev && prev->isThisDeclarationADefinition())
prev = prev->getPreviousDecl();
if (!prev)
Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
}
if (var->getTLSKind() == VarDecl::TLS_Static &&
var->getType().isDestructedType()) {
// GNU C++98 edits for __thread, [basic.start.term]p3:
// The type of an object with thread storage duration shall not
// have a non-trivial destructor.
Diag(var->getLocation(), diag::err_thread_nontrivial_dtor);
if (getLangOpts().CPlusPlus11)
Diag(var->getLocation(), diag::note_use_thread_local);
}
// All the following checks are C++ only.
if (!getLangOpts().CPlusPlus) return;
QualType type = var->getType();
if (type->isDependentType()) return;
// __block variables might require us to capture a copy-initializer.
if (var->hasAttr<BlocksAttr>()) {
// It's currently invalid to ever have a __block variable with an
// array type; should we diagnose that here?
// Regardless, we don't want to ignore array nesting when
// constructing this copy.
if (type->isStructureOrClassType()) {
EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated);
SourceLocation poi = var->getLocation();
Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi);
ExprResult result
= PerformMoveOrCopyInitialization(
InitializedEntity::InitializeBlock(poi, type, false),
var, var->getType(), varRef, /*AllowNRVO=*/true);
if (!result.isInvalid()) {
result = MaybeCreateExprWithCleanups(result);
Expr *init = result.takeAs<Expr>();
Context.setBlockVarCopyInits(var, init);
}
}
}
Expr *Init = var->getInit();
bool IsGlobal = var->hasGlobalStorage() && !var->isStaticLocal();
QualType baseType = Context.getBaseElementType(type);
if (!var->getDeclContext()->isDependentContext() &&
Init && !Init->isValueDependent()) {
if (IsGlobal && !var->isConstexpr() &&
getDiagnostics().getDiagnosticLevel(diag::warn_global_constructor,
var->getLocation())
!= DiagnosticsEngine::Ignored &&
!Init->isConstantInitializer(Context, baseType->isReferenceType()))
Diag(var->getLocation(), diag::warn_global_constructor)
<< Init->getSourceRange();
if (var->isConstexpr()) {
SmallVector<PartialDiagnosticAt, 8> Notes;
if (!var->evaluateValue(Notes) || !var->isInitICE()) {
SourceLocation DiagLoc = var->getLocation();
// If the note doesn't add any useful information other than a source
// location, fold it into the primary diagnostic.
if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
diag::note_invalid_subexpr_in_const_expr) {
DiagLoc = Notes[0].first;
Notes.clear();
}
Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
<< var << Init->getSourceRange();
for (unsigned I = 0, N = Notes.size(); I != N; ++I)
Diag(Notes[I].first, Notes[I].second);
}
} else if (var->isUsableInConstantExpressions(Context)) {
// Check whether the initializer of a const variable of integral or
// enumeration type is an ICE now, since we can't tell whether it was
// initialized by a constant expression if we check later.
var->checkInitIsICE();
}
}
// Require the destructor.
if (const RecordType *recordType = baseType->getAs<RecordType>())
FinalizeVarWithDestructor(var, recordType);
}
/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform
/// any semantic actions necessary after any initializer has been attached.
void
Sema::FinalizeDeclaration(Decl *ThisDecl) {
// Note that we are no longer parsing the initializer for this declaration.
ParsingInitForAutoVars.erase(ThisDecl);
VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
if (!VD)
return;
const DeclContext *DC = VD->getDeclContext();
// If there's a #pragma GCC visibility in scope, and this isn't a class
// member, set the visibility of this variable.
if (!DC->isRecord() && VD->hasExternalLinkage())
AddPushedVisibilityAttribute(VD);
if (VD->isFileVarDecl())
MarkUnusedFileScopedDecl(VD);
// Now we have parsed the initializer and can update the table of magic
// tag values.
if (!VD->hasAttr<TypeTagForDatatypeAttr>() ||
!VD->getType()->isIntegralOrEnumerationType())
return;
for (specific_attr_iterator<TypeTagForDatatypeAttr>
I = ThisDecl->specific_attr_begin<TypeTagForDatatypeAttr>(),
E = ThisDecl->specific_attr_end<TypeTagForDatatypeAttr>();
I != E; ++I) {
const Expr *MagicValueExpr = VD->getInit();
if (!MagicValueExpr) {
continue;
}
llvm::APSInt MagicValueInt;
if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) {
Diag(I->getRange().getBegin(),
diag::err_type_tag_for_datatype_not_ice)
<< LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
continue;
}
if (MagicValueInt.getActiveBits() > 64) {
Diag(I->getRange().getBegin(),
diag::err_type_tag_for_datatype_too_large)
<< LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
continue;
}
uint64_t MagicValue = MagicValueInt.getZExtValue();
RegisterTypeTagForDatatype(I->getArgumentKind(),
MagicValue,
I->getMatchingCType(),
I->getLayoutCompatible(),
I->getMustBeNull());
}
}
Sema::DeclGroupPtrTy
Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
Decl **Group, unsigned NumDecls) {
SmallVector<Decl*, 8> Decls;
if (DS.isTypeSpecOwned())
Decls.push_back(DS.getRepAsDecl());
for (unsigned i = 0; i != NumDecls; ++i)
if (Decl *D = Group[i])
Decls.push_back(D);
if (DeclSpec::isDeclRep(DS.getTypeSpecType()))
if (const TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl()))
getASTContext().addUnnamedTag(Tag);
return BuildDeclaratorGroup(Decls.data(), Decls.size(),
DS.containsPlaceholderType());
}
/// BuildDeclaratorGroup - convert a list of declarations into a declaration
/// group, performing any necessary semantic checking.
Sema::DeclGroupPtrTy
Sema::BuildDeclaratorGroup(Decl **Group, unsigned NumDecls,
bool TypeMayContainAuto) {
// C++0x [dcl.spec.auto]p7:
// If the type deduced for the template parameter U is not the same in each
// deduction, the program is ill-formed.
// FIXME: When initializer-list support is added, a distinction is needed
// between the deduced type U and the deduced type which 'auto' stands for.
// auto a = 0, b = { 1, 2, 3 };
// is legal because the deduced type U is 'int' in both cases.
if (TypeMayContainAuto && NumDecls > 1) {
QualType Deduced;
CanQualType DeducedCanon;
VarDecl *DeducedDecl = 0;
for (unsigned i = 0; i != NumDecls; ++i) {
if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) {
AutoType *AT = D->getType()->getContainedAutoType();
// Don't reissue diagnostics when instantiating a template.
if (AT && D->isInvalidDecl())
break;
QualType U = AT ? AT->getDeducedType() : QualType();
if (!U.isNull()) {
CanQualType UCanon = Context.getCanonicalType(U);
if (Deduced.isNull()) {
Deduced = U;
DeducedCanon = UCanon;
DeducedDecl = D;
} else if (DeducedCanon != UCanon) {
Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
diag::err_auto_different_deductions)
<< (AT->isDecltypeAuto() ? 1 : 0)
<< Deduced << DeducedDecl->getDeclName()
<< U << D->getDeclName()
<< DeducedDecl->getInit()->getSourceRange()
<< D->getInit()->getSourceRange();
D->setInvalidDecl();
break;
}
}
}
}
}
ActOnDocumentableDecls(Group, NumDecls);
return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, NumDecls));
}
void Sema::ActOnDocumentableDecl(Decl *D) {
ActOnDocumentableDecls(&D, 1);
}
void Sema::ActOnDocumentableDecls(Decl **Group, unsigned NumDecls) {
// Don't parse the comment if Doxygen diagnostics are ignored.
if (NumDecls == 0 || !Group[0])
return;
if (Diags.getDiagnosticLevel(diag::warn_doc_param_not_found,
Group[0]->getLocation())
== DiagnosticsEngine::Ignored)
return;
if (NumDecls >= 2) {
// This is a decl group. Normally it will contain only declarations
// procuded from declarator list. But in case we have any definitions or
// additional declaration references:
// 'typedef struct S {} S;'
// 'typedef struct S *S;'
// 'struct S *pS;'
// FinalizeDeclaratorGroup adds these as separate declarations.
Decl *MaybeTagDecl = Group[0];
if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
Group++;
NumDecls--;
}
}
// See if there are any new comments that are not attached to a decl.
ArrayRef<RawComment *> Comments = Context.getRawCommentList().getComments();
if (!Comments.empty() &&
!Comments.back()->isAttached()) {
// There is at least one comment that not attached to a decl.
// Maybe it should be attached to one of these decls?
//
// Note that this way we pick up not only comments that precede the
// declaration, but also comments that *follow* the declaration -- thanks to
// the lookahead in the lexer: we've consumed the semicolon and looked
// ahead through comments.
for (unsigned i = 0; i != NumDecls; ++i)
Context.getCommentForDecl(Group[i], &PP);
}
}
/// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
/// to introduce parameters into function prototype scope.
Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
const DeclSpec &DS = D.getDeclSpec();
// Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
// C++03 [dcl.stc]p2 also permits 'auto'.
VarDecl::StorageClass StorageClass = SC_None;
if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
StorageClass = SC_Register;
} else if (getLangOpts().CPlusPlus &&
DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
StorageClass = SC_Auto;
} else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
Diag(DS.getStorageClassSpecLoc(),
diag::err_invalid_storage_class_in_func_decl);
D.getMutableDeclSpec().ClearStorageClassSpecs();
}
if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread)
<< DeclSpec::getSpecifierName(TSCS);
if (DS.isConstexprSpecified())
Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr)
<< 0;
DiagnoseFunctionSpecifiers(DS);
TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
QualType parmDeclType = TInfo->getType();
if (getLangOpts().CPlusPlus) {
// Check that there are no default arguments inside the type of this
// parameter.
CheckExtraCXXDefaultArguments(D);
// Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
if (D.getCXXScopeSpec().isSet()) {
Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
<< D.getCXXScopeSpec().getRange();
D.getCXXScopeSpec().clear();
}
}
// Ensure we have a valid name
IdentifierInfo *II = 0;
if (D.hasName()) {
II = D.getIdentifier();
if (!II) {
Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name)
<< GetNameForDeclarator(D).getName().getAsString();
D.setInvalidType(true);
}
}
// Check for redeclaration of parameters, e.g. int foo(int x, int x);
if (II) {
LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName,
ForRedeclaration);
LookupName(R, S);
if (R.isSingleResult()) {
NamedDecl *PrevDecl = R.getFoundDecl();
if (PrevDecl->isTemplateParameter()) {
// Maybe we will complain about the shadowed template parameter.
DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
// Just pretend that we didn't see the previous declaration.
PrevDecl = 0;
} else if (S->isDeclScope(PrevDecl)) {
Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
// Recover by removing the name
II = 0;
D.SetIdentifier(0, D.getIdentifierLoc());
D.setInvalidType(true);
}
}
}
// Temporarily put parameter variables in the translation unit, not
// the enclosing context. This prevents them from accidentally
// looking like class members in C++.
ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(),
D.getLocStart(),
D.getIdentifierLoc(), II,
parmDeclType, TInfo,
StorageClass);
if (D.isInvalidType())
New->setInvalidDecl();
assert(S->isFunctionPrototypeScope());
assert(S->getFunctionPrototypeDepth() >= 1);
New->setScopeInfo(S->getFunctionPrototypeDepth() - 1,
S->getNextFunctionPrototypeIndex());
// Add the parameter declaration into this scope.
S->AddDecl(New);
if (II)
IdResolver.AddDecl(New);
ProcessDeclAttributes(S, New, D);
if (D.getDeclSpec().isModulePrivateSpecified())
Diag(New->getLocation(), diag::err_module_private_local)
<< 1 << New->getDeclName()
<< SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
<< FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
if (New->hasAttr<BlocksAttr>()) {
Diag(New->getLocation(), diag::err_block_on_nonlocal);
}
return New;
}
/// \brief Synthesizes a variable for a parameter arising from a
/// typedef.
ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC,
SourceLocation Loc,
QualType T) {
/* FIXME: setting StartLoc == Loc.
Would it be worth to modify callers so as to provide proper source
location for the unnamed parameters, embedding the parameter's type? */
ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, 0,
T, Context.getTrivialTypeSourceInfo(T, Loc),
SC_None, 0);
Param->setImplicit();
return Param;
}
void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param,
ParmVarDecl * const *ParamEnd) {
// Don't diagnose unused-parameter errors in template instantiations; we
// will already have done so in the template itself.
if (!ActiveTemplateInstantiations.empty())
return;
for (; Param != ParamEnd; ++Param) {
if (!(*Param)->isReferenced() && (*Param)->getDeclName() &&
!(*Param)->hasAttr<UnusedAttr>()) {
Diag((*Param)->getLocation(), diag::warn_unused_parameter)
<< (*Param)->getDeclName();
}
}
}
void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param,
ParmVarDecl * const *ParamEnd,
QualType ReturnTy,
NamedDecl *D) {
if (LangOpts.NumLargeByValueCopy == 0) // No check.
return;
// Warn if the return value is pass-by-value and larger than the specified
// threshold.
if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) {
unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity();
if (Size > LangOpts.NumLargeByValueCopy)
Diag(D->getLocation(), diag::warn_return_value_size)
<< D->getDeclName() << Size;
}
// Warn if any parameter is pass-by-value and larger than the specified
// threshold.
for (; Param != ParamEnd; ++Param) {
QualType T = (*Param)->getType();
if (T->isDependentType() || !T.isPODType(Context))
continue;
unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
if (Size > LangOpts.NumLargeByValueCopy)
Diag((*Param)->getLocation(), diag::warn_parameter_size)
<< (*Param)->getDeclName() << Size;
}
}
ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc,
SourceLocation NameLoc, IdentifierInfo *Name,
QualType T, TypeSourceInfo *TSInfo,
VarDecl::StorageClass StorageClass) {
// In ARC, infer a lifetime qualifier for appropriate parameter types.
if (getLangOpts().ObjCAutoRefCount &&
T.getObjCLifetime() == Qualifiers::OCL_None &&
T->isObjCLifetimeType()) {
Qualifiers::ObjCLifetime lifetime;
// Special cases for arrays:
// - if it's const, use __unsafe_unretained
// - otherwise, it's an error
if (T->isArrayType()) {
if (!T.isConstQualified()) {
DelayedDiagnostics.add(
sema::DelayedDiagnostic::makeForbiddenType(
NameLoc, diag::err_arc_array_param_no_ownership, T, false));
}
lifetime = Qualifiers::OCL_ExplicitNone;
} else {
lifetime = T->getObjCARCImplicitLifetime();
}
T = Context.getLifetimeQualifiedType(T, lifetime);
}
ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name,
Context.getAdjustedParameterType(T),
TSInfo,
StorageClass, 0);
// Parameters can not be abstract class types.
// For record types, this is done by the AbstractClassUsageDiagnoser once
// the class has been completely parsed.
if (!CurContext->isRecord() &&
RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl,
AbstractParamType))
New->setInvalidDecl();
// Parameter declarators cannot be interface types. All ObjC objects are
// passed by reference.
if (T->isObjCObjectType()) {
SourceLocation TypeEndLoc = TSInfo->getTypeLoc().getLocEnd();
Diag(NameLoc,
diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
<< FixItHint::CreateInsertion(TypeEndLoc, "*");
T = Context.getObjCObjectPointerType(T);
New->setType(T);
}
// ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
// duration shall not be qualified by an address-space qualifier."
// Since all parameters have automatic store duration, they can not have
// an address space.
if (T.getAddressSpace() != 0) {
Diag(NameLoc, diag::err_arg_with_address_space);
New->setInvalidDecl();
}
return New;
}
void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
SourceLocation LocAfterDecls) {
DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
// Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
// for a K&R function.
if (!FTI.hasPrototype) {
for (int i = FTI.NumArgs; i != 0; /* decrement in loop */) {
--i;
if (FTI.ArgInfo[i].Param == 0) {
SmallString<256> Code;
llvm::raw_svector_ostream(Code) << " int "
<< FTI.ArgInfo[i].Ident->getName()
<< ";\n";
Diag(FTI.ArgInfo[i].IdentLoc, diag::ext_param_not_declared)
<< FTI.ArgInfo[i].Ident
<< FixItHint::CreateInsertion(LocAfterDecls, Code.str());
// Implicitly declare the argument as type 'int' for lack of a better
// type.
AttributeFactory attrs;
DeclSpec DS(attrs);
const char* PrevSpec; // unused
unsigned DiagID; // unused
DS.SetTypeSpecType(DeclSpec::TST_int, FTI.ArgInfo[i].IdentLoc,
PrevSpec, DiagID);
// Use the identifier location for the type source range.
DS.SetRangeStart(FTI.ArgInfo[i].IdentLoc);
DS.SetRangeEnd(FTI.ArgInfo[i].IdentLoc);
Declarator ParamD(DS, Declarator::KNRTypeListContext);
ParamD.SetIdentifier(FTI.ArgInfo[i].Ident, FTI.ArgInfo[i].IdentLoc);
FTI.ArgInfo[i].Param = ActOnParamDeclarator(S, ParamD);
}
}
}
}
Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) {
assert(getCurFunctionDecl() == 0 && "Function parsing confused");
assert(D.isFunctionDeclarator() && "Not a function declarator!");
Scope *ParentScope = FnBodyScope->getParent();
D.setFunctionDefinitionKind(FDK_Definition);
Decl *DP = HandleDeclarator(ParentScope, D, MultiTemplateParamsArg());
return ActOnStartOfFunctionDef(FnBodyScope, DP);
}
static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD,
const FunctionDecl*& PossibleZeroParamPrototype) {
// Don't warn about invalid declarations.
if (FD->isInvalidDecl())
return false;
// Or declarations that aren't global.
if (!FD->isGlobal())
return false;
// Don't warn about C++ member functions.
if (isa<CXXMethodDecl>(FD))
return false;
// Don't warn about 'main'.
if (FD->isMain())
return false;
// Don't warn about inline functions.
if (FD->isInlined())
return false;
// Don't warn about function templates.
if (FD->getDescribedFunctionTemplate())
return false;
// Don't warn about function template specializations.
if (FD->isFunctionTemplateSpecialization())
return false;
// Don't warn for OpenCL kernels.
if (FD->hasAttr<OpenCLKernelAttr>())
return false;
bool MissingPrototype = true;
for (const FunctionDecl *Prev = FD->getPreviousDecl();
Prev; Prev = Prev->getPreviousDecl()) {
// Ignore any declarations that occur in function or method
// scope, because they aren't visible from the header.
if (Prev->getDeclContext()->isFunctionOrMethod())
continue;
MissingPrototype = !Prev->getType()->isFunctionProtoType();
if (FD->getNumParams() == 0)
PossibleZeroParamPrototype = Prev;
break;
}
return MissingPrototype;
}
void Sema::CheckForFunctionRedefinition(FunctionDecl *FD) {
// Don't complain if we're in GNU89 mode and the previous definition
// was an extern inline function.
const FunctionDecl *Definition;
if (FD->isDefined(Definition) &&
!canRedefineFunction(Definition, getLangOpts())) {
if (getLangOpts().GNUMode && Definition->isInlineSpecified() &&
Definition->getStorageClass() == SC_Extern)
Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
<< FD->getDeclName() << getLangOpts().CPlusPlus;
else
Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
Diag(Definition->getLocation(), diag::note_previous_definition);
FD->setInvalidDecl();
}
}
Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) {
// Clear the last template instantiation error context.
LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
if (!D)
return D;
FunctionDecl *FD = 0;
if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
FD = FunTmpl->getTemplatedDecl();
else
FD = cast<FunctionDecl>(D);
// Enter a new function scope
PushFunctionScope();
// See if this is a redefinition.
if (!FD->isLateTemplateParsed())
CheckForFunctionRedefinition(FD);
// Builtin functions cannot be defined.
if (unsigned BuiltinID = FD->getBuiltinID()) {
if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
FD->setInvalidDecl();
}
}
// The return type of a function definition must be complete
// (C99 6.9.1p3, C++ [dcl.fct]p6).
QualType ResultType = FD->getResultType();
if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
!FD->isInvalidDecl() &&
RequireCompleteType(FD->getLocation(), ResultType,
diag::err_func_def_incomplete_result))
FD->setInvalidDecl();
// GNU warning -Wmissing-prototypes:
// Warn if a global function is defined without a previous
// prototype declaration. This warning is issued even if the
// definition itself provides a prototype. The aim is to detect
// global functions that fail to be declared in header files.
const FunctionDecl *PossibleZeroParamPrototype = 0;
if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) {
Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
if (PossibleZeroParamPrototype) {
// We found a declaration that is not a prototype,
// but that could be a zero-parameter prototype
TypeSourceInfo* TI = PossibleZeroParamPrototype->getTypeSourceInfo();
TypeLoc TL = TI->getTypeLoc();
if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>())
Diag(PossibleZeroParamPrototype->getLocation(),
diag::note_declaration_not_a_prototype)
<< PossibleZeroParamPrototype
<< FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
}
}
if (FnBodyScope)
PushDeclContext(FnBodyScope, FD);
// Check the validity of our function parameters
CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(),
/*CheckParameterNames=*/true);
// Introduce our parameters into the function scope
for (unsigned p = 0, NumParams = FD->getNumParams(); p < NumParams; ++p) {
ParmVarDecl *Param = FD->getParamDecl(p);
Param->setOwningFunction(FD);
// If this has an identifier, add it to the scope stack.
if (Param->getIdentifier() && FnBodyScope) {
CheckShadow(FnBodyScope, Param);
PushOnScopeChains(Param, FnBodyScope);
}
}
// If we had any tags defined in the function prototype,
// introduce them into the function scope.
if (FnBodyScope) {
for (llvm::ArrayRef<NamedDecl*>::iterator I = FD->getDeclsInPrototypeScope().begin(),
E = FD->getDeclsInPrototypeScope().end(); I != E; ++I) {
NamedDecl *D = *I;
// Some of these decls (like enums) may have been pinned to the translation unit
// for lack of a real context earlier. If so, remove from the translation unit
// and reattach to the current context.
if (D->getLexicalDeclContext() == Context.getTranslationUnitDecl()) {
// Is the decl actually in the context?
for (DeclContext::decl_iterator DI = Context.getTranslationUnitDecl()->decls_begin(),
DE = Context.getTranslationUnitDecl()->decls_end(); DI != DE; ++DI) {
if (*DI == D) {
Context.getTranslationUnitDecl()->removeDecl(D);
break;
}
}
// Either way, reassign the lexical decl context to our FunctionDecl.
D->setLexicalDeclContext(CurContext);
}
// If the decl has a non-null name, make accessible in the current scope.
if (!D->getName().empty())
PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false);
// Similarly, dive into enums and fish their constants out, making them
// accessible in this scope.
if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
for (EnumDecl::enumerator_iterator EI = ED->enumerator_begin(),
EE = ED->enumerator_end(); EI != EE; ++EI)
PushOnScopeChains(*EI, FnBodyScope, /*AddToContext=*/false);
}
}
}
// Ensure that the function's exception specification is instantiated.
if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>())
ResolveExceptionSpec(D->getLocation(), FPT);
// Checking attributes of current function definition
// dllimport attribute.
DLLImportAttr *DA = FD->getAttr<DLLImportAttr>();
if (DA && (!FD->getAttr<DLLExportAttr>())) {
// dllimport attribute cannot be directly applied to definition.
// Microsoft accepts dllimport for functions defined within class scope.
if (!DA->isInherited() &&
!(LangOpts.MicrosoftExt && FD->getLexicalDeclContext()->isRecord())) {
Diag(FD->getLocation(),
diag::err_attribute_can_be_applied_only_to_symbol_declaration)
<< "dllimport";
FD->setInvalidDecl();
return D;
}
// Visual C++ appears to not think this is an issue, so only issue
// a warning when Microsoft extensions are disabled.
if (!LangOpts.MicrosoftExt) {
// If a symbol previously declared dllimport is later defined, the
// attribute is ignored in subsequent references, and a warning is
// emitted.
Diag(FD->getLocation(),
diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
<< FD->getName() << "dllimport";
}
}
// We want to attach documentation to original Decl (which might be
// a function template).
ActOnDocumentableDecl(D);
return D;
}
/// \brief Given the set of return statements within a function body,
/// compute the variables that are subject to the named return value
/// optimization.
///
/// Each of the variables that is subject to the named return value
/// optimization will be marked as NRVO variables in the AST, and any
/// return statement that has a marked NRVO variable as its NRVO candidate can
/// use the named return value optimization.
///
/// This function applies a very simplistic algorithm for NRVO: if every return
/// statement in the function has the same NRVO candidate, that candidate is
/// the NRVO variable.
///
/// FIXME: Employ a smarter algorithm that accounts for multiple return
/// statements and the lifetimes of the NRVO candidates. We should be able to
/// find a maximal set of NRVO variables.
void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) {
ReturnStmt **Returns = Scope->Returns.data();
const VarDecl *NRVOCandidate = 0;
for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) {
if (!Returns[I]->getNRVOCandidate())
return;
if (!NRVOCandidate)
NRVOCandidate = Returns[I]->getNRVOCandidate();
else if (NRVOCandidate != Returns[I]->getNRVOCandidate())
return;
}
if (NRVOCandidate)
const_cast<VarDecl*>(NRVOCandidate)->setNRVOVariable(true);
}
bool Sema::canSkipFunctionBody(Decl *D) {
if (!Consumer.shouldSkipFunctionBody(D))
return false;
if (isa<ObjCMethodDecl>(D))
return true;
FunctionDecl *FD = 0;
if (FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D))
FD = FTD->getTemplatedDecl();
else
FD = cast<FunctionDecl>(D);
// We cannot skip the body of a function (or function template) which is
// constexpr, since we may need to evaluate its body in order to parse the
// rest of the file.
return !FD->isConstexpr();
}
Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) {
if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl))
FD->setHasSkippedBody();
else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl))
MD->setHasSkippedBody();
return ActOnFinishFunctionBody(Decl, 0);
}
Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) {
return ActOnFinishFunctionBody(D, BodyArg, false);
}
Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
bool IsInstantiation) {
FunctionDecl *FD = 0;
FunctionTemplateDecl *FunTmpl = dyn_cast_or_null<FunctionTemplateDecl>(dcl);
if (FunTmpl)
FD = FunTmpl->getTemplatedDecl();
else
FD = dyn_cast_or_null<FunctionDecl>(dcl);
sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
sema::AnalysisBasedWarnings::Policy *ActivePolicy = 0;
if (FD) {
FD->setBody(Body);
if (getLangOpts().CPlusPlus1y && !FD->isInvalidDecl() &&
!FD->isDependentContext()) {
if (FD->getResultType()->isUndeducedType()) {
// If the function has a deduced result type but contains no 'return'
// statements, the result type as written must be exactly 'auto', and
// the deduced result type is 'void'.
if (!FD->getResultType()->getAs<AutoType>()) {
Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto)
<< FD->getResultType();
FD->setInvalidDecl();
}
Context.adjustDeducedFunctionResultType(FD, Context.VoidTy);
}
}
// The only way to be included in UndefinedButUsed is if there is an
// ODR use before the definition. Avoid the expensive map lookup if this
// is the first declaration.
if (FD->getPreviousDecl() != 0 && FD->getPreviousDecl()->isUsed()) {
if (FD->getLinkage() != ExternalLinkage)
UndefinedButUsed.erase(FD);
else if (FD->isInlined() &&
(LangOpts.CPlusPlus || !LangOpts.GNUInline) &&
(!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>()))
UndefinedButUsed.erase(FD);
}
if(numElementWise) {
FD->setElementWise(true);
--numElementWise;
}
else
FD->setElementWise(false);
// If the function implicitly returns zero (like 'main') or is naked,
// don't complain about missing return statements.
if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>())
WP.disableCheckFallThrough();
// MSVC permits the use of pure specifier (=0) on function definition,
// defined at class scope, warn about this non standard construct.
if (getLangOpts().MicrosoftExt && FD->isPure())
Diag(FD->getLocation(), diag::warn_pure_function_definition);
if (!FD->isInvalidDecl()) {
DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(),
FD->getResultType(), FD);
// If this is a constructor, we need a vtable.
if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
MarkVTableUsed(FD->getLocation(), Constructor->getParent());
// Try to apply the named return value optimization. We have to check
// if we can do this here because lambdas keep return statements around
// to deduce an implicit return type.
if (getLangOpts().CPlusPlus && FD->getResultType()->isRecordType() &&
!FD->isDependentContext())
computeNRVO(Body, getCurFunction());
}
assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) &&
"Function parsing confused");
} else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
assert(MD == getCurMethodDecl() && "Method parsing confused");
MD->setBody(Body);
if (!MD->isInvalidDecl()) {
DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(),
MD->getResultType(), MD);
if (Body)
computeNRVO(Body, getCurFunction());
}
if (getCurFunction()->ObjCShouldCallSuper) {
Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call)
<< MD->getSelector().getAsString();
getCurFunction()->ObjCShouldCallSuper = false;
}
} else {
return 0;
}
assert(!getCurFunction()->ObjCShouldCallSuper &&
"This should only be set for ObjC methods, which should have been "
"handled in the block above.");
// Verify and clean out per-function state.
if (Body) {
// C++ constructors that have function-try-blocks can't have return
// statements in the handlers of that block. (C++ [except.handle]p14)
// Verify this.
if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
// Verify that gotos and switch cases don't jump into scopes illegally.
if (getCurFunction()->NeedsScopeChecking() &&
!dcl->isInvalidDecl() &&
!hasAnyUnrecoverableErrorsInThisFunction() &&
!PP.isCodeCompletionEnabled())
DiagnoseInvalidJumps(Body);
if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) {
if (!Destructor->getParent()->isDependentType())
CheckDestructor(Destructor);
MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
Destructor->getParent());
}
// If any errors have occurred, clear out any temporaries that may have
// been leftover. This ensures that these temporaries won't be picked up for
// deletion in some later function.
if (PP.getDiagnostics().hasErrorOccurred() ||
PP.getDiagnostics().getSuppressAllDiagnostics()) {
DiscardCleanupsInEvaluationContext();
}
if (!PP.getDiagnostics().hasUncompilableErrorOccurred() &&
!isa<FunctionTemplateDecl>(dcl)) {
// Since the body is valid, issue any analysis-based warnings that are
// enabled.
ActivePolicy = &WP;
}
if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
(!CheckConstexprFunctionDecl(FD) ||
!CheckConstexprFunctionBody(FD, Body)))
FD->setInvalidDecl();
assert(ExprCleanupObjects.empty() && "Leftover temporaries in function");
assert(!ExprNeedsCleanups && "Unaccounted cleanups in function");
assert(MaybeODRUseExprs.empty() &&
"Leftover expressions for odr-use checking");
}
if (!IsInstantiation)
PopDeclContext();
PopFunctionScopeInfo(ActivePolicy, dcl);
// If any errors have occurred, clear out any temporaries that may have
// been leftover. This ensures that these temporaries won't be picked up for
// deletion in some later function.
if (getDiagnostics().hasErrorOccurred()) {
DiscardCleanupsInEvaluationContext();
}
return dcl;
}
/// When we finish delayed parsing of an attribute, we must attach it to the
/// relevant Decl.
void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D,
ParsedAttributes &Attrs) {
// Always attach attributes to the underlying decl.
if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
D = TD->getTemplatedDecl();
ProcessDeclAttributeList(S, D, Attrs.getList());
if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
if (Method->isStatic())
checkThisInStaticMemberFunctionAttributes(Method);
}
/// ImplicitlyDefineFunction - An undeclared identifier was used in a function
/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
IdentifierInfo &II, Scope *S) {
// Before we produce a declaration for an implicitly defined
// function, see whether there was a locally-scoped declaration of
// this name as a function or variable. If so, use that
// (non-visible) declaration, and complain about it.
llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
= findLocallyScopedExternCDecl(&II);
if (Pos != LocallyScopedExternCDecls.end()) {
Diag(Loc, diag::warn_use_out_of_scope_declaration) << Pos->second;
Diag(Pos->second->getLocation(), diag::note_previous_declaration);
return Pos->second;
}
// Extension in C99. Legal in C90, but warn about it.
unsigned diag_id;
if (II.getName().startswith("__builtin_"))
diag_id = diag::warn_builtin_unknown;
else if (getLangOpts().C99)
diag_id = diag::ext_implicit_function_decl;
else
diag_id = diag::warn_implicit_function_decl;
Diag(Loc, diag_id) << &II;
// Because typo correction is expensive, only do it if the implicit
// function declaration is going to be treated as an error.
if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) {
TypoCorrection Corrected;
DeclFilterCCC<FunctionDecl> Validator;
if (S && (Corrected = CorrectTypo(DeclarationNameInfo(&II, Loc),
LookupOrdinaryName, S, 0, Validator))) {
std::string CorrectedStr = Corrected.getAsString(getLangOpts());
std::string CorrectedQuotedStr = Corrected.getQuoted(getLangOpts());
FunctionDecl *Func = Corrected.getCorrectionDeclAs<FunctionDecl>();
Diag(Loc, diag::note_function_suggestion) << CorrectedQuotedStr
<< FixItHint::CreateReplacement(Loc, CorrectedStr);
if (Func->getLocation().isValid()
&& !II.getName().startswith("__builtin_"))
Diag(Func->getLocation(), diag::note_previous_decl)
<< CorrectedQuotedStr;
}
}
// Set a Declarator for the implicit definition: int foo();
const char *Dummy;
AttributeFactory attrFactory;
DeclSpec DS(attrFactory);
unsigned DiagID;
bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID);
(void)Error; // Silence warning.
assert(!Error && "Error setting up implicit decl!");
SourceLocation NoLoc;
Declarator D(DS, Declarator::BlockContext);
D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false,
/*IsAmbiguous=*/false,
/*RParenLoc=*/NoLoc,
/*ArgInfo=*/0,
/*NumArgs=*/0,
/*EllipsisLoc=*/NoLoc,
/*RParenLoc=*/NoLoc,
/*TypeQuals=*/0,
/*RefQualifierIsLvalueRef=*/true,
/*RefQualifierLoc=*/NoLoc,
/*ConstQualifierLoc=*/NoLoc,
/*VolatileQualifierLoc=*/NoLoc,
/*MutableLoc=*/NoLoc,
EST_None,
/*ESpecLoc=*/NoLoc,
/*Exceptions=*/0,
/*ExceptionRanges=*/0,
/*NumExceptions=*/0,
/*NoexceptExpr=*/0,
Loc, Loc, D),
DS.getAttributes(),
SourceLocation());
D.SetIdentifier(&II, Loc);
// Insert this function into translation-unit scope.
DeclContext *PrevDC = CurContext;
CurContext = Context.getTranslationUnitDecl();
FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D));
FD->setImplicit();
CurContext = PrevDC;
AddKnownFunctionAttributes(FD);
return FD;
}
/// \brief Adds any function attributes that we know a priori based on
/// the declaration of this function.
///
/// These attributes can apply both to implicitly-declared builtins
/// (like __builtin___printf_chk) or to library-declared functions
/// like NSLog or printf.
///
/// We need to check for duplicate attributes both here and where user-written
/// attributes are applied to declarations.
void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
if (FD->isInvalidDecl())
return;
// If this is a built-in function, map its builtin attributes to
// actual attributes.
if (unsigned BuiltinID = FD->getBuiltinID()) {
// Handle printf-formatting attributes.
unsigned FormatIdx;
bool HasVAListArg;
if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
if (!FD->getAttr<FormatAttr>()) {
const char *fmt = "printf";
unsigned int NumParams = FD->getNumParams();
if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf)
FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType())
fmt = "NSString";
FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context,
fmt, FormatIdx+1,
HasVAListArg ? 0 : FormatIdx+2));
}
}
if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx,
HasVAListArg)) {
if (!FD->getAttr<FormatAttr>())
FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context,
"scanf", FormatIdx+1,
HasVAListArg ? 0 : FormatIdx+2));
}
// Mark const if we don't care about errno and that is the only
// thing preventing the function from being const. This allows
// IRgen to use LLVM intrinsics for such functions.
if (!getLangOpts().MathErrno &&
Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
if (!FD->getAttr<ConstAttr>())
FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context));
}
if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
!FD->getAttr<ReturnsTwiceAttr>())
FD->addAttr(::new (Context) ReturnsTwiceAttr(FD->getLocation(), Context));
if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->getAttr<NoThrowAttr>())
FD->addAttr(::new (Context) NoThrowAttr(FD->getLocation(), Context));
if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->getAttr<ConstAttr>())
FD->addAttr(::new (Context) ConstAttr(FD->getLocation(), Context));
}
IdentifierInfo *Name = FD->getIdentifier();
if (!Name)
return;
if ((!getLangOpts().CPlusPlus &&
FD->getDeclContext()->isTranslationUnit()) ||
(isa<LinkageSpecDecl>(FD->getDeclContext()) &&
cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
LinkageSpecDecl::lang_c)) {
// Okay: this could be a libc/libm/Objective-C function we know
// about.
} else
return;
if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
// FIXME: asprintf and vasprintf aren't C99 functions. Should they be
// target-specific builtins, perhaps?
if (!FD->getAttr<FormatAttr>())
FD->addAttr(::new (Context) FormatAttr(FD->getLocation(), Context,
"printf", 2,
Name->isStr("vasprintf") ? 0 : 3));
}
if (Name->isStr("__CFStringMakeConstantString")) {
// We already have a __builtin___CFStringMakeConstantString,
// but builds that use -fno-constant-cfstrings don't go through that.
if (!FD->getAttr<FormatArgAttr>())
FD->addAttr(::new (Context) FormatArgAttr(FD->getLocation(), Context, 1));
}
}
TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
TypeSourceInfo *TInfo) {
assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
if (!TInfo) {
assert(D.isInvalidType() && "no declarator info for valid type");
TInfo = Context.getTrivialTypeSourceInfo(T);
}
// Scope manipulation handled by caller.
TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
D.getLocStart(),
D.getIdentifierLoc(),
D.getIdentifier(),
TInfo);
// Bail out immediately if we have an invalid declaration.
if (D.isInvalidType()) {
NewTD->setInvalidDecl();
return NewTD;
}
if (D.getDeclSpec().isModulePrivateSpecified()) {
if (CurContext->isFunctionOrMethod())
Diag(NewTD->getLocation(), diag::err_module_private_local)
<< 2 << NewTD->getDeclName()
<< SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
<< FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
else
NewTD->setModulePrivate();
}
// C++ [dcl.typedef]p8:
// If the typedef declaration defines an unnamed class (or
// enum), the first typedef-name declared by the declaration
// to be that class type (or enum type) is used to denote the
// class type (or enum type) for linkage purposes only.
// We need to check whether the type was declared in the declaration.
switch (D.getDeclSpec().getTypeSpecType()) {
case TST_enum:
case TST_struct:
case TST_interface:
case TST_union:
case TST_class: {
TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
// Do nothing if the tag is not anonymous or already has an
// associated typedef (from an earlier typedef in this decl group).
if (tagFromDeclSpec->getIdentifier()) break;
if (tagFromDeclSpec->getTypedefNameForAnonDecl()) break;
// A well-formed anonymous tag must always be a TUK_Definition.
assert(tagFromDeclSpec->isThisDeclarationADefinition());
// The type must match the tag exactly; no qualifiers allowed.
if (!Context.hasSameType(T, Context.getTagDeclType(tagFromDeclSpec)))
break;
// Otherwise, set this is the anon-decl typedef for the tag.
tagFromDeclSpec->setTypedefNameForAnonDecl(NewTD);
break;
}
default:
break;
}
return NewTD;
}
/// \brief Check that this is a valid underlying type for an enum declaration.
bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) {
SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
QualType T = TI->getType();
if (T->isDependentType())
return false;
if (const BuiltinType *BT = T->getAs<BuiltinType>())
if (BT->isInteger())
return false;
Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T;
return true;
}
/// Check whether this is a valid redeclaration of a previous enumeration.
/// \return true if the redeclaration was invalid.
bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
QualType EnumUnderlyingTy,
const EnumDecl *Prev) {
bool IsFixed = !EnumUnderlyingTy.isNull();
if (IsScoped != Prev->isScoped()) {
Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
<< Prev->isScoped();
Diag(Prev->getLocation(), diag::note_previous_use);
return true;
}
if (IsFixed && Prev->isFixed()) {
if (!EnumUnderlyingTy->isDependentType() &&
!Prev->getIntegerType()->isDependentType() &&
!Context.hasSameUnqualifiedType(EnumUnderlyingTy,
Prev->getIntegerType())) {
Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
<< EnumUnderlyingTy << Prev->getIntegerType();
Diag(Prev->getLocation(), diag::note_previous_use);
return true;
}
} else if (IsFixed != Prev->isFixed()) {
Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
<< Prev->isFixed();
Diag(Prev->getLocation(), diag::note_previous_use);
return true;
}
return false;
}
/// \brief Get diagnostic %select index for tag kind for
/// redeclaration diagnostic message.
/// WARNING: Indexes apply to particular diagnostics only!
///
/// \returns diagnostic %select index.
static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) {
switch (Tag) {
case TTK_Struct: return 0;
case TTK_Interface: return 1;
case TTK_Class: return 2;
default: llvm_unreachable("Invalid tag kind for redecl diagnostic!");
}
}
/// \brief Determine if tag kind is a class-key compatible with
/// class for redeclaration (class, struct, or __interface).
///
/// \returns true iff the tag kind is compatible.
static bool isClassCompatTagKind(TagTypeKind Tag)
{
return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface;
}
/// \brief Determine whether a tag with a given kind is acceptable
/// as a redeclaration of the given tag declaration.
///
/// \returns true if the new tag kind is acceptable, false otherwise.
bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
TagTypeKind NewTag, bool isDefinition,
SourceLocation NewTagLoc,
const IdentifierInfo &Name) {
// C++ [dcl.type.elab]p3:
// The class-key or enum keyword present in the
// elaborated-type-specifier shall agree in kind with the
// declaration to which the name in the elaborated-type-specifier
// refers. This rule also applies to the form of
// elaborated-type-specifier that declares a class-name or
// friend class since it can be construed as referring to the
// definition of the class. Thus, in any
// elaborated-type-specifier, the enum keyword shall be used to
// refer to an enumeration (7.2), the union class-key shall be
// used to refer to a union (clause 9), and either the class or
// struct class-key shall be used to refer to a class (clause 9)
// declared using the class or struct class-key.
TagTypeKind OldTag = Previous->getTagKind();
if (!isDefinition || !isClassCompatTagKind(NewTag))
if (OldTag == NewTag)
return true;
if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) {
// Warn about the struct/class tag mismatch.
bool isTemplate = false;
if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
isTemplate = Record->getDescribedClassTemplate();
if (!ActiveTemplateInstantiations.empty()) {
// In a template instantiation, do not offer fix-its for tag mismatches
// since they usually mess up the template instead of fixing the problem.
Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
<< getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
<< getRedeclDiagFromTagKind(OldTag);
return true;
}
if (isDefinition) {
// On definitions, check previous tags and issue a fix-it for each
// one that doesn't match the current tag.
if (Previous->getDefinition()) {
// Don't suggest fix-its for redefinitions.
return true;
}
bool previousMismatch = false;
for (TagDecl::redecl_iterator I(Previous->redecls_begin()),
E(Previous->redecls_end()); I != E; ++I) {
if (I->getTagKind() != NewTag) {
if (!previousMismatch) {
previousMismatch = true;
Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
<< getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
<< getRedeclDiagFromTagKind(I->getTagKind());
}
Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
<< getRedeclDiagFromTagKind(NewTag)
<< FixItHint::CreateReplacement(I->getInnerLocStart(),
TypeWithKeyword::getTagTypeKindName(NewTag));
}
}
return true;
}
// Check for a previous definition. If current tag and definition
// are same type, do nothing. If no definition, but disagree with
// with previous tag type, give a warning, but no fix-it.
const TagDecl *Redecl = Previous->getDefinition() ?
Previous->getDefinition() : Previous;
if (Redecl->getTagKind() == NewTag) {
return true;
}
Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
<< getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
<< getRedeclDiagFromTagKind(OldTag);
Diag(Redecl->getLocation(), diag::note_previous_use);
// If there is a previous defintion, suggest a fix-it.
if (Previous->getDefinition()) {
Diag(NewTagLoc, diag::note_struct_class_suggestion)
<< getRedeclDiagFromTagKind(Redecl->getTagKind())
<< FixItHint::CreateReplacement(SourceRange(NewTagLoc),
TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind()));
}
return true;
}
return false;
}
/// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'. In the
/// former case, Name will be non-null. In the later case, Name will be null.
/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
/// reference/declaration/definition of a tag.
Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
SourceLocation KWLoc, CXXScopeSpec &SS,
IdentifierInfo *Name, SourceLocation NameLoc,
AttributeList *Attr, AccessSpecifier AS,
SourceLocation ModulePrivateLoc,
MultiTemplateParamsArg TemplateParameterLists,
bool &OwnedDecl, bool &IsDependent,
SourceLocation ScopedEnumKWLoc,
bool ScopedEnumUsesClassTag,
TypeResult UnderlyingType) {
// If this is not a definition, it must have a name.
IdentifierInfo *OrigName = Name;
assert((Name != 0 || TUK == TUK_Definition) &&
"Nameless record must be a definition!");
assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference);
OwnedDecl = false;
TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
bool ScopedEnum = ScopedEnumKWLoc.isValid();
// FIXME: Check explicit specializations more carefully.
bool isExplicitSpecialization = false;
bool Invalid = false;
// We only need to do this matching if we have template parameters
// or a scope specifier, which also conveniently avoids this work
// for non-C++ cases.
if (TemplateParameterLists.size() > 0 ||
(SS.isNotEmpty() && TUK != TUK_Reference)) {
if (TemplateParameterList *TemplateParams
= MatchTemplateParametersToScopeSpecifier(KWLoc, NameLoc, SS,
TemplateParameterLists.data(),
TemplateParameterLists.size(),
TUK == TUK_Friend,
isExplicitSpecialization,
Invalid)) {
if (Kind == TTK_Enum) {
Diag(KWLoc, diag::err_enum_template);
return 0;
}
if (TemplateParams->size() > 0) {
// This is a declaration or definition of a class template (which may
// be a member of another template).
if (Invalid)
return 0;
OwnedDecl = false;
DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
SS, Name, NameLoc, Attr,
TemplateParams, AS,
ModulePrivateLoc,
TemplateParameterLists.size()-1,
TemplateParameterLists.data());
return Result.get();
} else {
// The "template<>" header is extraneous.
Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
<< TypeWithKeyword::getTagTypeKindName(Kind) << Name;
isExplicitSpecialization = true;
}
}
}
// Figure out the underlying type if this a enum declaration. We need to do
// this early, because it's needed to detect if this is an incompatible
// redeclaration.
llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
if (Kind == TTK_Enum) {
if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum))
// No underlying type explicitly specified, or we failed to parse the
// type, default to int.
EnumUnderlying = Context.IntTy.getTypePtr();
else if (UnderlyingType.get()) {
// C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an
// integral type; any cv-qualification is ignored.
TypeSourceInfo *TI = 0;
GetTypeFromParser(UnderlyingType.get(), &TI);
EnumUnderlying = TI;
if (CheckEnumUnderlyingType(TI))
// Recover by falling back to int.
EnumUnderlying = Context.IntTy.getTypePtr();
if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI,
UPPC_FixedUnderlyingType))
EnumUnderlying = Context.IntTy.getTypePtr();
} else if (getLangOpts().MicrosoftMode)
// Microsoft enums are always of int type.
EnumUnderlying = Context.IntTy.getTypePtr();
}
DeclContext *SearchDC = CurContext;
DeclContext *DC = CurContext;
bool isStdBadAlloc = false;
RedeclarationKind Redecl = ForRedeclaration;
if (TUK == TUK_Friend || TUK == TUK_Reference)
Redecl = NotForRedeclaration;
LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
if (Name && SS.isNotEmpty()) {
// We have a nested-name tag ('struct foo::bar').
// Check for invalid 'foo::'.
if (SS.isInvalid()) {
Name = 0;
goto CreateNewDecl;
}
// If this is a friend or a reference to a class in a dependent
// context, don't try to make a decl for it.
if (TUK == TUK_Friend || TUK == TUK_Reference) {
DC = computeDeclContext(SS, false);
if (!DC) {
IsDependent = true;
return 0;
}
} else {
DC = computeDeclContext(SS, true);
if (!DC) {
Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec)
<< SS.getRange();
return 0;
}
}
if (RequireCompleteDeclContext(SS, DC))
return 0;
SearchDC = DC;
// Look-up name inside 'foo::'.
LookupQualifiedName(Previous, DC);
if (Previous.isAmbiguous())
return 0;
if (Previous.empty()) {
// Name lookup did not find anything. However, if the
// nested-name-specifier refers to the current instantiation,
// and that current instantiation has any dependent base
// classes, we might find something at instantiation time: treat
// this as a dependent elaborated-type-specifier.
// But this only makes any sense for reference-like lookups.
if (Previous.wasNotFoundInCurrentInstantiation() &&
(TUK == TUK_Reference || TUK == TUK_Friend)) {
IsDependent = true;
return 0;
}
// A tag 'foo::bar' must already exist.
Diag(NameLoc, diag::err_not_tag_in_scope)
<< Kind << Name << DC << SS.getRange();
Name = 0;
Invalid = true;
goto CreateNewDecl;
}
} else if (Name) {
// If this is a named struct, check to see if there was a previous forward
// declaration or definition.
// FIXME: We're looking into outer scopes here, even when we
// shouldn't be. Doing so can result in ambiguities that we
// shouldn't be diagnosing.
LookupName(Previous, S);
// When declaring or defining a tag, ignore ambiguities introduced
// by types using'ed into this scope.
if (Previous.isAmbiguous() &&
(TUK == TUK_Definition || TUK == TUK_Declaration)) {
LookupResult::Filter F = Previous.makeFilter();
while (F.hasNext()) {
NamedDecl *ND = F.next();
if (ND->getDeclContext()->getRedeclContext() != SearchDC)
F.erase();
}
F.done();
}
// C++11 [namespace.memdef]p3:
// If the name in a friend declaration is neither qualified nor
// a template-id and the declaration is a function or an
// elaborated-type-specifier, the lookup to determine whether
// the entity has been previously declared shall not consider
// any scopes outside the innermost enclosing namespace.
//
// Does it matter that this should be by scope instead of by
// semantic context?
if (!Previous.empty() && TUK == TUK_Friend) {
DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext();
LookupResult::Filter F = Previous.makeFilter();
while (F.hasNext()) {
NamedDecl *ND = F.next();
DeclContext *DC = ND->getDeclContext()->getRedeclContext();
if (DC->isFileContext() && !EnclosingNS->Encloses(ND->getDeclContext()))
F.erase();
}
F.done();
}
// Note: there used to be some attempt at recovery here.
if (Previous.isAmbiguous())
return 0;
if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) {
// FIXME: This makes sure that we ignore the contexts associated
// with C structs, unions, and enums when looking for a matching
// tag declaration or definition. See the similar lookup tweak
// in Sema::LookupName; is there a better way to deal with this?
while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
SearchDC = SearchDC->getParent();
}
} else if (S->isFunctionPrototypeScope()) {
// If this is an enum declaration in function prototype scope, set its
// initial context to the translation unit.
// FIXME: [citation needed]
SearchDC = Context.getTranslationUnitDecl();
}
if (Previous.isSingleResult() &&
Previous.getFoundDecl()->isTemplateParameter()) {
// Maybe we will complain about the shadowed template parameter.
DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
// Just pretend that we didn't see the previous declaration.
Previous.clear();
}
if (getLangOpts().CPlusPlus && Name && DC && StdNamespace &&
DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) {
// This is a declaration of or a reference to "std::bad_alloc".
isStdBadAlloc = true;
if (Previous.empty() && StdBadAlloc) {
// std::bad_alloc has been implicitly declared (but made invisible to
// name lookup). Fill in this implicit declaration as the previous
// declaration, so that the declarations get chained appropriately.
Previous.addDecl(getStdBadAlloc());
}
}
// If we didn't find a previous declaration, and this is a reference
// (or friend reference), move to the correct scope. In C++, we
// also need to do a redeclaration lookup there, just in case
// there's a shadow friend decl.
if (Name && Previous.empty() &&
(TUK == TUK_Reference || TUK == TUK_Friend)) {
if (Invalid) goto CreateNewDecl;
assert(SS.isEmpty());
if (TUK == TUK_Reference) {
// C++ [basic.scope.pdecl]p5:
// -- for an elaborated-type-specifier of the form
//
// class-key identifier
//
// if the elaborated-type-specifier is used in the
// decl-specifier-seq or parameter-declaration-clause of a
// function defined in namespace scope, the identifier is
// declared as a class-name in the namespace that contains
// the declaration; otherwise, except as a friend
// declaration, the identifier is declared in the smallest
// non-class, non-function-prototype scope that contains the
// declaration.
//
// C99 6.7.2.3p8 has a similar (but not identical!) provision for
// C structs and unions.
//
// It is an error in C++ to declare (rather than define) an enum
// type, including via an elaborated type specifier. We'll
// diagnose that later; for now, declare the enum in the same
// scope as we would have picked for any other tag type.
//
// GNU C also supports this behavior as part of its incomplete
// enum types extension, while GNU C++ does not.
//
// Find the context where we'll be declaring the tag.
// FIXME: We would like to maintain the current DeclContext as the
// lexical context,
while (!SearchDC->isFileContext() && !SearchDC->isFunctionOrMethod())
SearchDC = SearchDC->getParent();
// Find the scope where we'll be declaring the tag.
while (S->isClassScope() ||
(getLangOpts().CPlusPlus &&
S->isFunctionPrototypeScope()) ||
((S->getFlags() & Scope::DeclScope) == 0) ||
(S->getEntity() &&
((DeclContext *)S->getEntity())->isTransparentContext()))
S = S->getParent();
} else {
assert(TUK == TUK_Friend);
// C++ [namespace.memdef]p3:
// If a friend declaration in a non-local class first declares a
// class or function, the friend class or function is a member of
// the innermost enclosing namespace.
SearchDC = SearchDC->getEnclosingNamespaceContext();
}
// In C++, we need to do a redeclaration lookup to properly
// diagnose some problems.
if (getLangOpts().CPlusPlus) {
Previous.setRedeclarationKind(ForRedeclaration);
LookupQualifiedName(Previous, SearchDC);
}
}
if (!Previous.empty()) {
NamedDecl *PrevDecl = (*Previous.begin())->getUnderlyingDecl();
// It's okay to have a tag decl in the same scope as a typedef
// which hides a tag decl in the same scope. Finding this
// insanity with a redeclaration lookup can only actually happen
// in C++.
//
// This is also okay for elaborated-type-specifiers, which is
// technically forbidden by the current standard but which is
// okay according to the likely resolution of an open issue;
// see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407
if (getLangOpts().CPlusPlus) {
if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) {
if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
TagDecl *Tag = TT->getDecl();
if (Tag->getDeclName() == Name &&
Tag->getDeclContext()->getRedeclContext()
->Equals(TD->getDeclContext()->getRedeclContext())) {
PrevDecl = Tag;
Previous.clear();
Previous.addDecl(Tag);
Previous.resolveKind();
}
}
}
}
if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
// If this is a use of a previous tag, or if the tag is already declared
// in the same scope (so that the definition/declaration completes or
// rementions the tag), reuse the decl.
if (TUK == TUK_Reference || TUK == TUK_Friend ||
isDeclInScope(PrevDecl, SearchDC, S, isExplicitSpecialization)) {
// Make sure that this wasn't declared as an enum and now used as a
// struct or something similar.
if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind,
TUK == TUK_Definition, KWLoc,
*Name)) {
bool SafeToContinue
= (PrevTagDecl->getTagKind() != TTK_Enum &&
Kind != TTK_Enum);
if (SafeToContinue)
Diag(KWLoc, diag::err_use_with_wrong_tag)
<< Name
<< FixItHint::CreateReplacement(SourceRange(KWLoc),
PrevTagDecl->getKindName());
else
Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
if (SafeToContinue)
Kind = PrevTagDecl->getTagKind();
else {
// Recover by making this an anonymous redefinition.
Name = 0;
Previous.clear();
Invalid = true;
}
}
if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) {
const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
// If this is an elaborated-type-specifier for a scoped enumeration,
// the 'class' keyword is not necessary and not permitted.
if (TUK == TUK_Reference || TUK == TUK_Friend) {
if (ScopedEnum)
Diag(ScopedEnumKWLoc, diag::err_enum_class_reference)
<< PrevEnum->isScoped()
<< FixItHint::CreateRemoval(ScopedEnumKWLoc);
return PrevTagDecl;
}
QualType EnumUnderlyingTy;
if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
EnumUnderlyingTy = TI->getType();
else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>())
EnumUnderlyingTy = QualType(T, 0);
// All conflicts with previous declarations are recovered by
// returning the previous declaration, unless this is a definition,
// in which case we want the caller to bail out.
if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc,
ScopedEnum, EnumUnderlyingTy, PrevEnum))
return TUK == TUK_Declaration ? PrevTagDecl : 0;
}
if (!Invalid) {
// If this is a use, just return the declaration we found.
// FIXME: In the future, return a variant or some other clue
// for the consumer of this Decl to know it doesn't own it.
// For our current ASTs this shouldn't be a problem, but will
// need to be changed with DeclGroups.
if ((TUK == TUK_Reference && (!PrevTagDecl->getFriendObjectKind() ||
getLangOpts().MicrosoftExt)) || TUK == TUK_Friend)
return PrevTagDecl;
// Diagnose attempts to redefine a tag.
if (TUK == TUK_Definition) {
if (TagDecl *Def = PrevTagDecl->getDefinition()) {
// If we're defining a specialization and the previous definition
// is from an implicit instantiation, don't emit an error
// here; we'll catch this in the general case below.
bool IsExplicitSpecializationAfterInstantiation = false;
if (isExplicitSpecialization) {
if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def))
IsExplicitSpecializationAfterInstantiation =
RD->getTemplateSpecializationKind() !=
TSK_ExplicitSpecialization;
else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def))
IsExplicitSpecializationAfterInstantiation =
ED->getTemplateSpecializationKind() !=
TSK_ExplicitSpecialization;
}
if (!IsExplicitSpecializationAfterInstantiation) {
// A redeclaration in function prototype scope in C isn't
// visible elsewhere, so merely issue a warning.
if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope())
Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
else
Diag(NameLoc, diag::err_redefinition) << Name;
Diag(Def->getLocation(), diag::note_previous_definition);
// If this is a redefinition, recover by making this
// struct be anonymous, which will make any later
// references get the previous definition.
Name = 0;
Previous.clear();
Invalid = true;
}
} else {
// If the type is currently being defined, complain
// about a nested redefinition.
const TagType *Tag
= cast<TagType>(Context.getTagDeclType(PrevTagDecl));
if (Tag->isBeingDefined()) {
Diag(NameLoc, diag::err_nested_redefinition) << Name;
Diag(PrevTagDecl->getLocation(),
diag::note_previous_definition);
Name = 0;
Previous.clear();
Invalid = true;
}
}
// Okay, this is definition of a previously declared or referenced
// tag PrevDecl. We're going to create a new Decl for it.
}
}
// If we get here we have (another) forward declaration or we
// have a definition. Just create a new decl.
} else {
// If we get here, this is a definition of a new tag type in a nested
// scope, e.g. "struct foo; void bar() { struct foo; }", just create a
// new decl/type. We set PrevDecl to NULL so that the entities
// have distinct types.
Previous.clear();
}
// If we get here, we're going to create a new Decl. If PrevDecl
// is non-NULL, it's a definition of the tag declared by
// PrevDecl. If it's NULL, we have a new definition.
// Otherwise, PrevDecl is not a tag, but was found with tag
// lookup. This is only actually possible in C++, where a few
// things like templates still live in the tag namespace.
} else {
// Use a better diagnostic if an elaborated-type-specifier
// found the wrong kind of type on the first
// (non-redeclaration) lookup.
if ((TUK == TUK_Reference || TUK == TUK_Friend) &&
!Previous.isForRedeclaration()) {
unsigned Kind = 0;
if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind;
Diag(PrevDecl->getLocation(), diag::note_declared_at);
Invalid = true;
// Otherwise, only diagnose if the declaration is in scope.
} else if (!isDeclInScope(PrevDecl, SearchDC, S,
isExplicitSpecialization)) {
// do nothing
// Diagnose implicit declarations introduced by elaborated types.
} else if (TUK == TUK_Reference || TUK == TUK_Friend) {
unsigned Kind = 0;
if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
Diag(NameLoc, diag::err_tag_reference_conflict) << Kind;
Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
Invalid = true;
// Otherwise it's a declaration. Call out a particularly common
// case here.
} else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
unsigned Kind = 0;
if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
Diag(NameLoc, diag::err_tag_definition_of_typedef)
<< Name << Kind << TND->getUnderlyingType();
Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
Invalid = true;
// Otherwise, diagnose.
} else {
// The tag name clashes with something else in the target scope,
// issue an error and recover by making this tag be anonymous.
Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
Diag(PrevDecl->getLocation(), diag::note_previous_definition);
Name = 0;
Invalid = true;
}
// The existing declaration isn't relevant to us; we're in a
// new scope, so clear out the previous declaration.
Previous.clear();
}
}
CreateNewDecl:
TagDecl *PrevDecl = 0;
if (Previous.isSingleResult())
PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
// If there is an identifier, use the location of the identifier as the
// location of the decl, otherwise use the location of the struct/union
// keyword.
SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
// Otherwise, create a new declaration. If there is a previous
// declaration of the same entity, the two will be linked via
// PrevDecl.
TagDecl *New;
bool IsForwardReference = false;
if (Kind == TTK_Enum) {
// FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
// enum X { A, B, C } D; D should chain to X.
New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name,
cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
ScopedEnumUsesClassTag, !EnumUnderlying.isNull());
// If this is an undefined enum, warn.
if (TUK != TUK_Definition && !Invalid) {
TagDecl *Def;
if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) &&
cast<EnumDecl>(New)->isFixed()) {
// C++0x: 7.2p2: opaque-enum-declaration.
// Conflicts are diagnosed above. Do nothing.
}
else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) {
Diag(Loc, diag::ext_forward_ref_enum_def)
<< New;
Diag(Def->getLocation(), diag::note_previous_definition);
} else {
unsigned DiagID = diag::ext_forward_ref_enum;
if (getLangOpts().MicrosoftMode)
DiagID = diag::ext_ms_forward_ref_enum;
else if (getLangOpts().CPlusPlus)
DiagID = diag::err_forward_ref_enum;
Diag(Loc, DiagID);
// If this is a forward-declared reference to an enumeration, make a
// note of it; we won't actually be introducing the declaration into
// the declaration context.
if (TUK == TUK_Reference)
IsForwardReference = true;
}
}
if (EnumUnderlying) {
EnumDecl *ED = cast<EnumDecl>(New);
if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
ED->setIntegerTypeSourceInfo(TI);
else
ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0));
ED->setPromotionType(ED->getIntegerType());
}
} else {
// struct/union/class
// FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
// struct X { int A; } D; D should chain to X.
if (getLangOpts().CPlusPlus) {
// FIXME: Look for a way to use RecordDecl for simple structs.
New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
cast_or_null<CXXRecordDecl>(PrevDecl));
if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit()))
StdBadAlloc = cast<CXXRecordDecl>(New);
} else
New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
cast_or_null<RecordDecl>(PrevDecl));
}
// Maybe add qualifier info.
if (SS.isNotEmpty()) {
if (SS.isSet()) {
// If this is either a declaration or a definition, check the
// nested-name-specifier against the current context. We don't do this
// for explicit specializations, because they have similar checking
// (with more specific diagnostics) in the call to
// CheckMemberSpecialization, below.
if (!isExplicitSpecialization &&
(TUK == TUK_Definition || TUK == TUK_Declaration) &&
diagnoseQualifiedDeclaration(SS, DC, OrigName, NameLoc))
Invalid = true;
New->setQualifierInfo(SS.getWithLocInContext(Context));
if (TemplateParameterLists.size() > 0) {
New->setTemplateParameterListsInfo(Context,
TemplateParameterLists.size(),
TemplateParameterLists.data());
}
}
else
Invalid = true;
}
if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
// Add alignment attributes if necessary; these attributes are checked when
// the ASTContext lays out the structure.
//
// It is important for implementing the correct semantics that this
// happen here (in act on tag decl). The #pragma pack stack is
// maintained as a result of parser callbacks which can occur at
// many points during the parsing of a struct declaration (because
// the #pragma tokens are effectively skipped over during the
// parsing of the struct).
if (TUK == TUK_Definition) {
AddAlignmentAttributesForRecord(RD);
AddMsStructLayoutForRecord(RD);
}
}
if (ModulePrivateLoc.isValid()) {
if (isExplicitSpecialization)
Diag(New->getLocation(), diag::err_module_private_specialization)
<< 2
<< FixItHint::CreateRemoval(ModulePrivateLoc);
// __module_private__ does not apply to local classes. However, we only
// diagnose this as an error when the declaration specifiers are
// freestanding. Here, we just ignore the __module_private__.
else if (!SearchDC->isFunctionOrMethod())
New->setModulePrivate();
}
// If this is a specialization of a member class (of a class template),
// check the specialization.
if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
Invalid = true;
if (Invalid)
New->setInvalidDecl();
if (Attr)
ProcessDeclAttributeList(S, New, Attr);
// If we're declaring or defining a tag in function prototype scope
// in C, note that this type can only be used within the function.
if (Name && S->isFunctionPrototypeScope() && !getLangOpts().CPlusPlus)
Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
// Set the lexical context. If the tag has a C++ scope specifier, the
// lexical context will be different from the semantic context.
New->setLexicalDeclContext(CurContext);
// Mark this as a friend decl if applicable.
// In Microsoft mode, a friend declaration also acts as a forward
// declaration so we always pass true to setObjectOfFriendDecl to make
// the tag name visible.
if (TUK == TUK_Friend)
New->setObjectOfFriendDecl(/* PreviouslyDeclared = */ !Previous.empty() ||
getLangOpts().MicrosoftExt);
// Set the access specifier.
if (!Invalid && SearchDC->isRecord())
SetMemberAccessSpecifier(New, PrevDecl, AS);
if (TUK == TUK_Definition)
New->startDefinition();
// If this has an identifier, add it to the scope stack.
if (TUK == TUK_Friend) {
// We might be replacing an existing declaration in the lookup tables;
// if so, borrow its access specifier.
if (PrevDecl)
New->setAccess(PrevDecl->getAccess());
DeclContext *DC = New->getDeclContext()->getRedeclContext();
DC->makeDeclVisibleInContext(New);
if (Name) // can be null along some error paths
if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
} else if (Name) {
S = getNonFieldDeclScope(S);
PushOnScopeChains(New, S, !IsForwardReference);
if (IsForwardReference)
SearchDC->makeDeclVisibleInContext(New);
} else {
CurContext->addDecl(New);
}
// If this is the C FILE type, notify the AST context.
if (IdentifierInfo *II = New->getIdentifier())
if (!New->isInvalidDecl() &&
New->getDeclContext()->getRedeclContext()->isTranslationUnit() &&
II->isStr("FILE"))
Context.setFILEDecl(New);
// If we were in function prototype scope (and not in C++ mode), add this
// tag to the list of decls to inject into the function definition scope.
if (S->isFunctionPrototypeScope() && !getLangOpts().CPlusPlus &&
InFunctionDeclarator && Name)
DeclsInPrototypeScope.push_back(New);
if (PrevDecl)
mergeDeclAttributes(New, PrevDecl);
// If there's a #pragma GCC visibility in scope, set the visibility of this
// record.
AddPushedVisibilityAttribute(New);
OwnedDecl = true;
// In C++, don't return an invalid declaration. We can't recover well from
// the cases where we make the type anonymous.
return (Invalid && getLangOpts().CPlusPlus) ? 0 : New;
}
void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) {
AdjustDeclIfTemplate(TagD);
TagDecl *Tag = cast<TagDecl>(TagD);
// Enter the tag context.
PushDeclContext(S, Tag);
ActOnDocumentableDecl(TagD);
// If there's a #pragma GCC visibility in scope, set the visibility of this
// record.
AddPushedVisibilityAttribute(Tag);
}
Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) {
assert(isa<ObjCContainerDecl>(IDecl) &&
"ActOnObjCContainerStartDefinition - Not ObjCContainerDecl");
DeclContext *OCD = cast<DeclContext>(IDecl);
assert(getContainingDC(OCD) == CurContext &&
"The next DeclContext should be lexically contained in the current one.");
CurContext = OCD;
return IDecl;
}
void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD,
SourceLocation FinalLoc,
SourceLocation LBraceLoc) {
AdjustDeclIfTemplate(TagD);
CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD);
FieldCollector->StartClass();
if (!Record->getIdentifier())
return;
if (FinalLoc.isValid())
Record->addAttr(new (Context) FinalAttr(FinalLoc, Context));
// C++ [class]p2:
// [...] The class-name is also inserted into the scope of the
// class itself; this is known as the injected-class-name. For
// purposes of access checking, the injected-class-name is treated
// as if it were a public member name.
CXXRecordDecl *InjectedClassName
= CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext,
Record->getLocStart(), Record->getLocation(),
Record->getIdentifier(),
/*PrevDecl=*/0,
/*DelayTypeCreation=*/true);
Context.getTypeDeclType(InjectedClassName, Record);
InjectedClassName->setImplicit();
InjectedClassName->setAccess(AS_public);
if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
InjectedClassName->setDescribedClassTemplate(Template);
PushOnScopeChains(InjectedClassName, S);
assert(InjectedClassName->isInjectedClassName() &&
"Broken injected-class-name");
}
void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD,
SourceLocation RBraceLoc) {
AdjustDeclIfTemplate(TagD);
TagDecl *Tag = cast<TagDecl>(TagD);
Tag->setRBraceLoc(RBraceLoc);
// Make sure we "complete" the definition even it is invalid.
if (Tag->isBeingDefined()) {
assert(Tag->isInvalidDecl() && "We should already have completed it");
if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
RD->completeDefinition();
}
if (isa<CXXRecordDecl>(Tag))
FieldCollector->FinishClass();
// Exit this scope of this tag's definition.
PopDeclContext();
if (getCurLexicalContext()->isObjCContainer() &&
Tag->getDeclContext()->isFileContext())
Tag->setTopLevelDeclInObjCContainer();
// Notify the consumer that we've defined a tag.
Consumer.HandleTagDeclDefinition(Tag);
}
void Sema::ActOnObjCContainerFinishDefinition() {
// Exit this scope of this interface definition.
PopDeclContext();
}
void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) {
assert(DC == CurContext && "Mismatch of container contexts");
OriginalLexicalContext = DC;
ActOnObjCContainerFinishDefinition();
}
void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) {
ActOnObjCContainerStartDefinition(cast<Decl>(DC));
OriginalLexicalContext = 0;
}
void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) {
AdjustDeclIfTemplate(TagD);
TagDecl *Tag = cast<TagDecl>(TagD);
Tag->setInvalidDecl();
// Make sure we "complete" the definition even it is invalid.
if (Tag->isBeingDefined()) {
if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
RD->completeDefinition();
}
// We're undoing ActOnTagStartDefinition here, not
// ActOnStartCXXMemberDeclarations, so we don't have to mess with
// the FieldCollector.
PopDeclContext();
}
// Note that FieldName may be null for anonymous bitfields.
ExprResult Sema::VerifyBitField(SourceLocation FieldLoc,
IdentifierInfo *FieldName,
QualType FieldTy, Expr *BitWidth,
bool *ZeroWidth) {
// Default to true; that shouldn't confuse checks for emptiness
if (ZeroWidth)
*ZeroWidth = true;
// C99 6.7.2.1p4 - verify the field type.
// C++ 9.6p3: A bit-field shall have integral or enumeration type.
if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) {
// Handle incomplete types with specific error.
if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
return ExprError();
if (FieldName)
return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
<< FieldName << FieldTy << BitWidth->getSourceRange();
return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
<< FieldTy << BitWidth->getSourceRange();
} else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth),
UPPC_BitFieldWidth))
return ExprError();
// If the bit-width is type- or value-dependent, don't try to check
// it now.
if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
return Owned(BitWidth);
llvm::APSInt Value;
ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value);
if (ICE.isInvalid())
return ICE;
BitWidth = ICE.take();
if (Value != 0 && ZeroWidth)
*ZeroWidth = false;
// Zero-width bitfield is ok for anonymous field.
if (Value == 0 && FieldName)
return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
if (Value.isSigned() && Value.isNegative()) {
if (FieldName)
return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
<< FieldName << Value.toString(10);
return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
<< Value.toString(10);
}
if (!FieldTy->isDependentType()) {
uint64_t TypeSize = Context.getTypeSize(FieldTy);
if (Value.getZExtValue() > TypeSize) {
if (!getLangOpts().CPlusPlus) {
if (FieldName)
return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
<< FieldName << (unsigned)Value.getZExtValue()
<< (unsigned)TypeSize;
return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
<< (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
}
if (FieldName)
Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size)
<< FieldName << (unsigned)Value.getZExtValue()
<< (unsigned)TypeSize;
else
Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size)
<< (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
}
}
return Owned(BitWidth);
}
/// ActOnField - Each field of a C struct/union is passed into this in order
/// to create a FieldDecl object for it.
Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
Declarator &D, Expr *BitfieldWidth) {
FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD),
DeclStart, D, static_cast<Expr*>(BitfieldWidth),
/*InitStyle=*/ICIS_NoInit, AS_public);
return Res;
}
/// HandleField - Analyze a field of a C struct or a C++ data member.
///
FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
SourceLocation DeclStart,
Declarator &D, Expr *BitWidth,
InClassInitStyle InitStyle,
AccessSpecifier AS) {
IdentifierInfo *II = D.getIdentifier();
SourceLocation Loc = DeclStart;
if (II) Loc = D.getIdentifierLoc();
TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
QualType T = TInfo->getType();
if (getLangOpts().CPlusPlus) {
CheckExtraCXXDefaultArguments(D);
if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
UPPC_DataMemberType)) {
D.setInvalidType();
T = Context.IntTy;
TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
}
}
// TR 18037 does not allow fields to be declared with address spaces.
if (T.getQualifiers().hasAddressSpace()) {
Diag(Loc, diag::err_field_with_address_space);
D.setInvalidType();
}
// OpenCL 1.2 spec, s6.9 r:
// The event type cannot be used to declare a structure or union field.
if (LangOpts.OpenCL && T->isEventT()) {
Diag(Loc, diag::err_event_t_struct_field);
D.setInvalidType();
}
DiagnoseFunctionSpecifiers(D.getDeclSpec());
if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
diag::err_invalid_thread)
<< DeclSpec::getSpecifierName(TSCS);
// Check to see if this name was declared as a member previously
NamedDecl *PrevDecl = 0;
LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration);
LookupName(Previous, S);
switch (Previous.getResultKind()) {
case LookupResult::Found:
case LookupResult::FoundUnresolvedValue:
PrevDecl = Previous.getAsSingle<NamedDecl>();
break;
case LookupResult::FoundOverloaded:
PrevDecl = Previous.getRepresentativeDecl();
break;
case LookupResult::NotFound:
case LookupResult::NotFoundInCurrentInstantiation:
case LookupResult::Ambiguous:
break;
}
Previous.suppressDiagnostics();
if (PrevDecl && PrevDecl->isTemplateParameter()) {
// Maybe we will complain about the shadowed template parameter.
DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
// Just pretend that we didn't see the previous declaration.
PrevDecl = 0;
}
if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
PrevDecl = 0;
bool Mutable
= (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
SourceLocation TSSL = D.getLocStart();
FieldDecl *NewFD
= CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle,
TSSL, AS, PrevDecl, &D);
if (NewFD->isInvalidDecl())
Record->setInvalidDecl();
if (D.getDeclSpec().isModulePrivateSpecified())
NewFD->setModulePrivate();
if (NewFD->isInvalidDecl() && PrevDecl) {
// Don't introduce NewFD into scope; there's already something
// with the same name in the same scope.
} else if (II) {
PushOnScopeChains(NewFD, S);
} else
Record->addDecl(NewFD);
return NewFD;
}
/// \brief Build a new FieldDecl and check its well-formedness.
///
/// This routine builds a new FieldDecl given the fields name, type,
/// record, etc. \p PrevDecl should refer to any previous declaration
/// with the same name and in the same scope as the field to be
/// created.
///
/// \returns a new FieldDecl.
///
/// \todo The Declarator argument is a hack. It will be removed once
FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
TypeSourceInfo *TInfo,
RecordDecl *Record, SourceLocation Loc,
bool Mutable, Expr *BitWidth,
InClassInitStyle InitStyle,
SourceLocation TSSL,
AccessSpecifier AS, NamedDecl *PrevDecl,
Declarator *D) {
IdentifierInfo *II = Name.getAsIdentifierInfo();
bool InvalidDecl = false;
if (D) InvalidDecl = D->isInvalidType();
// If we receive a broken type, recover by assuming 'int' and
// marking this declaration as invalid.
if (T.isNull()) {
InvalidDecl = true;
T = Context.IntTy;
}
QualType EltTy = Context.getBaseElementType(T);
if (!EltTy->isDependentType()) {
if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) {
// Fields of incomplete type force their record to be invalid.
Record->setInvalidDecl();
InvalidDecl = true;
} else {
NamedDecl *Def;
EltTy->isIncompleteType(&Def);
if (Def && Def->isInvalidDecl()) {
Record->setInvalidDecl();
InvalidDecl = true;
}
}
}
// OpenCL v1.2 s6.9.c: bitfields are not supported.
if (BitWidth && getLangOpts().OpenCL) {
Diag(Loc, diag::err_opencl_bitfields);
InvalidDecl = true;
}
// C99 6.7.2.1p8: A member of a structure or union may have any type other
// than a variably modified type.
if (!InvalidDecl && T->isVariablyModifiedType()) {
bool SizeIsNegative;
llvm::APSInt Oversized;
TypeSourceInfo *FixedTInfo =
TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
SizeIsNegative,
Oversized);
if (FixedTInfo) {
Diag(Loc, diag::warn_illegal_constant_array_size);
TInfo = FixedTInfo;
T = FixedTInfo->getType();
} else {
if (SizeIsNegative)
Diag(Loc, diag::err_typecheck_negative_array_size);
else if (Oversized.getBoolValue())
Diag(Loc, diag::err_array_too_large)
<< Oversized.toString(10);
else
Diag(Loc, diag::err_typecheck_field_variable_size);
InvalidDecl = true;
}
}
// Fields can not have abstract class types
if (!InvalidDecl && RequireNonAbstractType(Loc, T,
diag::err_abstract_type_in_decl,
AbstractFieldType))
InvalidDecl = true;
bool ZeroWidth = false;
// If this is declared as a bit-field, check the bit-field.
if (!InvalidDecl && BitWidth) {
BitWidth = VerifyBitField(Loc, II, T, BitWidth, &ZeroWidth).take();
if (!BitWidth) {
InvalidDecl = true;
BitWidth = 0;
ZeroWidth = false;
}
}
// Check that 'mutable' is consistent with the type of the declaration.
if (!InvalidDecl && Mutable) {
unsigned DiagID = 0;
if (T->isReferenceType())
DiagID = diag::err_mutable_reference;
else if (T.isConstQualified())
DiagID = diag::err_mutable_const;
if (DiagID) {
SourceLocation ErrLoc = Loc;
if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid())
ErrLoc = D->getDeclSpec().getStorageClassSpecLoc();
Diag(ErrLoc, DiagID);
Mutable = false;
InvalidDecl = true;
}
}
FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
BitWidth, Mutable, InitStyle);
if (InvalidDecl)
NewFD->setInvalidDecl();
if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
Diag(Loc, diag::err_duplicate_member) << II;
Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
NewFD->setInvalidDecl();
}
if (!InvalidDecl && getLangOpts().CPlusPlus) {
if (Record->isUnion()) {
if (const RecordType *RT = EltTy->getAs<RecordType>()) {
CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
if (RDecl->getDefinition()) {
// C++ [class.union]p1: An object of a class with a non-trivial
// constructor, a non-trivial copy constructor, a non-trivial
// destructor, or a non-trivial copy assignment operator
// cannot be a member of a union, nor can an array of such
// objects.
if (CheckNontrivialField(NewFD))
NewFD->setInvalidDecl();
}
}
// C++ [class.union]p1: If a union contains a member of reference type,
// the program is ill-formed.
if (EltTy->isReferenceType()) {
Diag(NewFD->getLocation(), diag::err_union_member_of_reference_type)
<< NewFD->getDeclName() << EltTy;
NewFD->setInvalidDecl();
}
}
}
// FIXME: We need to pass in the attributes given an AST
// representation, not a parser representation.
if (D) {
// FIXME: The current scope is almost... but not entirely... correct here.
ProcessDeclAttributes(getCurScope(), NewFD, *D);
if (NewFD->hasAttrs())
CheckAlignasUnderalignment(NewFD);
}
// In auto-retain/release, infer strong retension for fields of
// retainable type.
if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD))
NewFD->setInvalidDecl();
if (T.isObjCGCWeak())
Diag(Loc, diag::warn_attribute_weak_on_field);
NewFD->setAccess(AS);
return NewFD;
}
bool Sema::CheckNontrivialField(FieldDecl *FD) {
assert(FD);
assert(getLangOpts().CPlusPlus && "valid check only for C++");
if (FD->isInvalidDecl())
return true;
QualType EltTy = Context.getBaseElementType(FD->getType());
if (const RecordType *RT = EltTy->getAs<RecordType>()) {
CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl());
if (RDecl->getDefinition()) {
// We check for copy constructors before constructors
// because otherwise we'll never get complaints about
// copy constructors.
CXXSpecialMember member = CXXInvalid;
// We're required to check for any non-trivial constructors. Since the
// implicit default constructor is suppressed if there are any
// user-declared constructors, we just need to check that there is a
// trivial default constructor and a trivial copy constructor. (We don't
// worry about move constructors here, since this is a C++98 check.)
if (RDecl->hasNonTrivialCopyConstructor())
member = CXXCopyConstructor;
else if (!RDecl->hasTrivialDefaultConstructor())
member = CXXDefaultConstructor;
else if (RDecl->hasNonTrivialCopyAssignment())
member = CXXCopyAssignment;
else if (RDecl->hasNonTrivialDestructor())
member = CXXDestructor;
if (member != CXXInvalid) {
if (!getLangOpts().CPlusPlus11 &&
getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) {
// Objective-C++ ARC: it is an error to have a non-trivial field of
// a union. However, system headers in Objective-C programs
// occasionally have Objective-C lifetime objects within unions,
// and rather than cause the program to fail, we make those
// members unavailable.
SourceLocation Loc = FD->getLocation();
if (getSourceManager().isInSystemHeader(Loc)) {
if (!FD->hasAttr<UnavailableAttr>())
FD->addAttr(new (Context) UnavailableAttr(Loc, Context,
"this system field has retaining ownership"));
return false;
}
}
Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ?
diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member :
diag::err_illegal_union_or_anon_struct_member)
<< (int)FD->getParent()->isUnion() << FD->getDeclName() << member;
DiagnoseNontrivial(RDecl, member);
return !getLangOpts().CPlusPlus11;
}
}
}
return false;
}
/// TranslateIvarVisibility - Translate visibility from a token ID to an
/// AST enum value.
static ObjCIvarDecl::AccessControl
TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
switch (ivarVisibility) {
default: llvm_unreachable("Unknown visitibility kind");
case tok::objc_private: return ObjCIvarDecl::Private;
case tok::objc_public: return ObjCIvarDecl::Public;
case tok::objc_protected: return ObjCIvarDecl::Protected;
case tok::objc_package: return ObjCIvarDecl::Package;
}
}
/// ActOnIvar - Each ivar field of an objective-c class is passed into this
/// in order to create an IvarDecl object for it.
Decl *Sema::ActOnIvar(Scope *S,
SourceLocation DeclStart,
Declarator &D, Expr *BitfieldWidth,
tok::ObjCKeywordKind Visibility) {
IdentifierInfo *II = D.getIdentifier();
Expr *BitWidth = (Expr*)BitfieldWidth;
SourceLocation Loc = DeclStart;
if (II) Loc = D.getIdentifierLoc();
// FIXME: Unnamed fields can be handled in various different ways, for
// example, unnamed unions inject all members into the struct namespace!
TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
QualType T = TInfo->getType();
if (BitWidth) {
// 6.7.2.1p3, 6.7.2.1p4
BitWidth = VerifyBitField(Loc, II, T, BitWidth).take();
if (!BitWidth)
D.setInvalidType();
} else {
// Not a bitfield.
// validate II.
}
if (T->isReferenceType()) {
Diag(Loc, diag::err_ivar_reference_type);
D.setInvalidType();
}
// C99 6.7.2.1p8: A member of a structure or union may have any type other
// than a variably modified type.
else if (T->isVariablyModifiedType()) {
Diag(Loc, diag::err_typecheck_ivar_variable_size);
D.setInvalidType();
}
// Get the visibility (access control) for this ivar.
ObjCIvarDecl::AccessControl ac =
Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
: ObjCIvarDecl::None;
// Must set ivar's DeclContext to its enclosing interface.
ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext);
if (!EnclosingDecl || EnclosingDecl->isInvalidDecl())
return 0;
ObjCContainerDecl *EnclosingContext;
if (ObjCImplementationDecl *IMPDecl =
dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
if (LangOpts.ObjCRuntime.isFragile()) {
// Case of ivar declared in an implementation. Context is that of its class.
EnclosingContext = IMPDecl->getClassInterface();
assert(EnclosingContext && "Implementation has no class interface!");
}
else
EnclosingContext = EnclosingDecl;
} else {
if (ObjCCategoryDecl *CDecl =
dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) {
Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
return 0;
}
}
EnclosingContext = EnclosingDecl;
}
// Construct the decl.
ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext,
DeclStart, Loc, II, T,
TInfo, ac, (Expr *)BitfieldWidth);
if (II) {
NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
ForRedeclaration);
if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
&& !isa<TagDecl>(PrevDecl)) {
Diag(Loc, diag::err_duplicate_member) << II;
Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
NewID->setInvalidDecl();
}
}
// Process attributes attached to the ivar.
ProcessDeclAttributes(S, NewID, D);
if (D.isInvalidType())
NewID->setInvalidDecl();
// In ARC, infer 'retaining' for ivars of retainable type.
if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID))
NewID->setInvalidDecl();
if (D.getDeclSpec().isModulePrivateSpecified())
NewID->setModulePrivate();
if (II) {
// FIXME: When interfaces are DeclContexts, we'll need to add
// these to the interface.
S->AddDecl(NewID);
IdResolver.AddDecl(NewID);
}
if (LangOpts.ObjCRuntime.isNonFragile() &&
!NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
Diag(Loc, diag::warn_ivars_in_interface);
return NewID;
}
/// ActOnLastBitfield - This routine handles synthesized bitfields rules for
/// class and class extensions. For every class \@interface and class
/// extension \@interface, if the last ivar is a bitfield of any type,
/// then add an implicit `char :0` ivar to the end of that interface.
void Sema::ActOnLastBitfield(SourceLocation DeclLoc,
SmallVectorImpl<Decl *> &AllIvarDecls) {
if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty())
return;
Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl);
if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0)
return;
ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext);
if (!ID) {
if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) {
if (!CD->IsClassExtension())
return;
}
// No need to add this to end of @implementation.
else
return;
}
// All conditions are met. Add a new bitfield to the tail end of ivars.
llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0);
Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc);
Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext),
DeclLoc, DeclLoc, 0,
Context.CharTy,
Context.getTrivialTypeSourceInfo(Context.CharTy,
DeclLoc),
ObjCIvarDecl::Private, BW,
true);
AllIvarDecls.push_back(Ivar);
}
void Sema::ActOnFields(Scope* S,
SourceLocation RecLoc, Decl *EnclosingDecl,
llvm::ArrayRef<Decl *> Fields,
SourceLocation LBrac, SourceLocation RBrac,
AttributeList *Attr) {
assert(EnclosingDecl && "missing record or interface decl");
// If this is an Objective-C @implementation or category and we have
// new fields here we should reset the layout of the interface since
// it will now change.
if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl);
switch (DC->getKind()) {
default: break;
case Decl::ObjCCategory:
Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface());
break;
case Decl::ObjCImplementation:
Context.
ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
break;
}
}
RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
// Start counting up the number of named members; make sure to include
// members of anonymous structs and unions in the total.
unsigned NumNamedMembers = 0;
if (Record) {
for (RecordDecl::decl_iterator i = Record->decls_begin(),
e = Record->decls_end(); i != e; i++) {
if (IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(*i))
if (IFD->getDeclName())
++NumNamedMembers;
}
}
// Verify that all the fields are okay.
SmallVector<FieldDecl*, 32> RecFields;
bool ARCErrReported = false;
for (llvm::ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end();
i != end; ++i) {
FieldDecl *FD = cast<FieldDecl>(*i);
// Get the type for the field.
const Type *FDTy = FD->getType().getTypePtr();
if (!FD->isAnonymousStructOrUnion()) {
// Remember all fields written by the user.
RecFields.push_back(FD);
}
// If the field is already invalid for some reason, don't emit more
// diagnostics about it.
if (FD->isInvalidDecl()) {
EnclosingDecl->setInvalidDecl();
continue;
}
// C99 6.7.2.1p2:
// A structure or union shall not contain a member with
// incomplete or function type (hence, a structure shall not
// contain an instance of itself, but may contain a pointer to
// an instance of itself), except that the last member of a
// structure with more than one named member may have incomplete
// array type; such a structure (and any union containing,
// possibly recursively, a member that is such a structure)
// shall not be a member of a structure or an element of an
// array.
if (FDTy->isFunctionType()) {
// Field declared as a function.
Diag(FD->getLocation(), diag::err_field_declared_as_function)
<< FD->getDeclName();
FD->setInvalidDecl();
EnclosingDecl->setInvalidDecl();
continue;
} else if (FDTy->isIncompleteArrayType() && Record &&
((i + 1 == Fields.end() && !Record->isUnion()) ||
((getLangOpts().MicrosoftExt ||
getLangOpts().CPlusPlus) &&
(i + 1 == Fields.end() || Record->isUnion())))) {
// Flexible array member.
// Microsoft and g++ is more permissive regarding flexible array.
// It will accept flexible array in union and also
// as the sole element of a struct/class.
if (getLangOpts().MicrosoftExt) {
if (Record->isUnion())
Diag(FD->getLocation(), diag::ext_flexible_array_union_ms)
<< FD->getDeclName();
else if (Fields.size() == 1)
Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_ms)
<< FD->getDeclName() << Record->getTagKind();
} else if (getLangOpts().CPlusPlus) {
if (Record->isUnion())
Diag(FD->getLocation(), diag::ext_flexible_array_union_gnu)
<< FD->getDeclName();
else if (Fields.size() == 1)
Diag(FD->getLocation(), diag::ext_flexible_array_empty_aggregate_gnu)
<< FD->getDeclName() << Record->getTagKind();
} else if (!getLangOpts().C99) {
if (Record->isUnion())
Diag(FD->getLocation(), diag::ext_flexible_array_union_gnu)
<< FD->getDeclName();
else
Diag(FD->getLocation(), diag::ext_c99_flexible_array_member)
<< FD->getDeclName() << Record->getTagKind();
} else if (NumNamedMembers < 1) {
Diag(FD->getLocation(), diag::err_flexible_array_empty_struct)
<< FD->getDeclName();
FD->setInvalidDecl();
EnclosingDecl->setInvalidDecl();
continue;
}
if (!FD->getType()->isDependentType() &&
!Context.getBaseElementType(FD->getType()).isPODType(Context)) {
Diag(FD->getLocation(), diag::err_flexible_array_has_nonpod_type)
<< FD->getDeclName() << FD->getType();
FD->setInvalidDecl();
EnclosingDecl->setInvalidDecl();
continue;
}
// Okay, we have a legal flexible array member at the end of the struct.
if (Record)
Record->setHasFlexibleArrayMember(true);
} else if (!FDTy->isDependentType() &&
RequireCompleteType(FD->getLocation(), FD->getType(),
diag::err_field_incomplete)) {
// Incomplete type
FD->setInvalidDecl();
EnclosingDecl->setInvalidDecl();
continue;
} else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
// If this is a member of a union, then entire union becomes "flexible".
if (Record && Record->isUnion()) {
Record->setHasFlexibleArrayMember(true);
} else {
// If this is a struct/class and this is not the last element, reject
// it. Note that GCC supports variable sized arrays in the middle of
// structures.
if (i + 1 != Fields.end())
Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
<< FD->getDeclName() << FD->getType();
else {
// We support flexible arrays at the end of structs in
// other structs as an extension.
Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
<< FD->getDeclName();
if (Record)
Record->setHasFlexibleArrayMember(true);
}
}
}
if (isa<ObjCContainerDecl>(EnclosingDecl) &&
RequireNonAbstractType(FD->getLocation(), FD->getType(),
diag::err_abstract_type_in_decl,
AbstractIvarType)) {
// Ivars can not have abstract class types
FD->setInvalidDecl();
}
if (Record && FDTTy->getDecl()->hasObjectMember())
Record->setHasObjectMember(true);
if (Record && FDTTy->getDecl()->hasVolatileMember())
Record->setHasVolatileMember(true);
} else if (FDTy->isObjCObjectType()) {
/// A field cannot be an Objective-c object
Diag(FD->getLocation(), diag::err_statically_allocated_object)
<< FixItHint::CreateInsertion(FD->getLocation(), "*");
QualType T = Context.getObjCObjectPointerType(FD->getType());
FD->setType(T);
} else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported &&
(!getLangOpts().CPlusPlus || Record->isUnion())) {
// It's an error in ARC if a field has lifetime.
// We don't want to report this in a system header, though,
// so we just make the field unavailable.
// FIXME: that's really not sufficient; we need to make the type
// itself invalid to, say, initialize or copy.
QualType T = FD->getType();
Qualifiers::ObjCLifetime lifetime = T.getObjCLifetime();
if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) {
SourceLocation loc = FD->getLocation();
if (getSourceManager().isInSystemHeader(loc)) {
if (!FD->hasAttr<UnavailableAttr>()) {
FD->addAttr(new (Context) UnavailableAttr(loc, Context,
"this system field has retaining ownership"));
}
} else {
Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag)
<< T->isBlockPointerType() << Record->getTagKind();
}
ARCErrReported = true;
}
} else if (getLangOpts().ObjC1 &&
getLangOpts().getGC() != LangOptions::NonGC &&
Record && !Record->hasObjectMember()) {
if (FD->getType()->isObjCObjectPointerType() ||
FD->getType().isObjCGCStrong())
Record->setHasObjectMember(true);
else if (Context.getAsArrayType(FD->getType())) {
QualType BaseType = Context.getBaseElementType(FD->getType());
if (BaseType->isRecordType() &&
BaseType->getAs<RecordType>()->getDecl()->hasObjectMember())
Record->setHasObjectMember(true);
else if (BaseType->isObjCObjectPointerType() ||
BaseType.isObjCGCStrong())
Record->setHasObjectMember(true);
}
}
if (Record && FD->getType().isVolatileQualified())
Record->setHasVolatileMember(true);
// Keep track of the number of named members.
if (FD->getIdentifier())
++NumNamedMembers;
}
// Okay, we successfully defined 'Record'.
if (Record) {
bool Completed = false;
if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
if (!CXXRecord->isInvalidDecl()) {
// Set access bits correctly on the directly-declared conversions.
for (CXXRecordDecl::conversion_iterator
I = CXXRecord->conversion_begin(),
E = CXXRecord->conversion_end(); I != E; ++I)
I.setAccess((*I)->getAccess());
if (!CXXRecord->isDependentType()) {
// Adjust user-defined destructor exception spec.
if (getLangOpts().CPlusPlus11 &&
CXXRecord->hasUserDeclaredDestructor())
AdjustDestructorExceptionSpec(CXXRecord,CXXRecord->getDestructor());
// Add any implicitly-declared members to this class.
AddImplicitlyDeclaredMembersToClass(CXXRecord);
// If we have virtual base classes, we may end up finding multiple
// final overriders for a given virtual function. Check for this
// problem now.
if (CXXRecord->getNumVBases()) {
CXXFinalOverriderMap FinalOverriders;
CXXRecord->getFinalOverriders(FinalOverriders);
for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
MEnd = FinalOverriders.end();
M != MEnd; ++M) {
for (OverridingMethods::iterator SO = M->second.begin(),
SOEnd = M->second.end();
SO != SOEnd; ++SO) {
assert(SO->second.size() > 0 &&
"Virtual function without overridding functions?");
if (SO->second.size() == 1)
continue;
// C++ [class.virtual]p2:
// In a derived class, if a virtual member function of a base
// class subobject has more than one final overrider the
// program is ill-formed.
Diag(Record->getLocation(), diag::err_multiple_final_overriders)
<< (const NamedDecl *)M->first << Record;
Diag(M->first->getLocation(),
diag::note_overridden_virtual_function);
for (OverridingMethods::overriding_iterator
OM = SO->second.begin(),
OMEnd = SO->second.end();
OM != OMEnd; ++OM)
Diag(OM->Method->getLocation(), diag::note_final_overrider)
<< (const NamedDecl *)M->first << OM->Method->getParent();
Record->setInvalidDecl();
}
}
CXXRecord->completeDefinition(&FinalOverriders);
Completed = true;
}
}
}
}
if (!Completed)
Record->completeDefinition();
if (Record->hasAttrs())
CheckAlignasUnderalignment(Record);
} else {
ObjCIvarDecl **ClsFields =
reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
ID->setEndOfDefinitionLoc(RBrac);
// Add ivar's to class's DeclContext.
for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
ClsFields[i]->setLexicalDeclContext(ID);
ID->addDecl(ClsFields[i]);
}
// Must enforce the rule that ivars in the base classes may not be
// duplicates.
if (ID->getSuperClass())
DiagnoseDuplicateIvars(ID, ID->getSuperClass());
} else if (ObjCImplementationDecl *IMPDecl =
dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
// Ivar declared in @implementation never belongs to the implementation.
// Only it is in implementation's lexical context.
ClsFields[I]->setLexicalDeclContext(IMPDecl);
CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
IMPDecl->setIvarLBraceLoc(LBrac);
IMPDecl->setIvarRBraceLoc(RBrac);
} else if (ObjCCategoryDecl *CDecl =
dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
// case of ivars in class extension; all other cases have been
// reported as errors elsewhere.
// FIXME. Class extension does not have a LocEnd field.
// CDecl->setLocEnd(RBrac);
// Add ivar's to class extension's DeclContext.
// Diagnose redeclaration of private ivars.
ObjCInterfaceDecl *IDecl = CDecl->getClassInterface();
for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
if (IDecl) {
if (const ObjCIvarDecl *ClsIvar =
IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) {
Diag(ClsFields[i]->getLocation(),
diag::err_duplicate_ivar_declaration);
Diag(ClsIvar->getLocation(), diag::note_previous_definition);
continue;
}
for (ObjCInterfaceDecl::known_extensions_iterator
Ext = IDecl->known_extensions_begin(),
ExtEnd = IDecl->known_extensions_end();
Ext != ExtEnd; ++Ext) {
if (const ObjCIvarDecl *ClsExtIvar
= Ext->getIvarDecl(ClsFields[i]->getIdentifier())) {
Diag(ClsFields[i]->getLocation(),
diag::err_duplicate_ivar_declaration);
Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
continue;
}
}
}
ClsFields[i]->setLexicalDeclContext(CDecl);
CDecl->addDecl(ClsFields[i]);
}
CDecl->setIvarLBraceLoc(LBrac);
CDecl->setIvarRBraceLoc(RBrac);
}
}
if (Attr)
ProcessDeclAttributeList(S, Record, Attr);
}
/// \brief Determine whether the given integral value is representable within
/// the given type T.
static bool isRepresentableIntegerValue(ASTContext &Context,
llvm::APSInt &Value,
QualType T) {
assert(T->isIntegralType(Context) && "Integral type required!");
unsigned BitWidth = Context.getIntWidth(T);
if (Value.isUnsigned() || Value.isNonNegative()) {
if (T->isSignedIntegerOrEnumerationType())
--BitWidth;
return Value.getActiveBits() <= BitWidth;
}
return Value.getMinSignedBits() <= BitWidth;
}
// \brief Given an integral type, return the next larger integral type
// (or a NULL type of no such type exists).
static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) {
// FIXME: Int128/UInt128 support, which also needs to be introduced into
// enum checking below.
assert(T->isIntegralType(Context) && "Integral type required!");
const unsigned NumTypes = 4;
QualType SignedIntegralTypes[NumTypes] = {
Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
};
QualType UnsignedIntegralTypes[NumTypes] = {
Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
Context.UnsignedLongLongTy
};
unsigned BitWidth = Context.getTypeSize(T);
QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes
: UnsignedIntegralTypes;
for (unsigned I = 0; I != NumTypes; ++I)
if (Context.getTypeSize(Types[I]) > BitWidth)
return Types[I];
return QualType();
}
EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
EnumConstantDecl *LastEnumConst,
SourceLocation IdLoc,
IdentifierInfo *Id,
Expr *Val) {
unsigned IntWidth = Context.getTargetInfo().getIntWidth();
llvm::APSInt EnumVal(IntWidth);
QualType EltTy;
if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue))
Val = 0;
if (Val)
Val = DefaultLvalueConversion(Val).take();
if (Val) {
if (Enum->isDependentType() || Val->isTypeDependent())
EltTy = Context.DependentTy;
else {
SourceLocation ExpLoc;
if (getLangOpts().CPlusPlus11 && Enum->isFixed() &&
!getLangOpts().MicrosoftMode) {
// C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the
// constant-expression in the enumerator-definition shall be a converted
// constant expression of the underlying type.
EltTy = Enum->getIntegerType();
ExprResult Converted =
CheckConvertedConstantExpression(Val, EltTy, EnumVal,
CCEK_Enumerator);
if (Converted.isInvalid())
Val = 0;
else
Val = Converted.take();
} else if (!Val->isValueDependent() &&
!(Val = VerifyIntegerConstantExpression(Val,
&EnumVal).take())) {
// C99 6.7.2.2p2: Make sure we have an integer constant expression.
} else {
if (Enum->isFixed()) {
EltTy = Enum->getIntegerType();
// In Obj-C and Microsoft mode, require the enumeration value to be
// representable in the underlying type of the enumeration. In C++11,
// we perform a non-narrowing conversion as part of converted constant
// expression checking.
if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
if (getLangOpts().MicrosoftMode) {
Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take();
} else
Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
} else
Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).take();
} else if (getLangOpts().CPlusPlus) {
// C++11 [dcl.enum]p5:
// If the underlying type is not fixed, the type of each enumerator
// is the type of its initializing value:
// - If an initializer is specified for an enumerator, the
// initializing value has the same type as the expression.
EltTy = Val->getType();
} else {
// C99 6.7.2.2p2:
// The expression that defines the value of an enumeration constant
// shall be an integer constant expression that has a value
// representable as an int.
// Complain if the value is not representable in an int.
if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy))
Diag(IdLoc, diag::ext_enum_value_not_int)
<< EnumVal.toString(10) << Val->getSourceRange()
<< (EnumVal.isUnsigned() || EnumVal.isNonNegative());
else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
// Force the type of the expression to 'int'.
Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).take();
}
EltTy = Val->getType();
}
}
}
}
if (!Val) {
if (Enum->isDependentType())
EltTy = Context.DependentTy;
else if (!LastEnumConst) {
// C++0x [dcl.enum]p5:
// If the underlying type is not fixed, the type of each enumerator
// is the type of its initializing value:
// - If no initializer is specified for the first enumerator, the
// initializing value has an unspecified integral type.
//
// GCC uses 'int' for its unspecified integral type, as does
// C99 6.7.2.2p3.
if (Enum->isFixed()) {
EltTy = Enum->getIntegerType();
}
else {
EltTy = Context.IntTy;
}
} else {
// Assign the last value + 1.
EnumVal = LastEnumConst->getInitVal();
++EnumVal;
EltTy = LastEnumConst->getType();
// Check for overflow on increment.
if (EnumVal < LastEnumConst->getInitVal()) {
// C++0x [dcl.enum]p5:
// If the underlying type is not fixed, the type of each enumerator
// is the type of its initializing value:
//
// - Otherwise the type of the initializing value is the same as
// the type of the initializing value of the preceding enumerator
// unless the incremented value is not representable in that type,
// in which case the type is an unspecified integral type
// sufficient to contain the incremented value. If no such type
// exists, the program is ill-formed.
QualType T = getNextLargerIntegralType(Context, EltTy);
if (T.isNull() || Enum->isFixed()) {
// There is no integral type larger enough to represent this
// value. Complain, then allow the value to wrap around.
EnumVal = LastEnumConst->getInitVal();
EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
++EnumVal;
if (Enum->isFixed())
// When the underlying type is fixed, this is ill-formed.
Diag(IdLoc, diag::err_enumerator_wrapped)
<< EnumVal.toString(10)
<< EltTy;
else
Diag(IdLoc, diag::warn_enumerator_too_large)
<< EnumVal.toString(10);
} else {
EltTy = T;
}
// Retrieve the last enumerator's value, extent that type to the
// type that is supposed to be large enough to represent the incremented
// value, then increment.
EnumVal = LastEnumConst->getInitVal();
EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
++EnumVal;
// If we're not in C++, diagnose the overflow of enumerator values,
// which in C99 means that the enumerator value is not representable in
// an int (C99 6.7.2.2p2). However, we support GCC's extension that
// permits enumerator values that are representable in some larger
// integral type.
if (!getLangOpts().CPlusPlus && !T.isNull())
Diag(IdLoc, diag::warn_enum_value_overflow);
} else if (!getLangOpts().CPlusPlus &&
!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
// Enforce C99 6.7.2.2p2 even when we compute the next value.
Diag(IdLoc, diag::ext_enum_value_not_int)
<< EnumVal.toString(10) << 1;
}
}
}
if (!EltTy->isDependentType()) {
// Make the enumerator value match the signedness and size of the
// enumerator's type.
EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy));
EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
}
return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
Val, EnumVal);
}
Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst,
SourceLocation IdLoc, IdentifierInfo *Id,
AttributeList *Attr,
SourceLocation EqualLoc, Expr *Val) {
EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
EnumConstantDecl *LastEnumConst =
cast_or_null<EnumConstantDecl>(lastEnumConst);
// The scope passed in may not be a decl scope. Zip up the scope tree until
// we find one that is.
S = getNonFieldDeclScope(S);
// Verify that there isn't already something declared with this name in this
// scope.
NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName,
ForRedeclaration);
if (PrevDecl && PrevDecl->isTemplateParameter()) {
// Maybe we will complain about the shadowed template parameter.
DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
// Just pretend that we didn't see the previous declaration.
PrevDecl = 0;
}
if (PrevDecl) {
// When in C++, we may get a TagDecl with the same name; in this case the
// enum constant will 'hide' the tag.
assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
"Received TagDecl when not in C++!");
if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
if (isa<EnumConstantDecl>(PrevDecl))
Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
else
Diag(IdLoc, diag::err_redefinition) << Id;
Diag(PrevDecl->getLocation(), diag::note_previous_definition);
return 0;
}
}
// C++ [class.mem]p15:
// If T is the name of a class, then each of the following shall have a name
// different from T:
// - every enumerator of every member of class T that is an unscoped
// enumerated type
if (CXXRecordDecl *Record
= dyn_cast<CXXRecordDecl>(
TheEnumDecl->getDeclContext()->getRedeclContext()))
if (!TheEnumDecl->isScoped() &&
Record->getIdentifier() && Record->getIdentifier() == Id)
Diag(IdLoc, diag::err_member_name_of_class) << Id;
EnumConstantDecl *New =
CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val);
if (New) {
// Process attributes.
if (Attr) ProcessDeclAttributeList(S, New, Attr);
// Register this decl in the current scope stack.
New->setAccess(TheEnumDecl->getAccess());
PushOnScopeChains(New, S);
}
ActOnDocumentableDecl(New);
return New;
}
// Returns true when the enum initial expression does not trigger the
// duplicate enum warning. A few common cases are exempted as follows:
// Element2 = Element1
// Element2 = Element1 + 1
// Element2 = Element1 - 1
// Where Element2 and Element1 are from the same enum.
static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) {
Expr *InitExpr = ECD->getInitExpr();
if (!InitExpr)
return true;
InitExpr = InitExpr->IgnoreImpCasts();
if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) {
if (!BO->isAdditiveOp())
return true;
IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS());
if (!IL)
return true;
if (IL->getValue() != 1)
return true;
InitExpr = BO->getLHS();
}
// This checks if the elements are from the same enum.
DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
if (!DRE)
return true;
EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl());
if (!EnumConstant)
return true;
if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) !=
Enum)
return true;
return false;
}
struct DupKey {
int64_t val;
bool isTombstoneOrEmptyKey;
DupKey(int64_t val, bool isTombstoneOrEmptyKey)
: val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {}
};
static DupKey GetDupKey(const llvm::APSInt& Val) {
return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(),
false);
}
struct DenseMapInfoDupKey {
static DupKey getEmptyKey() { return DupKey(0, true); }
static DupKey getTombstoneKey() { return DupKey(1, true); }
static unsigned getHashValue(const DupKey Key) {
return (unsigned)(Key.val * 37);
}
static bool isEqual(const DupKey& LHS, const DupKey& RHS) {
return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey &&
LHS.val == RHS.val;
}
};
// Emits a warning when an element is implicitly set a value that
// a previous element has already been set to.
static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements,
EnumDecl *Enum,
QualType EnumType) {
if (S.Diags.getDiagnosticLevel(diag::warn_duplicate_enum_values,
Enum->getLocation()) ==
DiagnosticsEngine::Ignored)
return;
// Avoid anonymous enums
if (!Enum->getIdentifier())
return;
// Only check for small enums.
if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64)
return;
typedef SmallVector<EnumConstantDecl *, 3> ECDVector;
typedef SmallVector<ECDVector *, 3> DuplicatesVector;
typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey>
ValueToVectorMap;
DuplicatesVector DupVector;
ValueToVectorMap EnumMap;
// Populate the EnumMap with all values represented by enum constants without
// an initialier.
for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]);
// Null EnumConstantDecl means a previous diagnostic has been emitted for
// this constant. Skip this enum since it may be ill-formed.
if (!ECD) {
return;
}
if (ECD->getInitExpr())
continue;
DupKey Key = GetDupKey(ECD->getInitVal());
DeclOrVector &Entry = EnumMap[Key];
// First time encountering this value.
if (Entry.isNull())
Entry = ECD;
}
// Create vectors for any values that has duplicates.
for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]);
if (!ValidDuplicateEnum(ECD, Enum))
continue;
DupKey Key = GetDupKey(ECD->getInitVal());
DeclOrVector& Entry = EnumMap[Key];
if (Entry.isNull())
continue;
if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) {
// Ensure constants are different.
if (D == ECD)
continue;
// Create new vector and push values onto it.
ECDVector *Vec = new ECDVector();
Vec->push_back(D);
Vec->push_back(ECD);
// Update entry to point to the duplicates vector.
Entry = Vec;
// Store the vector somewhere we can consult later for quick emission of
// diagnostics.
DupVector.push_back(Vec);
continue;
}
ECDVector *Vec = Entry.get<ECDVector*>();
// Make sure constants are not added more than once.
if (*Vec->begin() == ECD)
continue;
Vec->push_back(ECD);
}
// Emit diagnostics.
for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(),
DupVectorEnd = DupVector.end();
DupVectorIter != DupVectorEnd; ++DupVectorIter) {
ECDVector *Vec = *DupVectorIter;
assert(Vec->size() > 1 && "ECDVector should have at least 2 elements.");
// Emit warning for one enum constant.
ECDVector::iterator I = Vec->begin();
S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values)
<< (*I)->getName() << (*I)->getInitVal().toString(10)
<< (*I)->getSourceRange();
++I;
// Emit one note for each of the remaining enum constants with
// the same value.
for (ECDVector::iterator E = Vec->end(); I != E; ++I)
S.Diag((*I)->getLocation(), diag::note_duplicate_element)
<< (*I)->getName() << (*I)->getInitVal().toString(10)
<< (*I)->getSourceRange();
delete Vec;
}
}
void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
SourceLocation RBraceLoc, Decl *EnumDeclX,
ArrayRef<Decl *> Elements,
Scope *S, AttributeList *Attr) {
EnumDecl *Enum = cast<EnumDecl>(EnumDeclX);
QualType EnumType = Context.getTypeDeclType(Enum);
if (Attr)
ProcessDeclAttributeList(S, Enum, Attr);
if (Enum->isDependentType()) {
for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
EnumConstantDecl *ECD =
cast_or_null<EnumConstantDecl>(Elements[i]);
if (!ECD) continue;
ECD->setType(EnumType);
}
Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0);
return;
}
// TODO: If the result value doesn't fit in an int, it must be a long or long
// long value. ISO C does not support this, but GCC does as an extension,
// emit a warning.
unsigned IntWidth = Context.getTargetInfo().getIntWidth();
unsigned CharWidth = Context.getTargetInfo().getCharWidth();
unsigned ShortWidth = Context.getTargetInfo().getShortWidth();
// Verify that all the values are okay, compute the size of the values, and
// reverse the list.
unsigned NumNegativeBits = 0;
unsigned NumPositiveBits = 0;
// Keep track of whether all elements have type int.
bool AllElementsInt = true;
for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
EnumConstantDecl *ECD =
cast_or_null<EnumConstantDecl>(Elements[i]);
if (!ECD) continue; // Already issued a diagnostic.
const llvm::APSInt &InitVal = ECD->getInitVal();
// Keep track of the size of positive and negative values.
if (InitVal.isUnsigned() || InitVal.isNonNegative())
NumPositiveBits = std::max(NumPositiveBits,
(unsigned)InitVal.getActiveBits());
else
NumNegativeBits = std::max(NumNegativeBits,
(unsigned)InitVal.getMinSignedBits());
// Keep track of whether every enum element has type int (very commmon).
if (AllElementsInt)
AllElementsInt = ECD->getType() == Context.IntTy;
}
// Figure out the type that should be used for this enum.
QualType BestType;
unsigned BestWidth;
// C++0x N3000 [conv.prom]p3:
// An rvalue of an unscoped enumeration type whose underlying
// type is not fixed can be converted to an rvalue of the first
// of the following types that can represent all the values of
// the enumeration: int, unsigned int, long int, unsigned long
// int, long long int, or unsigned long long int.
// C99 6.4.4.3p2:
// An identifier declared as an enumeration constant has type int.
// The C99 rule is modified by a gcc extension
QualType BestPromotionType;
bool Packed = Enum->getAttr<PackedAttr>() ? true : false;
// -fshort-enums is the equivalent to specifying the packed attribute on all
// enum definitions.
if (LangOpts.ShortEnums)
Packed = true;
if (Enum->isFixed()) {
BestType = Enum->getIntegerType();
if (BestType->isPromotableIntegerType())
BestPromotionType = Context.getPromotedIntegerType(BestType);
else
BestPromotionType = BestType;
// We don't need to set BestWidth, because BestType is going to be the type
// of the enumerators, but we do anyway because otherwise some compilers
// warn that it might be used uninitialized.
BestWidth = CharWidth;
}
else if (NumNegativeBits) {
// If there is a negative value, figure out the smallest integer type (of
// int/long/longlong) that fits.
// If it's packed, check also if it fits a char or a short.
if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
BestType = Context.SignedCharTy;
BestWidth = CharWidth;
} else if (Packed && NumNegativeBits <= ShortWidth &&
NumPositiveBits < ShortWidth) {
BestType = Context.ShortTy;
BestWidth = ShortWidth;
} else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
BestType = Context.IntTy;
BestWidth = IntWidth;
} else {
BestWidth = Context.getTargetInfo().getLongWidth();
if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
BestType = Context.LongTy;
} else {
BestWidth = Context.getTargetInfo().getLongLongWidth();
if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
Diag(Enum->getLocation(), diag::warn_enum_too_large);
BestType = Context.LongLongTy;
}
}
BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
} else {
// If there is no negative value, figure out the smallest type that fits
// all of the enumerator values.
// If it's packed, check also if it fits a char or a short.
if (Packed && NumPositiveBits <= CharWidth) {
BestType = Context.UnsignedCharTy;
BestPromotionType = Context.IntTy;
BestWidth = CharWidth;
} else if (Packed && NumPositiveBits <= ShortWidth) {
BestType = Context.UnsignedShortTy;
BestPromotionType = Context.IntTy;
BestWidth = ShortWidth;
} else if (NumPositiveBits <= IntWidth) {
BestType = Context.UnsignedIntTy;
BestWidth = IntWidth;
BestPromotionType
= (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
? Context.UnsignedIntTy : Context.IntTy;
} else if (NumPositiveBits <=
(BestWidth = Context.getTargetInfo().getLongWidth())) {
BestType = Context.UnsignedLongTy;
BestPromotionType
= (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
? Context.UnsignedLongTy : Context.LongTy;
} else {
BestWidth = Context.getTargetInfo().getLongLongWidth();
assert(NumPositiveBits <= BestWidth &&
"How could an initializer get larger than ULL?");
BestType = Context.UnsignedLongLongTy;
BestPromotionType
= (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
? Context.UnsignedLongLongTy : Context.LongLongTy;
}
}
// Loop over all of the enumerator constants, changing their types to match
// the type of the enum if needed.
for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]);
if (!ECD) continue; // Already issued a diagnostic.
// Standard C says the enumerators have int type, but we allow, as an
// extension, the enumerators to be larger than int size. If each
// enumerator value fits in an int, type it as an int, otherwise type it the
// same as the enumerator decl itself. This means that in "enum { X = 1U }"
// that X has type 'int', not 'unsigned'.
// Determine whether the value fits into an int.
llvm::APSInt InitVal = ECD->getInitVal();
// If it fits into an integer type, force it. Otherwise force it to match
// the enum decl type.
QualType NewTy;
unsigned NewWidth;
bool NewSign;
if (!getLangOpts().CPlusPlus &&
!Enum->isFixed() &&
isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) {
NewTy = Context.IntTy;
NewWidth = IntWidth;
NewSign = true;
} else if (ECD->getType() == BestType) {
// Already the right type!
if (getLangOpts().CPlusPlus)
// C++ [dcl.enum]p4: Following the closing brace of an
// enum-specifier, each enumerator has the type of its
// enumeration.
ECD->setType(EnumType);
continue;
} else {
NewTy = BestType;
NewWidth = BestWidth;
NewSign = BestType->isSignedIntegerOrEnumerationType();
}
// Adjust the APSInt value.
InitVal = InitVal.extOrTrunc(NewWidth);
InitVal.setIsSigned(NewSign);
ECD->setInitVal(InitVal);
// Adjust the Expr initializer and type.
if (ECD->getInitExpr() &&
!Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy,
CK_IntegralCast,
ECD->getInitExpr(),
/*base paths*/ 0,
VK_RValue));
if (getLangOpts().CPlusPlus)
// C++ [dcl.enum]p4: Following the closing brace of an
// enum-specifier, each enumerator has the type of its
// enumeration.
ECD->setType(EnumType);
else
ECD->setType(NewTy);
}
Enum->completeDefinition(BestType, BestPromotionType,
NumPositiveBits, NumNegativeBits);
// If we're declaring a function, ensure this decl isn't forgotten about -
// it needs to go into the function scope.
if (InFunctionDeclarator)
DeclsInPrototypeScope.push_back(Enum);
CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType);
// Now that the enum type is defined, ensure it's not been underaligned.
if (Enum->hasAttrs())
CheckAlignasUnderalignment(Enum);
}
Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr,
SourceLocation StartLoc,
SourceLocation EndLoc) {
StringLiteral *AsmString = cast<StringLiteral>(expr);
FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
AsmString, StartLoc,
EndLoc);
CurContext->addDecl(New);
return New;
}
DeclResult Sema::ActOnModuleImport(SourceLocation AtLoc,
SourceLocation ImportLoc,
ModuleIdPath Path) {
Module *Mod = PP.getModuleLoader().loadModule(ImportLoc, Path,
Module::AllVisible,
/*IsIncludeDirective=*/false);
if (!Mod)
return true;
SmallVector<SourceLocation, 2> IdentifierLocs;
Module *ModCheck = Mod;
for (unsigned I = 0, N = Path.size(); I != N; ++I) {
// If we've run out of module parents, just drop the remaining identifiers.
// We need the length to be consistent.
if (!ModCheck)
break;
ModCheck = ModCheck->Parent;
IdentifierLocs.push_back(Path[I].second);
}
ImportDecl *Import = ImportDecl::Create(Context,
Context.getTranslationUnitDecl(),
AtLoc.isValid()? AtLoc : ImportLoc,
Mod, IdentifierLocs);
Context.getTranslationUnitDecl()->addDecl(Import);
return Import;
}
void Sema::createImplicitModuleImport(SourceLocation Loc, Module *Mod) {
// Create the implicit import declaration.
TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
Loc, Mod, Loc);
TU->addDecl(ImportD);
Consumer.HandleImplicitImportDecl(ImportD);
// Make the module visible.
PP.getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc,
/*Complain=*/false);
}
void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name,
IdentifierInfo* AliasName,
SourceLocation PragmaLoc,
SourceLocation NameLoc,
SourceLocation AliasNameLoc) {
Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc,
LookupOrdinaryName);
AsmLabelAttr *Attr =
::new (Context) AsmLabelAttr(AliasNameLoc, Context, AliasName->getName());
if (PrevDecl)
PrevDecl->addAttr(Attr);
else
(void)ExtnameUndeclaredIdentifiers.insert(
std::pair<IdentifierInfo*,AsmLabelAttr*>(Name, Attr));
}
void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
SourceLocation PragmaLoc,
SourceLocation NameLoc) {
Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
if (PrevDecl) {
PrevDecl->addAttr(::new (Context) WeakAttr(PragmaLoc, Context));
} else {
(void)WeakUndeclaredIdentifiers.insert(
std::pair<IdentifierInfo*,WeakInfo>
(Name, WeakInfo((IdentifierInfo*)0, NameLoc)));
}
}
void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
IdentifierInfo* AliasName,
SourceLocation PragmaLoc,
SourceLocation NameLoc,
SourceLocation AliasNameLoc) {
Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc,
LookupOrdinaryName);
WeakInfo W = WeakInfo(Name, NameLoc);
if (PrevDecl) {
if (!PrevDecl->hasAttr<AliasAttr>())
if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
DeclApplyPragmaWeak(TUScope, ND, W);
} else {
(void)WeakUndeclaredIdentifiers.insert(
std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
}
}
Decl *Sema::getObjCDeclContext() const {
return (dyn_cast_or_null<ObjCContainerDecl>(CurContext));
}
AvailabilityResult Sema::getCurContextAvailability() const {
const Decl *D = cast<Decl>(getCurObjCLexicalContext());
return D->getAvailability();
}
| [
"zenghongbin16@mails.ucas.ac.cn"
] | zenghongbin16@mails.ucas.ac.cn |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.