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 986 values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23 values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 145 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 122 values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
d5efc3922541329f534b9034bf578a4a967cae3f | bc6d1b77b4a3721c1d5be7f769ad5b0423ec651d | /Simulator/stdafx.h | 07ca4fbc1add4a5e854226cd1f61a715794ffbe9 | [] | no_license | endiny/SMOLab | 3e4af0664bf19ca7cd70be3afb7bfc9d3257aeb5 | 9d6b3f03c104cc7c7fdd3be6c45860c8bc5fb856 | refs/heads/master | 2016-08-11T07:42:13.914763 | 2016-02-15T18:08:42 | 2016-02-15T19:59:45 | 48,456,047 | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 880 | h | // stdafx.h: включаемый файл для стандартных системных включаемых файлов
// или включаемых файлов для конкретного проекта, которые часто используются, но
// не часто изменяются
//
#pragma once
#include <string>
#include <iostream>
#include <stdio.h>
//#include <tchar.h>
#include "SourceRow.h"
#include "ServerRow.h"
#include "Generator.h"
#include "Buffer.h"
#include "Source.h"
#include <vector>
#include <algorithm>
#include "ArrivalProcess.h"
#include <ctime>
#include "Server.h"
#include "ServiceProcess.h"
#include "Statistic.h"
#include "Simulator.h"
// TODO: Установите здесь ссылки на дополнительные заголовки, требующиеся для программы
| [
"endiny@icloud.com"
] | endiny@icloud.com |
d0c2df3febeb4473c0172d8a30bf1639e7261dd2 | 5ba0371efb2e6621151b5b25f8973e6a20e8a0d3 | /private_inheritance.cpp | e3a6b09c90b0e7758133925ee41a018f9a0af288 | [] | no_license | kunal-pahwa/HackerRank_Questions | a2cc97cef7e6e2b68b7ae786f245ff4e1ba2f447 | 7090a0733aebdd77e516eefcd1f7ebe8d376b9a9 | refs/heads/master | 2020-03-22T22:44:58.165372 | 2018-07-12T22:13:51 | 2018-07-12T22:13:51 | 140,768,866 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 253 | cpp | #include<iostream>
using namespace std;
class base{
public:
int a=10;
int b=5;
void fun(){
cout<<"sadfasd";
}
};
class Derived:public base{
public:
void fun(){
cout<<"i am in derived";
}
};
int main()
{
Derived b1;
b1.base::fun();
}
| [
"kunalpahwa0001@gmail.com"
] | kunalpahwa0001@gmail.com |
fb6d9a45795a0e41c2048a11c417052c5a7f3e6a | ba96d7f21540bd7504e61954f01a6d77f88dea6f | /build/Android/Debug/app/src/main/include/_root.Haslaamispaivak-d3464ec1.h | 83d79b9947a9d5cc76c8c35681d33963b0647aa2 | [] | no_license | GetSomefi/haslaamispaivakirja | 096ff35fe55e3155293e0030c91b4bbeafd512c7 | 9ba6766987da4af3b662e33835231b5b88a452b3 | refs/heads/master | 2020-03-21T19:54:24.148074 | 2018-11-09T06:44:18 | 2018-11-09T06:44:18 | 138,976,977 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,200 | h | // This file was generated based on '/Users/petervirtanen/OneDrive/Fuse projektit/Häsläämispäiväkirja/.uno/ux15/Häsläämispäiväkirja.unoproj.g.uno'.
// WARNING: Changes might be lost if you edit this file directly.
#pragma once
#include <Uno.String.h>
#include <Uno.UX.Property1-1.h>
namespace g{namespace Fuse{namespace Triggers{struct WhileString;}}}
namespace g{namespace Uno{namespace UX{struct PropertyObject;}}}
namespace g{namespace Uno{namespace UX{struct Selector;}}}
namespace g{struct Haslaamispaivakirja_FuseTriggersWhileString_Value_Property;}
namespace g{
// internal sealed class Haslaamispaivakirja_FuseTriggersWhileString_Value_Property :525
// {
::g::Uno::UX::Property1_type* Haslaamispaivakirja_FuseTriggersWhileString_Value_Property_typeof();
void Haslaamispaivakirja_FuseTriggersWhileString_Value_Property__ctor_3_fn(Haslaamispaivakirja_FuseTriggersWhileString_Value_Property* __this, ::g::Fuse::Triggers::WhileString* obj, ::g::Uno::UX::Selector* name);
void Haslaamispaivakirja_FuseTriggersWhileString_Value_Property__Get1_fn(Haslaamispaivakirja_FuseTriggersWhileString_Value_Property* __this, ::g::Uno::UX::PropertyObject* obj, uString** __retval);
void Haslaamispaivakirja_FuseTriggersWhileString_Value_Property__New1_fn(::g::Fuse::Triggers::WhileString* obj, ::g::Uno::UX::Selector* name, Haslaamispaivakirja_FuseTriggersWhileString_Value_Property** __retval);
void Haslaamispaivakirja_FuseTriggersWhileString_Value_Property__get_Object_fn(Haslaamispaivakirja_FuseTriggersWhileString_Value_Property* __this, ::g::Uno::UX::PropertyObject** __retval);
void Haslaamispaivakirja_FuseTriggersWhileString_Value_Property__Set1_fn(Haslaamispaivakirja_FuseTriggersWhileString_Value_Property* __this, ::g::Uno::UX::PropertyObject* obj, uString* v, uObject* origin);
struct Haslaamispaivakirja_FuseTriggersWhileString_Value_Property : ::g::Uno::UX::Property1
{
uWeak< ::g::Fuse::Triggers::WhileString*> _obj;
void ctor_3(::g::Fuse::Triggers::WhileString* obj, ::g::Uno::UX::Selector name);
static Haslaamispaivakirja_FuseTriggersWhileString_Value_Property* New1(::g::Fuse::Triggers::WhileString* obj, ::g::Uno::UX::Selector name);
};
// }
} // ::g
| [
"peyte.com@gmail.com"
] | peyte.com@gmail.com |
775c6b7772b3b2f1b43fb003636ecad3da5d4819 | 1f6824a64c3cc6b0827b55f24079edc23ed6bc2b | /Plugins/VoxelFree/Source/Voxel/Public/VoxelContainers/VoxelSparseArray.h | 24a62018b75360763e9663867b8b2b856d25703b | [
"MIT"
] | permissive | lineCode/Woodlands | bb330644567c92e041e4da3d5d80326755c370c5 | 9e99f948543ad3f8f0eead691eddb4125da272f5 | refs/heads/master | 2023-04-15T13:56:45.978505 | 2021-04-19T04:30:44 | 2021-04-19T04:30:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,862 | h | // Copyright 2021 Phyronnaz
#pragma once
#include "CoreMinimal.h"
#include "Containers/SparseArray.h"
// Default one does not do check on element access
template<typename InElementType, typename InAllocator = FDefaultSparseArrayAllocator>
class TVoxelSparseArray : public TSparseArray<InElementType, InAllocator>
{
public:
using Super = TSparseArray<InElementType, InAllocator>;
// Accessors.
inline InElementType& operator[](int32 Index)
{
check(Index >= 0 && Index < this->GetMaxIndex() && this->IsValidIndex(Index));
return Super::operator[](Index);
}
inline const InElementType& operator[](int32 Index) const
{
check(Index >= 0 && Index < this->GetMaxIndex() && this->IsValidIndex(Index));
return Super::operator[](Index);
}
};
// UniqueClass: to forbid copying ids from different classes
template<typename UniqueClass>
class TVoxelTypedSparseArrayId
{
public:
TVoxelTypedSparseArrayId() = default;
bool operator==(TVoxelTypedSparseArrayId Other) const { return Other.Index == Index; }
bool operator!=(TVoxelTypedSparseArrayId Other) const { return Other.Index != Index; }
public:
bool IsValid() const
{
return Index != 0;
}
void Reset()
{
Index = 0;
}
uint32 GetDebugValue() const
{
return Index;
}
public:
friend uint32 GetTypeHash(TVoxelTypedSparseArrayId Value)
{
return GetTypeHash(Value.Index);
}
private:
TVoxelTypedSparseArrayId(uint32 Index) : Index(Index) {}
uint32 Index = 0;
template<typename InKeyType, typename InElementType, typename InAllocator>
friend class TVoxelTypedSparseArray;
};
#define DECLARE_TYPED_VOXEL_SPARSE_ARRAY_ID(Name) using Name = TVoxelTypedSparseArrayId<class Name##_Unique>;
template<typename InKeyType, typename InElementType, typename InAllocator = FDefaultSparseArrayAllocator>
class TVoxelTypedSparseArray
{
public:
inline InElementType& operator[](InKeyType Index)
{
check(Index.IsValid());
return Storage[Index.Index - 1];
}
inline const InElementType& operator[](InKeyType Index) const
{
check(Index.IsValid());
return Storage[Index.Index - 1];
}
inline bool IsValidIndex(InKeyType Index) const
{
return Index.IsValid() && Storage.IsValidIndex(Index.Index - 1);
}
inline InKeyType Add(const InElementType& Element)
{
return { uint32(Storage.Add(Element)) + 1 };
}
inline InKeyType Add(InElementType&& Element)
{
return { uint32(Storage.Add(MoveTemp(Element))) + 1 };
}
inline void RemoveAt(InKeyType Index)
{
check(Index.IsValid());
Storage.RemoveAt(Index.Index - 1);
}
inline int32 Num() const
{
return Storage.Num();
}
public:
inline auto begin() { return Storage.begin(); }
inline auto begin() const { return Storage.begin(); }
inline auto end () { return Storage.end(); }
inline auto end () const { return Storage.end(); }
private:
TVoxelSparseArray<InElementType, InAllocator> Storage;
}; | [
"Mattrb_99@ymail.com"
] | Mattrb_99@ymail.com |
5735235ecfb1609c613a81726001d5cd0215eea9 | 7c6e3057103cc68d648623fa43e6323ea7b7f16a | /buggyAlpha/item/gold/treasure.cc | 652904c670a929ae6e5d8c89c449328144496286 | [] | no_license | rick1847/a5CC3000 | cd28d13822c049d7f7f3e4fac045dae432264bb3 | 0f7f84b307a49d690087776a3e2534ecc2ef8e25 | refs/heads/master | 2020-03-23T06:04:06.354711 | 2018-07-25T22:03:10 | 2018-07-25T22:03:10 | 141,186,624 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 226 | cc | #include "treasure.h"
Treasure::Treasure(Coordinate &p, Cell &c) : Item(p, c)
{}
Treasure::~Treasure() {
}
char Treasure::getAvatar() {
return 'G';
}
bool Treasure::isSteppableByPlayer(){
return true;
}
| [
"rick1847@gmail.com"
] | rick1847@gmail.com |
404e975cfe6d313c0096bd7ce52b62c4fd2e36e5 | 4593d44ef24313de4820663afdc493ed44fc0f9c | /GAROUTER/GARouter/include/GARDynObjective.hpp | d9b73620cffaadb75f578166efdbd728d301358b | [] | no_license | gg-uah/GARouter | 1d23cee49ecef317456f50349b61ad5519a541ea | 8fc2da9294b1211901512d4ef11751f88a3a2e78 | refs/heads/master | 2021-01-17T19:23:40.270095 | 2016-06-02T14:53:51 | 2016-06-02T14:53:51 | 60,272,711 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,524 | hpp | /*
* GARDynObjective.hpp
*
* Created on: Jun 10, 2015
* Author: ctomas
*/
#ifndef GARDYNOBJECTIVE_HPP_
#define GARDYNOBJECTIVE_HPP_
#include <GARDetector.hpp>
#include <GARDetectorCon.hpp>
#include <GARDetectorFlow.hpp>
#include <GARRouteCont.hpp>
#include <utils/common/StdDefs.h>
#include <ga/ga.h>
namespace gar {
/**
* This enumerator is used to identify every line of the od-matrix file.
*/
enum class GARGeneData : unsigned short { RouteName, DepartTime };
typedef GA1DArrayAlleleGenome<int> genome_dyn;
class GARDynObjective {
public:
/**
* Deleted constructor.
*/
GARDynObjective() = delete;
/**
* Deleted virtual destructor.
*/
virtual ~GARDynObjective() = delete;
/**
* The objective function of the genetic algorithm.
* @param __genome The genome of the genetic algorithm.
* @return The score assigned to the genome.
*/
static float objective(GAGenome& __genome);
/**
* Write the emitter file containing the vehicle trips to be performed
* by the SUMO simulation.
* @param emittFilename The emitter file name.
* @param begin The beginning processing file.
* @param end The end processing file.
* @param timeStep The time step of the flow measures.
* @param pDetCont The detectors container.
* @param pFlows The detector flow measures.
* @param pRouCont A pointer to the route data container.
* @param routes The routes resulting from the static approach solution.
* @param genome An individual genome in the genetic algorithm population.
* This genome comprises the routes to be performed by the SUMO simulation.
* @return <code>0</code> if the emitter file is successfully written,
* <code>1</code> otherwise.
*/
static int writeEmitterFile(const std::string& emittFilename,
const SUMOTime& begin,
const SUMOTime& end,
const SUMOTime& timeStep,
const GARDetectorCon const* pDetCont,
const GARDetectorFlows const* pFlows,
const GARRouteCont const* pRouCont,
const std::vector<std::string>& routes,
const genome_dyn& genome);
/**
* Run the SUMO simulation.
* @param netFile The network file.
* @param loopFile The induction loop file.
* @param rouFile The route file.
* @param emittFile The emitter file.
* @param begin The simulation beginning time in seconds.
* @param teleport The time to teleport in seconds.
* @return <code>-1</code> if the SUMO simulation if the SUMO simulation can't be executed,
* <code>status</code> the return status of the SUMO simulation executed by popen().
*/
static int runSUMO(const std::string& netFile,
const std::string& loopFile,
const std::string& rouFile,
const std::string& emittFile,
const SUMOTime& begin,
const SUMOTime& teleport);
/**
* Read the end time in seconds of the SUMO simulation from the pipe stream to the executed 'sumo' command.
* @param fp A pointer to the stream used to read from the pipe between the calling program and
* the 'sumo' command.
* @return The end time in seconds of the SUMO simulation or -1 if an error raises during the
* SUMO simulation.
*/
static SUMOTime getSimulationEndTime(FILE* fp);
/**
* Read the induction loop measurements and build the detector flow data.
* @param loops2Dets A map that connects induction loop identifiers with detector data.
* @param beginTime The simulation beginning time in seconds.
* @param endTime The simulation end time in seconds.
* @param timeStep The interval of time in seconds between two successive detector data.
* @return
*/
static std::shared_ptr<GARDetectorFlows> readLoopMeasures(const gar::loop2det_map& loops2Dets,
const SUMOTime& beginTime,
const SUMOTime& endTime,
const SUMOTime& timeStep);
/**
* Compute the Root Mean Squared Error (RMSE) of the detector flow data.
* @param detectors A vector containing the detector data in the network.
* @param pGoalFlowData The detector flow data to be aimed for.
* @param pSimFlowData The detector flow data as a result of the SUMO simulation.
* @return The RMSE of the detector flow data of the SUMO simulation.
*/
static float computeScore(const std::vector<GARDetector*>& detectors,
const GARDetectorFlows const* pGoalFlowData,
const GARDetectorFlows const* pSimFlowData);
/**
* Compute the route depart speed for an emitter.
* @param startTime The start time in seconds.
* @param endTime The end time in seconds.
* @param timeStep The time step of the detector flow measures.
* @param pDetCont The detectors container.
* @param pFlows The detector flow measures.
* @param pRouCont The routes container.
* @param routeName The route name.
* @return
*/
static float computeDepartSpeed(const SUMOTime& startTime,
const SUMOTime& endTime,
const SUMOTime& timeStep,
const GARDetectorCon const* pDetCont,
const GARDetectorFlows const* pFlows,
const GARRouteCont const * pRouCont,
const std::string& routeName);
//! The loop measurement file generated by the SUMO simulation in the objective function
static const std::string GAR_LOOP_MEAS_FILE;
//! The separator between the route and the depart time in the genome allele
static const std::string GAR_ALLELE_DEPART_SEPARATOR;
};
} /* namespace gar */
#endif /* GARDYNOBJECTIVE_HPP_ */
| [
"miguellop@iMac-de-Miguel.local"
] | miguellop@iMac-de-Miguel.local |
31cc51d80cdb81a60b22a57126d5050674ff0f2d | 7ff00141aefe2dc9c5525897b2594f6a61d2deb7 | /far/tracer.cpp | c8a0b3f69bad7201bd71ed2f1709bc0d64445cec | [
"BSD-3-Clause"
] | permissive | ctapmex/FarManager | c9e1b44d876eee090cc378554c171fbda3416377 | 41a14bef7e8ec50d59c48c0d33b8408252eae744 | refs/heads/master | 2021-12-19T10:19:33.583355 | 2021-11-28T15:34:40 | 2021-11-28T15:34:40 | 161,012,545 | 0 | 0 | BSD-3-Clause | 2018-12-09T06:44:40 | 2018-12-09T06:44:39 | null | UTF-8 | C++ | false | false | 10,966 | cpp | /*
tracer.cpp
*/
/*
Copyright © 2016 Far Group
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. The name of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
// BUGBUG
#include "platform.headers.hpp"
// Self:
#include "tracer.hpp"
// Internal:
#include "imports.hpp"
#include "encoding.hpp"
#include "pathmix.hpp"
#include "log.hpp"
#include "map_file.hpp"
// Platform:
#include "platform.fs.hpp"
// Common:
#include "common.hpp"
#include "common/string_utils.hpp"
// External:
#include "format.hpp"
//----------------------------------------------------------------------------
static auto platform_specific_data(CONTEXT const& ContextRecord)
{
const struct
{
DWORD MachineType;
DWORD64 PC, Frame, Stack;
}
Data
{
#if defined _M_X64
IMAGE_FILE_MACHINE_AMD64,
ContextRecord.Rip,
ContextRecord.Rbp,
ContextRecord.Rsp
#elif defined _M_IX86
IMAGE_FILE_MACHINE_I386,
ContextRecord.Eip,
ContextRecord.Ebp,
ContextRecord.Esp
#elif defined _M_ARM64
IMAGE_FILE_MACHINE_ARM64,
ContextRecord.Pc,
ContextRecord.Fp,
ContextRecord.Sp
#elif defined _M_ARM
IMAGE_FILE_MACHINE_ARM,
ContextRecord.Pc,
ContextRecord.R11,
ContextRecord.Sp
#else
IMAGE_FILE_MACHINE_UNKNOWN
#endif
};
return Data;
}
// StackWalk64() may modify context record passed to it, so we will use a copy.
static auto GetBackTrace(CONTEXT ContextRecord, HANDLE ThreadHandle)
{
std::vector<uintptr_t> Result;
if (!imports.StackWalk64)
return Result;
const auto Data = platform_specific_data(ContextRecord);
if (Data.MachineType == IMAGE_FILE_MACHINE_UNKNOWN || (!Data.PC && !Data.Frame && !Data.Stack))
return Result;
const auto address = [](DWORD64 const Offset)
{
return ADDRESS64{ Offset, 0, AddrModeFlat };
};
STACKFRAME64 StackFrame{};
StackFrame.AddrPC = address(Data.PC);
StackFrame.AddrFrame = address(Data.Frame);
StackFrame.AddrStack = address(Data.Stack);
while (imports.StackWalk64(Data.MachineType, GetCurrentProcess(), ThreadHandle, &StackFrame, &ContextRecord, nullptr, imports.SymFunctionTableAccess64, imports.SymGetModuleBase64, nullptr))
{
// Cast to uintptr_t is ok here: although this function can be used
// to capture a stack of 64-bit process from a 32-bit one,
// we always use it with the current process only.
Result.emplace_back(static_cast<uintptr_t>(StackFrame.AddrPC.Offset));
}
return Result;
}
// SYMBOL_INFO_PACKAGEW not defined in GCC headers :(
namespace
{
template<typename header>
struct package
{
header info;
static constexpr auto max_name_size = MAX_SYM_NAME;
std::remove_all_extents_t<decltype(header::Name)> name[max_name_size + 1];
};
}
static void get_symbols_impl(
string_view const ModuleName,
span<uintptr_t const> const BackTrace,
std::unordered_map<uintptr_t, map_file>& MapFiles,
function_ref<void(string&&, string&&, string&&)> const Consumer
)
{
const auto Process = GetCurrentProcess();
const auto FormatAddress = [](uintptr_t const Value)
{
// It is unlikely that RVAs will be above 4 GiB,
// so we can save some screen space here.
const auto Width =
#ifdef _WIN64
Value & 0xffffffff00000000? 16 : 8
#else
8
#endif
;
return format(FSTR(L"{:0{}X}"sv), Value, Width);
};
std::variant
<
package<SYMBOL_INFOW>,
package<SYMBOL_INFO>,
package<IMAGEHLP_SYMBOL64>
>
SymbolData;
string NameBuffer;
const auto GetName = [&](uintptr_t const Address) -> string_view
{
const auto Get = [&](auto const& Getter, auto& Buffer) -> std::basic_string_view<VALUE_TYPE(Buffer.info.Name)>
{
if (!Getter)
return {};
Buffer.info.SizeOfStruct = sizeof(Buffer.info);
size_t NameSize{};
if constexpr (std::is_convertible_v<decltype(imports.SymGetSymFromAddr64), decltype(Getter)>)
{
// This one is for Win2k, which doesn't have SymFromAddr.
// However, I couldn't make it work with the out-of-the-box version.
// Get a newer dbghelp.dll if you need traces there:
// http://download.microsoft.com/download/A/6/A/A6AC035D-DA3F-4F0C-ADA4-37C8E5D34E3D/setup/WinSDKDebuggingTools/dbg_x86.msi
Buffer.info.MaxNameLength = Buffer.max_name_size;
if (DWORD64 Displacement; !Getter(Process, Address, &Displacement, &Buffer.info))
return {};
}
else
{
Buffer.info.MaxNameLen = Buffer.max_name_size;
if (!Getter(Process, Address, {}, &Buffer.info))
return {};
NameSize = Buffer.info.NameLen;
}
// Fake symbol, generated by the OS from the DLL export table.
// The name is usually rubbish.
if (Buffer.info.Flags & SYMFLAG_EXPORT)
return {};
// Old dbghelp versions (e.g. XP) not always populate NameLen
return { Buffer.info.Name, NameSize? NameSize : std::char_traits<VALUE_TYPE(Buffer.info.Name)>::length(Buffer.info.Name) };
};
if (const auto Name = Get(imports.SymFromAddrW, SymbolData.emplace<0>()); !Name.empty())
return Name;
if (const auto Name = Get(imports.SymFromAddr, SymbolData.emplace<1>()); !Name.empty())
return NameBuffer = encoding::ansi::get_chars(Name);
if (const auto Name = Get(imports.SymGetSymFromAddr64, SymbolData.emplace<2>()); !Name.empty())
return NameBuffer = encoding::ansi::get_chars(Name);
return L""sv;
};
const auto GetLocation = [&](uintptr_t const Address)
{
const auto Get = [&](auto const& Getter, auto& Buffer)
{
Buffer.SizeOfStruct = sizeof(Buffer);
DWORD Displacement;
return Getter && Getter(Process, Address, &Displacement, &Buffer);
};
const auto Location = [](string_view const File, unsigned const Line)
{
return format(FSTR(L"{}({})"sv), File, Line);
};
if (IMAGEHLP_LINEW64 Line; Get(imports.SymGetLineFromAddrW64, Line))
return Location(Line.FileName, Line.LineNumber);
if (IMAGEHLP_LINE64 Line; Get(imports.SymGetLineFromAddr64, Line))
return Location(encoding::ansi::get_chars(Line.FileName), Line.LineNumber);
return L""s;
};
for (const auto Address: BackTrace)
{
IMAGEHLP_MODULEW64 Module{ static_cast<DWORD>(aligned_size(offsetof(IMAGEHLP_MODULEW64, LoadedImageName), 8)) }; // use the pre-07-Jun-2002 struct size, aligned to 8
const auto HasModuleInfo = imports.SymGetModuleInfoW64 && imports.SymGetModuleInfoW64(Process, Address, &Module);
string_view SymbolName;
string Location;
if (Address)
{
SymbolName = GetName(Address);
Location = GetLocation(Address);
if (SymbolName.empty() && HasModuleInfo)
{
const auto& MapFile = MapFiles.try_emplace(
Module.BaseOfImage,
*Module.LoadedImageName?
Module.LoadedImageName :
*Module.ImageName?
Module.ImageName :
ModuleName
).first->second;
string_view LocationFromMap;
std::tie(NameBuffer, LocationFromMap) = MapFile.get(Address - Module.BaseOfImage);
SymbolName = NameBuffer;
if (Location.empty())
Location = LocationFromMap;
if (SymbolName.empty())
SymbolName = L"<unknown> (get the pdb)"sv;
}
}
Consumer(
FormatAddress(Address - Module.BaseOfImage),
Address?
concat(
HasModuleInfo?
PointToName(Module.ImageName) :
L"<unknown>"sv,
L'!',
SymbolName
) :
L""s,
std::move(Location)
);
}
}
tracer_detail::tracer::tracer():
m_MapFiles(std::make_unique<std::unordered_map<uintptr_t, map_file>>())
{
}
tracer_detail::tracer::~tracer() = default;
std::vector<uintptr_t> tracer_detail::tracer::get(string_view const Module, CONTEXT const& ContextRecord, HANDLE ThreadHandle)
{
SCOPED_ACTION(with_symbols)(Module);
return GetBackTrace(ContextRecord, ThreadHandle);
}
void tracer_detail::tracer::get_symbols(string_view const Module, span<uintptr_t const> const Trace, function_ref<void(string&& Line)> const Consumer)
{
SCOPED_ACTION(with_symbols)(Module);
get_symbols_impl(Module, Trace, *m_MapFiles, [&](string&& Address, string&& Name, string&& Source)
{
if (!Name.empty())
append(Address, L' ', Name);
if (!Source.empty())
append(Address, L" ("sv, Source, L')');
Consumer(std::move(Address));
});
}
void tracer_detail::tracer::get_symbol(string_view const Module, const void* Ptr, string& Address, string& Name, string& Source)
{
SCOPED_ACTION(with_symbols)(Module);
uintptr_t const Stack[]{ reinterpret_cast<uintptr_t>(Ptr) };
get_symbols_impl(Module, Stack, *m_MapFiles, [&](string&& StrAddress, string&& StrName, string&& StrSource)
{
Address = std::move(StrAddress);
Name = std::move(StrName);
Source = std::move(StrSource);
});
}
void tracer_detail::tracer::sym_initialise(string_view Module)
{
SCOPED_ACTION(std::lock_guard)(m_CS);
if (m_SymInitialised)
{
++m_SymInitialised;
return;
}
auto Path = os::fs::get_current_process_file_name();
CutToParent(Path);
if (!Module.empty())
{
CutToParent(Module);
append(Path, L';', Module);
}
if (imports.SymSetOptions)
{
imports.SymSetOptions(
SYMOPT_UNDNAME |
SYMOPT_DEFERRED_LOADS |
SYMOPT_LOAD_LINES |
SYMOPT_FAIL_CRITICAL_ERRORS |
SYMOPT_INCLUDE_32BIT_MODULES |
SYMOPT_NO_PROMPTS
);
}
if (
(imports.SymInitializeW && imports.SymInitializeW(GetCurrentProcess(), EmptyToNull(Path), TRUE)) ||
(imports.SymInitialize && imports.SymInitialize(GetCurrentProcess(), EmptyToNull(encoding::ansi::get_bytes(Path)), TRUE))
)
++m_SymInitialised;
}
void tracer_detail::tracer::sym_cleanup()
{
SCOPED_ACTION(std::lock_guard)(m_CS);
if (m_SymInitialised)
--m_SymInitialised;
if (!m_SymInitialised)
{
if (imports.SymCleanup)
imports.SymCleanup(GetCurrentProcess());
}
}
tracer_detail::tracer::with_symbols::with_symbols(string_view const Module)
{
::tracer.sym_initialise(Module);
}
tracer_detail::tracer::with_symbols::~with_symbols()
{
::tracer.sym_cleanup();
}
NIFTY_DEFINE(tracer_detail::tracer, tracer);
| [
"alabuzhev@gmail.com"
] | alabuzhev@gmail.com |
5e492c20a2fa7db0dc9be1b1c802e91d958c301a | fcd4bce0080771389b4a69338ed6443153942183 | /cores/n64/mupen64plus-rsp-paraLLEl/rsp_vu_fuzzer.cpp | bcb629b382c3b3e33066f7edb2f8034b3fe3ebb6 | [
"MIT",
"LGPL-2.1-only",
"MPL-1.1",
"LicenseRef-scancode-mame",
"GPL-1.0-or-later",
"Zlib",
"GPL-2.0-only",
"LGPL-2.1-or-later",
"MPL-2.0",
"CC-PDDC",
"LicenseRef-scancode-public-domain",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-brian-gladman-3-clause",
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla",
"GPL-3.0-only",
"LGPL-3.0-only"
] | permissive | wulfebw/retro | d4fcf9229b257b3c495f54b1aeb3ea36004ae4aa | dad4b509e99e729e39a2f27e9ee4120e3b607f58 | refs/heads/master | 2022-10-23T07:17:55.320585 | 2020-06-12T01:38:06 | 2020-06-12T01:38:06 | 260,832,205 | 8 | 1 | MIT | 2020-06-12T01:38:08 | 2020-05-03T05:06:17 | C | UTF-8 | C++ | false | false | 2,474 | cpp | #include "rsp_op.hpp"
#include "rsp_disasm.hpp"
#include <random>
using namespace RSP;
static uint64_t hash_registers(const CPUState *rsp)
{
uint64_t h = 0xcbf29ce484222325ull;
auto *data = reinterpret_cast<const uint32_t *>(&rsp->cp2);
unsigned words = sizeof(rsp->cp2) >> 2;
for (size_t i = 0; i < words; i++)
h = (h * 0x100000001b3ull) ^ data[i];
return h;
}
static void fill_cp2_register_state(std::mt19937 &rnd, CPUState *rsp)
{
auto *data = reinterpret_cast<uint32_t *>(&rsp->cp2);
unsigned words = sizeof(rsp->cp2) >> 2;
for (unsigned i = 0; i < words; i++)
data[i] = rnd();
}
static void run_vu_opcode(std::mt19937 &rnd, CPUState *rsp, unsigned instr)
{
fill_cp2_register_state(rnd, rsp);
uint32_t op = instr & 63;
uint32_t vd = (instr >> 6) & 31;
uint32_t vs = (instr >> 11) & 31;
uint32_t vt = (instr >> 16) & 31;
uint32_t e = (instr >> 21) & 15;
using VUOp = void (*)(RSP::CPUState *, unsigned vd, unsigned vs, unsigned vt, unsigned e);
static const VUOp ops[64] = {
RSP_VMULF, RSP_VMULU, nullptr, nullptr, RSP_VMUDL, RSP_VMUDM, RSP_VMUDN, RSP_VMUDH, RSP_VMACF, RSP_VMACU, nullptr,
nullptr, RSP_VMADL, RSP_VMADM, RSP_VMADN, RSP_VMADH, RSP_VADD, RSP_VSUB, nullptr, RSP_VABS, RSP_VADDC, RSP_VSUBC,
nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, RSP_VSAR, nullptr, nullptr, RSP_VLT,
RSP_VEQ, RSP_VNE, RSP_VGE, RSP_VCL, RSP_VCH, RSP_VCR, RSP_VMRG, RSP_VAND, RSP_VNAND, RSP_VOR, RSP_VNOR,
RSP_VXOR, RSP_VNXOR, nullptr, nullptr, RSP_VRCP, RSP_VRCPL, RSP_VRCPH, RSP_VMOV, RSP_VRSQ, RSP_VRSQL, RSP_VRSQH,
RSP_VNOP,
};
auto *vuop = ops[op];
if (!vuop)
vuop = RSP_RESERVED;
vuop(rsp, vd, vs, vt, e);
uint64_t register_hash = hash_registers(rsp);
auto disasm = disassemble(0, instr | (0x25u << 25u));
printf("%s (%llx)\n", disasm.c_str(), static_cast<unsigned long long>(register_hash));
}
int main()
{
// Exhaustive test every single VU opcode with random input.
std::mt19937 rnd(0xf00b4); // Fixed seed.
CPUState state = {};
// Sweep through every opcode at least once.
constexpr unsigned num_opcodes = 1u << 25u;
for (unsigned instr = 0; instr < num_opcodes; instr++)
run_vu_opcode(rnd, &state, instr);
// Try random opcodes some more, should hopefully hit some interesting corner cases eventually.
constexpr unsigned num_random_opcodes = 50000000;
for (unsigned i = 0; i < num_random_opcodes; i++)
{
unsigned instr = rnd() & (num_opcodes - 1);
run_vu_opcode(rnd, &state, instr);
}
}
| [
"blake.w.wulfe@gmail.com"
] | blake.w.wulfe@gmail.com |
d474d21bc6b9e06bf1d192309cf17078d37c52c1 | 13c3630445d73fb2703e5574b70942742f37fb89 | /Stable/CSCommon/MMatchServer_AntiHack.cpp | bf1f6b9412587e1f8a8d4b9f6af27ef0cda26b8a | [] | no_license | NovaDV/Gunz1.5 | 8cb660462c386f4c35d7f5198e614a29d5276547 | 97e7bc51fd082e37f3de0f02c5e2ce6c33530c50 | refs/heads/main | 2023-06-14T15:41:07.759755 | 2021-07-11T18:25:07 | 2021-07-11T18:25:07 | 385,099,338 | 1 | 0 | null | 2021-07-12T02:10:18 | 2021-07-12T02:10:18 | null | UTF-8 | C++ | false | false | 410 | cpp | #include "stdafx.h"
#include "MMatchServer.h"
#include "MSharedCommandTable.h"
#include "MErrorTable.h"
#include "MMatchObject.h"
#include "Msg.h"
#include "MMatchConfig.h"
#include "MCommandCommunicator.h"
#include "MDebug.h"
#include "MMatchAuth.h"
#include "MAsyncDBJob.h"
#include "MMatchUtil.h"
#include "MMatchPremiumIPCache.h"
#include "MCommandBuilder.h"
#include "MMatchAntiHack.h"
#include "MUtil.h"
| [
"jduncan0392@gmail.com"
] | jduncan0392@gmail.com |
d6eb01018604fccc5fc55c6c8d11cd7a95ac0038 | 35b0502a545134896c7b88243dd6359af18e7d23 | /WeeDiff/WeeDiffGen/Plugins/WDGRemoveIsGuildCheatName/WDGRemoveIsGuildCheatName.cpp | 902ff83e33ac8eb77b07342533536b454abaf2c1 | [
"LicenseRef-scancode-other-permissive"
] | permissive | HM-LIANG/atwl | a16fb5b1fe87f553aa7fceb6bf84bb079e18456e | 11632f8b3827e47845e5e2def75522819fa445aa | refs/heads/master | 2023-04-19T10:01:15.373940 | 2021-05-08T21:25:30 | 2021-05-08T21:25:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,861 | cpp | // -----------------------------------------------------------------
// WDGRemoveIsGuildCheatName
// (c) 2014 Ai4rei/AN
//
// This work is licensed under a
// Creative Commons BY-NC-SA 3.0 Unported License
// http://creativecommons.org/licenses/by-nc-sa/3.0/
//
// -----------------------------------------------------------------
#include "WDGRemoveIsGuildCheatName.h"
#ifndef _ARRAYSIZE
#define _ARRAYSIZE(x) (sizeof(x)/sizeof((x)[0]))
#endif /* _ARRAYSIZE */
static /* const */ WDGPLUGININFO l_PluginInfo =
{
_T("Remove CSession::IsCheatName"),
_T("Prevents warnings during PM's when the sender has similar name to one of your guild members."),
_T("[UI]"),
_T(""),
_T("Ai4rei/AN"),
1,
0,
{ 0x6161b1fa, 0xea19, 0x11e1, { 0xa7, 0x78, 0x0, 0x22, 0x15, 0x64, 0x8a, 0x98 } }, /* guid */
_T(""),
};
static WDGPlugin* l_lpSelfReference = NULL;
void WDGPlugin::Release(void)
{
this->m_DiffData.clear();
l_lpSelfReference = NULL;
delete this;
}
void WDGPlugin::Free(LPVOID lpBuf)
{
delete lpBuf;
}
LPWDGPLUGININFO WDGPlugin::GetPluginInfo(void)
{
return &l_PluginInfo;
}
INT32 WDGPlugin::Enabled(void)
{
return 0;
}
INT32 WDGPlugin::Disabled(void)
{
return 0;
}
LPCTSTR WDGPlugin::GetInputValue(void)
{
return NULL;
}
DiffData* WDGPlugin::GeneratePatch(void)
{
FINDDATA Fd;
UINT32 uOffset, uBegin, uPart;
this->m_DiffData.clear();
if(!this->IsSane())
{
return NULL;
}
try
{
// MISSION: Find set of pushes that set-up the warning and
// change the conditional jump before them.
Fd.uMask = WFD_PATTERN|WFD_SECTION;
Fd.lpData = "85C074236A006A0068FFFF00006897030000";
Fd.lpszSection = ".text";
uPart = 1;
uOffset = this->m_dgc->Match(&Fd);
this->SetByte(uOffset+2, 0xEB);
}
catch(const char* lpszThrown)
{
char szErrMsg[1024];
wsprintfA(szErrMsg, __FILE__" :: Part %u :: %s", uPart, lpszThrown);
this->m_dgc->LogMsg(szErrMsg);
this->m_DiffData.clear();
}
return this->m_DiffData.empty() ? NULL : &this->m_DiffData;
}
DiffData* WDGPlugin::GetDiffData(void)
{
return this->m_DiffData.empty() ? NULL : &this->m_DiffData;
}
bool WDGPlugin::IsVC9Image(void)
{
try
{
this->m_dgc->FindFunction("_except_handler4_common"); // msvcr90.dll/msvcr100.dll
}
catch(const char* lpszThrown)
{
return false;
// unused
(void)lpszThrown;
}
return true;
}
bool WDGPlugin::IsSane(void)
{// ensure that it actually is a valid RO client
#define ISSANEMAGIC "gravity"
FINDDATA Fd;
Fd.uMask = WFD_SECTION;
Fd.lpData = ISSANEMAGIC;
Fd.uDataSize = sizeof(ISSANEMAGIC);
Fd.lpszSection = this->IsVC9Image() ? ".rdata" : ".data";
try
{
this->m_dgc->Match(&Fd);
}
catch(const char* lpszThrown)
{
this->m_dgc->LogMsg(__FILE__" :: Image is not sane.");
return false;
// unused
(void)lpszThrown;
}
return true;
#undef ISSANEMAGIC
}
void WDGPlugin::SetByte(UINT32 uOffset, UCHAR uValue)
{
DIFFDATA Diff = { uOffset, uValue };
this->m_DiffData.push_back(Diff);
}
extern "C" __declspec(dllexport) WeeDiffGenPlugin::IWDGPlugin* InitPlugin(LPVOID lpData, USHORT huWeeDiffMajorVersion, USHORT huWeeDiffMinorVersion)
{
if(l_lpSelfReference)
{// double initialization
DebugBreak();
}
else
{
l_lpSelfReference = new WDGPlugin(lpData);
}
return l_lpSelfReference;
}
bool WDGPlugin::TryMatch(LPFINDDATA lpFd, UINT32* lpuOffset)
{
try
{
lpuOffset[0] = this->m_dgc->Match(lpFd);
}
catch(const char* lpszThrown)
{
return false;
// unused
(void)lpszThrown;
}
return true;
}
| [
"ai4rei@users.noreply.github.com"
] | ai4rei@users.noreply.github.com |
7b7b4c015402fdf5132e60905b5e0373b7d98882 | 0ef4f71c8ff2f233945ee4effdba893fed3b8fad | /misc_microsoft_gamedev_source_code/misc_microsoft_gamedev_source_code/extlib/havok/Source/Physics/Internal/hkpInternal.cpp | 780bded8f6dd952d0258c777af55336d618020ce | [] | no_license | sgzwiz/misc_microsoft_gamedev_source_code | 1f482b2259f413241392832effcbc64c4c3d79ca | 39c200a1642102b484736b51892033cc575b341a | refs/heads/master | 2022-12-22T11:03:53.930024 | 2020-09-28T20:39:56 | 2020-09-28T20:39:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,320 | cpp | /*
*
* Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
* prior written consent.This software contains code, techniques and know-how which is confidential and proprietary to Havok.
* Level 2 and Level 3 source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2007 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
*
*/
#include <Physics/Internal/hkpInternal.h>
#if defined(HK_PLATFORM_PSP)
static int makeCompilerNotCrashDummy3(int z){ int x = z; return x+z; }
#endif
/*
* Havok SDK - PUBLIC RELEASE, BUILD(#20070919)
*
* Confidential Information of Havok. (C) Copyright 1999-2007
* Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
* Logo, and the Havok buzzsaw logo are trademarks of Havok. Title, ownership
* rights, and intellectual property rights in the Havok software remain in
* Havok and/or its suppliers.
*
* Use of this software for evaluation purposes is subject to and indicates
* acceptance of the End User licence Agreement for this product. A copy of
* the license is included with this software and is also available from salesteam@havok.com.
*
*/
| [
"benjamin.barratt@icloud.com"
] | benjamin.barratt@icloud.com |
ad2e33df8684cbe1ae5aaa575d0943d4ba8d0a69 | 477c8309420eb102b8073ce067d8df0afc5a79b1 | /VTK/Rendering/fonts/face_courier_bold.cxx | bb7cad3bfc53c4bfd8f43bc7cea19f52587fb10f | [
"LicenseRef-scancode-paraview-1.2",
"BSD-3-Clause"
] | permissive | aashish24/paraview-climate-3.11.1 | e0058124e9492b7adfcb70fa2a8c96419297fbe6 | c8ea429f56c10059dfa4450238b8f5bac3208d3a | refs/heads/uvcdat-master | 2021-07-03T11:16:20.129505 | 2013-05-10T13:14:30 | 2013-05-10T13:14:30 | 4,238,077 | 1 | 0 | NOASSERTION | 2020-10-12T21:28:23 | 2012-05-06T02:32:44 | C++ | UTF-8 | C++ | false | false | 208,842 | cxx | #include "vtkEmbeddedFonts.h"
// VTK: Courier Bold
// Courier 10 Pitch Bold (c0583bt_.pfb)
// Contributed by Bitstream (XFree86)
size_t face_courier_bold_buffer_length = 40008;
unsigned char face_courier_bold_buffer[] = {
128, 1, 215, 5, 0, 0, 37, 33, 80, 83, 45, 65, 100, 111,
98, 101, 70, 111, 110, 116, 45, 49, 46, 48, 13, 37, 37, 67,
114, 101, 97, 116, 105, 111, 110, 68, 97, 116, 101, 58, 32, 83,
117, 110, 32, 78, 111, 118, 32, 32, 52, 32, 49, 57, 58, 51,
49, 58, 49, 48, 32, 49, 57, 57, 48, 13, 37, 32, 66, 105,
116, 115, 116, 114, 101, 97, 109, 32, 84, 121, 112, 101, 32, 49,
32, 70, 111, 110, 116, 32, 80, 114, 111, 103, 114, 97, 109, 13,
37, 32, 67, 111, 112, 121, 114, 105, 103, 104, 116, 32, 49, 57,
57, 48, 32, 97, 115, 32, 97, 110, 32, 117, 110, 112, 117, 98,
108, 105, 115, 104, 101, 100, 32, 119, 111, 114, 107, 32, 98, 121,
32, 66, 105, 116, 115, 116, 114, 101, 97, 109, 32, 73, 110, 99,
46, 44, 32, 67, 97, 109, 98, 114, 105, 100, 103, 101, 44, 32,
77, 65, 46, 13, 37, 32, 65, 108, 108, 32, 114, 105, 103, 104,
116, 115, 32, 114, 101, 115, 101, 114, 118, 101, 100, 46, 13, 37,
32, 67, 111, 110, 102, 105, 100, 101, 110, 116, 105, 97, 108, 32,
97, 110, 100, 32, 112, 114, 111, 112, 114, 105, 101, 116, 97, 114,
121, 32, 116, 111, 32, 66, 105, 116, 115, 116, 114, 101, 97, 109,
32, 73, 110, 99, 46, 13, 37, 32, 85, 46, 83, 46, 32, 71,
79, 86, 69, 82, 78, 77, 69, 78, 84, 32, 82, 69, 83, 84,
82, 73, 67, 84, 69, 68, 32, 82, 73, 71, 72, 84, 83, 13,
37, 32, 84, 104, 105, 115, 32, 115, 111, 102, 116, 119, 97, 114,
101, 32, 116, 121, 112, 101, 102, 97, 99, 101, 32, 112, 114, 111,
100, 117, 99, 116, 32, 105, 115, 32, 112, 114, 111, 118, 105, 100,
101, 100, 32, 119, 105, 116, 104, 32, 82, 69, 83, 84, 82, 73,
67, 84, 69, 68, 32, 82, 73, 71, 72, 84, 83, 46, 32, 85,
115, 101, 44, 13, 37, 32, 100, 117, 112, 108, 105, 99, 97, 116,
105, 111, 110, 32, 111, 114, 32, 100, 105, 115, 99, 108, 111, 115,
117, 114, 101, 32, 98, 121, 32, 116, 104, 101, 32, 71, 111, 118,
101, 114, 110, 109, 101, 110, 116, 32, 105, 115, 32, 115, 117, 98,
106, 101, 99, 116, 32, 116, 111, 32, 114, 101, 115, 116, 114, 105,
99, 116, 105, 111, 110, 115, 13, 37, 32, 97, 115, 32, 115, 101,
116, 32, 102, 111, 114, 116, 104, 32, 105, 110, 32, 116, 104, 101,
32, 108, 105, 99, 101, 110, 115, 101, 32, 97, 103, 114, 101, 101,
109, 101, 110, 116, 32, 97, 110, 100, 32, 105, 110, 32, 70, 65,
82, 32, 53, 50, 46, 50, 50, 55, 45, 49, 57, 32, 40, 99,
41, 32, 40, 50, 41, 32, 40, 77, 97, 121, 44, 32, 49, 57,
56, 55, 41, 44, 13, 37, 32, 119, 104, 101, 110, 32, 97, 112,
112, 108, 105, 99, 97, 98, 108, 101, 44, 32, 111, 114, 32, 116,
104, 101, 32, 97, 112, 112, 108, 105, 99, 97, 98, 108, 101, 32,
112, 114, 111, 118, 105, 115, 105, 111, 110, 115, 32, 111, 102, 32,
116, 104, 101, 32, 68, 79, 68, 32, 70, 65, 82, 32, 115, 117,
112, 112, 108, 101, 109, 101, 110, 116, 13, 37, 32, 50, 53, 50,
46, 50, 50, 55, 45, 55, 48, 49, 51, 32, 115, 117, 98, 100,
105, 118, 105, 115, 105, 111, 110, 32, 40, 97, 41, 32, 40, 49,
53, 41, 32, 40, 65, 112, 114, 105, 108, 44, 32, 49, 57, 56,
56, 41, 32, 111, 114, 32, 115, 117, 98, 100, 105, 118, 105, 115,
105, 111, 110, 32, 40, 97, 41, 32, 40, 49, 55, 41, 13, 37,
32, 40, 65, 112, 114, 105, 108, 44, 32, 49, 57, 56, 56, 41,
46, 32, 32, 67, 111, 110, 116, 114, 97, 99, 116, 111, 114, 47,
109, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 32, 105,
115, 32, 66, 105, 116, 115, 116, 114, 101, 97, 109, 32, 73, 110,
99, 46, 44, 13, 37, 32, 50, 49, 53, 32, 70, 105, 114, 115,
116, 32, 83, 116, 114, 101, 101, 116, 44, 32, 67, 97, 109, 98,
114, 105, 100, 103, 101, 44, 32, 77, 65, 32, 48, 50, 49, 52,
50, 46, 13, 37, 32, 66, 105, 116, 115, 116, 114, 101, 97, 109,
32, 105, 115, 32, 97, 32, 114, 101, 103, 105, 115, 116, 101, 114,
101, 100, 32, 116, 114, 97, 100, 101, 109, 97, 114, 107, 32, 111,
102, 32, 66, 105, 116, 115, 116, 114, 101, 97, 109, 32, 73, 110,
99, 46, 13, 49, 49, 32, 100, 105, 99, 116, 32, 98, 101, 103,
105, 110, 13, 47, 70, 111, 110, 116, 73, 110, 102, 111, 32, 57,
32, 100, 105, 99, 116, 32, 100, 117, 112, 32, 98, 101, 103, 105,
110, 13, 32, 32, 47, 118, 101, 114, 115, 105, 111, 110, 32, 40,
50, 46, 48, 45, 49, 46, 48, 41, 32, 114, 101, 97, 100, 111,
110, 108, 121, 32, 100, 101, 102, 13, 32, 32, 47, 78, 111, 116,
105, 99, 101, 32, 40, 67, 111, 112, 121, 114, 105, 103, 104, 116,
32, 49, 57, 57, 48, 32, 97, 115, 32, 97, 110, 32, 117, 110,
112, 117, 98, 108, 105, 115, 104, 101, 100, 32, 119, 111, 114, 107,
32, 98, 121, 32, 66, 105, 116, 115, 116, 114, 101, 97, 109, 32,
73, 110, 99, 46, 32, 32, 65, 108, 108, 32, 114, 105, 103, 104,
116, 115, 32, 114, 101, 115, 101, 114, 118, 101, 100, 46, 32, 32,
67, 111, 110, 102, 105, 100, 101, 110, 116, 105, 97, 108, 46, 41,
32, 114, 101, 97, 100, 111, 110, 108, 121, 32, 100, 101, 102, 13,
32, 32, 47, 70, 117, 108, 108, 78, 97, 109, 101, 32, 40, 67,
111, 117, 114, 105, 101, 114, 32, 49, 48, 32, 80, 105, 116, 99,
104, 32, 66, 111, 108, 100, 41, 32, 114, 101, 97, 100, 111, 110,
108, 121, 32, 100, 101, 102, 13, 32, 32, 47, 70, 97, 109, 105,
108, 121, 78, 97, 109, 101, 32, 40, 67, 111, 117, 114, 105, 101,
114, 32, 49, 48, 32, 80, 105, 116, 99, 104, 41, 32, 114, 101,
97, 100, 111, 110, 108, 121, 32, 100, 101, 102, 13, 32, 32, 47,
87, 101, 105, 103, 104, 116, 32, 40, 66, 111, 108, 100, 41, 32,
114, 101, 97, 100, 111, 110, 108, 121, 32, 100, 101, 102, 13, 32,
32, 47, 73, 116, 97, 108, 105, 99, 65, 110, 103, 108, 101, 32,
48, 32, 100, 101, 102, 13, 32, 32, 47, 105, 115, 70, 105, 120,
101, 100, 80, 105, 116, 99, 104, 32, 116, 114, 117, 101, 32, 100,
101, 102, 13, 32, 32, 47, 85, 110, 100, 101, 114, 108, 105, 110,
101, 80, 111, 115, 105, 116, 105, 111, 110, 32, 45, 57, 55, 32,
100, 101, 102, 13, 32, 32, 47, 85, 110, 100, 101, 114, 108, 105,
110, 101, 84, 104, 105, 99, 107, 110, 101, 115, 115, 32, 57, 51,
32, 100, 101, 102, 13, 101, 110, 100, 32, 114, 101, 97, 100, 111,
110, 108, 121, 32, 100, 101, 102, 13, 47, 70, 111, 110, 116, 78,
97, 109, 101, 32, 47, 67, 111, 117, 114, 105, 101, 114, 49, 48,
80, 105, 116, 99, 104, 66, 84, 45, 66, 111, 108, 100, 32, 100,
101, 102, 13, 47, 80, 97, 105, 110, 116, 84, 121, 112, 101, 32,
48, 32, 100, 101, 102, 13, 47, 70, 111, 110, 116, 84, 121, 112,
101, 32, 49, 32, 100, 101, 102, 13, 47, 70, 111, 110, 116, 77,
97, 116, 114, 105, 120, 32, 91, 48, 46, 48, 48, 49, 32, 48,
32, 48, 32, 48, 46, 48, 48, 49, 32, 48, 32, 48, 93, 32,
114, 101, 97, 100, 111, 110, 108, 121, 32, 100, 101, 102, 13, 47,
69, 110, 99, 111, 100, 105, 110, 103, 32, 83, 116, 97, 110, 100,
97, 114, 100, 69, 110, 99, 111, 100, 105, 110, 103, 32, 100, 101,
102, 13, 47, 70, 111, 110, 116, 66, 66, 111, 120, 32, 123, 45,
52, 52, 32, 45, 51, 48, 57, 32, 54, 54, 52, 32, 56, 55,
53, 125, 32, 114, 101, 97, 100, 111, 110, 108, 121, 32, 100, 101,
102, 13, 47, 85, 110, 105, 113, 117, 101, 73, 68, 32, 49, 53,
53, 51, 48, 53, 56, 51, 32, 100, 101, 102, 13, 99, 117, 114,
114, 101, 110, 116, 100, 105, 99, 116, 32, 101, 110, 100, 13, 99,
117, 114, 114, 101, 110, 116, 102, 105, 108, 101, 32, 101, 101, 120,
101, 99, 13, 128, 2, 73, 148, 0, 0, 162, 149, 24, 64, 131,
138, 65, 51, 131, 156, 169, 210, 46, 43, 153, 242, 182, 28, 118,
124, 214, 117, 8, 10, 172, 252, 178, 78, 25, 205, 19, 54, 115,
155, 182, 73, 148, 197, 103, 55, 9, 11, 76, 236, 146, 201, 148,
95, 240, 116, 94, 247, 255, 198, 27, 176, 169, 163, 184, 73, 231,
233, 135, 64, 229, 108, 11, 90, 247, 135, 85, 156, 198, 149, 106,
179, 30, 51, 207, 133, 83, 213, 92, 11, 14, 129, 142, 245, 236,
107, 244, 129, 98, 234, 196, 46, 115, 128, 202, 146, 29, 174, 28,
130, 179, 143, 214, 188, 242, 0, 26, 187, 93, 0, 26, 86, 21,
112, 148, 207, 226, 125, 143, 78, 172, 150, 147, 232, 131, 114, 210,
3, 88, 180, 126, 12, 56, 118, 85, 142, 191, 117, 122, 31, 188,
92, 28, 221, 246, 43, 60, 87, 191, 114, 126, 241, 196, 135, 148,
34, 193, 66, 160, 132, 209, 199, 70, 42, 194, 147, 224, 151, 250,
190, 58, 62, 207, 205, 130, 113, 242, 89, 131, 59, 172, 121, 18,
112, 114, 24, 236, 154, 48, 99, 191, 115, 133, 224, 45, 140, 16,
88, 172, 6, 223, 0, 179, 59, 140, 1, 135, 104, 178, 120, 1,
14, 178, 127, 94, 177, 18, 214, 48, 220, 65, 177, 171, 175, 91,
243, 199, 6, 173, 165, 169, 173, 20, 196, 58, 195, 84, 191, 23,
205, 41, 104, 116, 142, 32, 16, 220, 114, 205, 102, 33, 131, 58,
163, 215, 21, 119, 224, 110, 14, 31, 218, 59, 15, 185, 149, 32,
233, 64, 65, 246, 154, 168, 212, 168, 175, 8, 134, 218, 55, 5,
106, 178, 253, 94, 233, 232, 12, 153, 52, 239, 27, 169, 57, 42,
223, 14, 79, 43, 133, 55, 107, 42, 50, 205, 40, 168, 17, 227,
134, 242, 216, 168, 15, 63, 55, 32, 43, 128, 2, 95, 4, 186,
170, 6, 99, 98, 98, 146, 172, 133, 121, 105, 97, 74, 175, 65,
0, 87, 20, 113, 32, 207, 132, 86, 161, 57, 250, 247, 56, 9,
128, 215, 253, 112, 74, 201, 69, 151, 118, 212, 240, 20, 117, 6,
158, 249, 58, 18, 35, 205, 136, 219, 104, 59, 141, 53, 8, 217,
10, 114, 153, 252, 231, 71, 226, 67, 41, 227, 44, 254, 203, 75,
247, 216, 203, 56, 96, 149, 196, 27, 194, 98, 117, 36, 17, 179,
129, 73, 8, 229, 197, 196, 141, 252, 60, 15, 176, 191, 181, 212,
254, 155, 236, 28, 108, 191, 205, 88, 14, 180, 198, 155, 192, 195,
94, 253, 92, 28, 104, 9, 147, 53, 123, 162, 115, 183, 66, 172,
212, 196, 51, 106, 67, 205, 86, 82, 128, 200, 234, 42, 160, 87,
5, 195, 82, 235, 89, 48, 139, 173, 206, 175, 95, 6, 62, 237,
51, 96, 169, 190, 94, 125, 104, 58, 89, 143, 233, 39, 177, 182,
182, 241, 240, 50, 184, 87, 114, 240, 85, 250, 248, 225, 87, 220,
114, 52, 15, 237, 154, 207, 224, 133, 64, 223, 186, 85, 155, 18,
162, 218, 2, 58, 3, 47, 193, 241, 51, 209, 57, 199, 70, 52,
4, 123, 0, 102, 189, 225, 6, 191, 4, 219, 130, 198, 67, 216,
90, 147, 231, 30, 134, 172, 176, 250, 159, 140, 47, 148, 168, 17,
69, 87, 16, 121, 183, 7, 208, 86, 186, 208, 75, 111, 171, 125,
202, 225, 98, 139, 206, 218, 110, 191, 48, 65, 56, 101, 56, 216,
222, 34, 99, 232, 26, 249, 61, 218, 90, 173, 82, 72, 200, 193,
145, 118, 21, 215, 175, 91, 115, 125, 154, 204, 222, 110, 255, 206,
97, 25, 136, 50, 1, 240, 144, 192, 169, 131, 119, 167, 222, 63,
20, 15, 107, 212, 201, 228, 28, 53, 85, 201, 129, 81, 6, 60,
141, 160, 196, 111, 241, 217, 136, 89, 17, 20, 137, 165, 198, 43,
128, 96, 53, 230, 141, 187, 249, 76, 210, 154, 105, 51, 14, 150,
194, 1, 170, 21, 46, 222, 224, 200, 83, 161, 215, 25, 75, 201,
153, 94, 250, 148, 77, 87, 98, 34, 196, 2, 220, 130, 39, 109,
202, 71, 150, 158, 76, 194, 210, 174, 65, 117, 254, 19, 109, 137,
200, 177, 97, 233, 161, 227, 41, 136, 163, 89, 146, 255, 133, 128,
156, 113, 222, 89, 167, 116, 86, 214, 64, 72, 57, 106, 97, 195,
216, 137, 242, 42, 161, 214, 21, 180, 168, 59, 38, 27, 21, 83,
123, 55, 133, 43, 203, 195, 129, 48, 51, 165, 208, 159, 99, 228,
66, 197, 67, 193, 212, 89, 65, 199, 63, 105, 86, 230, 190, 204,
72, 226, 245, 139, 86, 118, 59, 154, 155, 68, 240, 167, 144, 180,
99, 97, 158, 170, 89, 161, 160, 251, 245, 102, 67, 2, 150, 97,
86, 222, 155, 102, 163, 192, 145, 127, 207, 55, 237, 237, 135, 34,
154, 10, 95, 202, 196, 96, 18, 243, 164, 254, 253, 77, 202, 104,
80, 47, 19, 114, 220, 189, 16, 253, 167, 88, 142, 142, 26, 14,
156, 95, 158, 214, 229, 161, 132, 60, 134, 85, 252, 233, 118, 48,
135, 104, 190, 71, 102, 85, 73, 95, 90, 235, 30, 250, 34, 187,
74, 216, 17, 86, 177, 200, 185, 108, 186, 110, 119, 170, 59, 62,
147, 157, 243, 59, 151, 101, 229, 57, 175, 191, 43, 104, 10, 118,
75, 175, 231, 218, 244, 75, 43, 1, 127, 8, 110, 80, 177, 233,
210, 162, 210, 102, 142, 219, 185, 214, 176, 97, 227, 143, 196, 96,
33, 240, 57, 23, 105, 23, 208, 254, 116, 148, 247, 104, 9, 29,
80, 251, 153, 127, 248, 244, 94, 230, 31, 153, 3, 25, 94, 170,
55, 218, 15, 37, 4, 145, 136, 187, 237, 162, 205, 0, 133, 199,
146, 223, 117, 31, 135, 98, 161, 46, 107, 22, 213, 223, 198, 163,
86, 58, 98, 214, 15, 123, 92, 5, 42, 234, 7, 131, 116, 206,
124, 7, 242, 73, 189, 74, 183, 244, 175, 156, 222, 173, 79, 70,
2, 149, 127, 49, 163, 76, 209, 163, 111, 92, 49, 50, 88, 113,
236, 73, 117, 95, 92, 195, 187, 41, 171, 58, 163, 83, 66, 41,
184, 103, 135, 112, 209, 131, 27, 61, 140, 23, 103, 99, 254, 70,
23, 226, 211, 118, 22, 30, 245, 25, 43, 189, 55, 177, 188, 113,
219, 84, 28, 193, 218, 4, 101, 35, 27, 242, 129, 235, 249, 76,
71, 84, 228, 112, 88, 2, 64, 103, 72, 182, 67, 195, 127, 191,
176, 37, 140, 213, 154, 147, 13, 31, 37, 178, 205, 238, 83, 31,
81, 71, 216, 38, 152, 250, 61, 10, 60, 10, 10, 179, 207, 107,
84, 103, 254, 243, 39, 124, 29, 174, 42, 117, 207, 140, 22, 46,
122, 72, 82, 52, 92, 238, 58, 125, 123, 111, 213, 150, 97, 87,
30, 66, 186, 218, 153, 210, 182, 176, 159, 246, 180, 184, 214, 218,
92, 200, 230, 66, 82, 23, 206, 228, 33, 234, 76, 195, 236, 25,
209, 81, 210, 160, 154, 115, 181, 128, 170, 37, 121, 26, 0, 4,
85, 170, 53, 147, 218, 10, 172, 57, 73, 137, 45, 17, 66, 164,
121, 34, 98, 164, 210, 246, 229, 232, 226, 238, 188, 92, 102, 168,
8, 25, 125, 22, 47, 28, 26, 172, 145, 213, 74, 222, 70, 98,
197, 234, 171, 200, 84, 13, 86, 106, 165, 121, 63, 182, 88, 201,
174, 235, 67, 248, 7, 47, 9, 97, 94, 41, 35, 129, 159, 173,
156, 200, 123, 133, 46, 102, 248, 16, 27, 57, 22, 102, 241, 122,
147, 103, 53, 216, 33, 132, 42, 52, 193, 73, 67, 153, 123, 208,
107, 60, 70, 76, 249, 196, 159, 207, 218, 163, 189, 103, 239, 0,
199, 150, 51, 237, 167, 31, 248, 20, 124, 127, 1, 69, 72, 51,
136, 63, 245, 25, 187, 69, 48, 21, 109, 238, 3, 140, 68, 107,
202, 46, 186, 156, 29, 132, 130, 204, 172, 135, 19, 86, 247, 21,
44, 199, 69, 1, 39, 35, 174, 124, 124, 173, 27, 183, 133, 221,
70, 190, 95, 235, 202, 45, 218, 45, 138, 152, 222, 33, 204, 137,
22, 37, 133, 147, 178, 61, 234, 41, 220, 37, 193, 39, 88, 210,
46, 105, 99, 176, 88, 135, 151, 23, 223, 170, 134, 52, 163, 240,
150, 190, 43, 156, 233, 127, 166, 170, 89, 50, 94, 83, 183, 73,
60, 170, 98, 48, 153, 252, 42, 106, 79, 56, 88, 103, 14, 125,
199, 107, 163, 96, 222, 170, 239, 205, 9, 17, 89, 123, 17, 187,
189, 117, 161, 80, 223, 150, 249, 103, 97, 238, 166, 192, 175, 18,
115, 34, 199, 243, 190, 216, 184, 8, 224, 21, 212, 58, 165, 1,
51, 174, 89, 160, 54, 51, 151, 200, 150, 12, 247, 71, 144, 39,
94, 3, 211, 201, 92, 168, 203, 23, 1, 117, 107, 15, 136, 245,
217, 107, 63, 190, 151, 84, 168, 181, 37, 210, 61, 193, 152, 4,
157, 16, 30, 38, 113, 138, 50, 236, 115, 217, 195, 208, 164, 109,
235, 29, 191, 80, 126, 78, 67, 233, 29, 151, 76, 139, 216, 94,
30, 3, 134, 167, 18, 12, 233, 163, 29, 160, 229, 83, 17, 199,
31, 133, 28, 14, 19, 125, 178, 232, 137, 253, 127, 80, 189, 133,
189, 149, 160, 231, 216, 211, 188, 148, 177, 53, 29, 198, 30, 49,
171, 213, 117, 194, 44, 169, 187, 150, 141, 129, 59, 164, 134, 128,
4, 20, 60, 222, 195, 98, 119, 189, 197, 195, 13, 229, 146, 81,
235, 231, 14, 6, 204, 75, 155, 124, 66, 33, 214, 230, 163, 233,
49, 162, 152, 238, 39, 29, 43, 165, 219, 221, 232, 24, 216, 91,
209, 196, 93, 77, 249, 194, 184, 95, 6, 8, 9, 121, 231, 62,
60, 46, 18, 220, 90, 91, 8, 250, 190, 75, 223, 124, 44, 57,
6, 190, 3, 182, 231, 106, 81, 58, 120, 163, 222, 163, 153, 123,
65, 70, 195, 187, 132, 122, 96, 234, 138, 134, 210, 58, 130, 180,
122, 86, 79, 209, 90, 52, 212, 184, 130, 39, 252, 113, 219, 195,
82, 109, 158, 106, 77, 12, 230, 93, 143, 127, 6, 39, 8, 192,
61, 56, 228, 237, 160, 190, 129, 201, 244, 251, 183, 122, 99, 70,
202, 190, 40, 93, 147, 194, 41, 98, 235, 117, 17, 15, 91, 147,
229, 149, 235, 61, 144, 33, 157, 234, 178, 22, 105, 57, 121, 172,
157, 131, 183, 181, 105, 151, 252, 248, 231, 48, 1, 70, 127, 33,
172, 156, 231, 182, 206, 100, 40, 163, 126, 178, 35, 252, 213, 112,
195, 115, 218, 255, 20, 119, 25, 194, 22, 183, 137, 207, 42, 61,
13, 151, 31, 196, 79, 65, 83, 85, 101, 89, 14, 136, 46, 245,
146, 14, 138, 166, 187, 12, 34, 213, 114, 182, 145, 225, 129, 90,
114, 189, 106, 108, 123, 160, 47, 68, 7, 149, 42, 79, 44, 141,
19, 117, 210, 157, 248, 172, 17, 189, 82, 252, 32, 19, 139, 13,
64, 44, 15, 38, 39, 56, 149, 224, 111, 198, 71, 126, 121, 116,
242, 13, 3, 64, 136, 115, 18, 155, 3, 177, 139, 249, 225, 136,
142, 73, 125, 50, 226, 193, 226, 244, 54, 146, 185, 87, 166, 196,
14, 230, 242, 230, 57, 176, 72, 163, 178, 253, 250, 145, 46, 194,
177, 112, 109, 45, 143, 23, 230, 167, 15, 30, 247, 78, 255, 176,
119, 221, 136, 35, 22, 3, 181, 102, 127, 82, 83, 216, 5, 234,
240, 173, 28, 124, 206, 221, 91, 109, 230, 52, 121, 40, 148, 72,
186, 54, 51, 169, 167, 91, 132, 97, 112, 224, 14, 8, 126, 12,
22, 104, 143, 191, 216, 228, 175, 236, 56, 107, 224, 231, 90, 28,
69, 132, 0, 39, 23, 0, 60, 98, 86, 48, 15, 119, 96, 117,
140, 28, 109, 195, 0, 92, 167, 91, 188, 144, 22, 191, 230, 45,
199, 239, 181, 3, 38, 15, 144, 118, 131, 201, 79, 48, 16, 205,
159, 143, 14, 11, 20, 90, 121, 161, 232, 174, 152, 61, 134, 240,
101, 119, 191, 253, 223, 226, 96, 46, 55, 80, 145, 72, 57, 182,
152, 91, 225, 223, 142, 139, 219, 133, 183, 176, 12, 144, 57, 24,
77, 14, 11, 10, 124, 177, 244, 67, 19, 31, 184, 139, 243, 212,
69, 118, 111, 219, 109, 96, 130, 72, 233, 100, 254, 28, 136, 89,
36, 63, 195, 160, 202, 177, 120, 28, 101, 103, 48, 226, 29, 41,
41, 235, 15, 45, 100, 56, 205, 117, 209, 56, 104, 38, 66, 1,
36, 233, 188, 146, 100, 179, 166, 212, 52, 131, 209, 3, 66, 230,
100, 219, 12, 92, 37, 247, 252, 152, 232, 241, 129, 237, 164, 199,
185, 158, 2, 255, 111, 144, 205, 67, 177, 17, 131, 140, 35, 190,
188, 106, 115, 204, 168, 167, 232, 76, 81, 33, 155, 100, 194, 226,
235, 72, 225, 214, 168, 103, 210, 72, 164, 180, 208, 152, 5, 123,
199, 53, 186, 162, 110, 241, 255, 184, 172, 154, 125, 193, 167, 196,
14, 45, 55, 43, 182, 177, 2, 185, 36, 95, 46, 148, 51, 147,
243, 89, 64, 155, 159, 154, 160, 230, 29, 3, 229, 111, 119, 207,
119, 62, 113, 0, 58, 135, 134, 53, 30, 5, 171, 113, 234, 116,
12, 18, 15, 198, 198, 180, 250, 227, 67, 75, 29, 243, 40, 231,
233, 40, 41, 110, 96, 194, 200, 44, 22, 245, 139, 200, 89, 50,
23, 50, 182, 182, 193, 28, 120, 151, 231, 243, 165, 96, 60, 163,
94, 147, 85, 157, 143, 71, 244, 219, 152, 57, 187, 26, 246, 192,
185, 152, 14, 150, 40, 148, 170, 126, 105, 233, 83, 248, 61, 222,
30, 232, 230, 211, 11, 250, 211, 143, 75, 200, 180, 165, 42, 90,
108, 21, 252, 122, 63, 183, 217, 182, 130, 118, 55, 168, 2, 69,
58, 185, 188, 246, 37, 248, 49, 173, 144, 9, 237, 62, 176, 231,
158, 149, 52, 17, 53, 57, 9, 121, 109, 14, 11, 91, 89, 140,
72, 165, 3, 229, 228, 229, 77, 84, 78, 53, 75, 106, 218, 7,
22, 14, 189, 13, 31, 187, 228, 133, 91, 118, 90, 164, 81, 80,
180, 215, 153, 145, 227, 214, 110, 210, 228, 147, 115, 241, 209, 228,
104, 11, 197, 31, 228, 82, 251, 201, 147, 134, 151, 124, 59, 103,
24, 23, 19, 244, 56, 112, 145, 193, 49, 59, 150, 61, 135, 105,
104, 2, 51, 181, 251, 65, 24, 169, 162, 120, 154, 80, 96, 232,
11, 168, 65, 87, 129, 107, 35, 60, 159, 139, 144, 42, 216, 192,
13, 235, 172, 245, 154, 136, 226, 83, 126, 255, 223, 46, 34, 140,
129, 248, 186, 32, 223, 33, 119, 242, 240, 136, 208, 199, 229, 10,
36, 255, 222, 41, 208, 131, 64, 81, 45, 165, 67, 37, 218, 40,
64, 131, 231, 144, 193, 246, 51, 40, 118, 237, 141, 206, 117, 227,
82, 85, 228, 143, 232, 91, 236, 225, 201, 101, 113, 54, 169, 131,
151, 221, 12, 67, 211, 243, 120, 170, 71, 154, 238, 197, 123, 81,
128, 56, 31, 157, 210, 159, 60, 99, 49, 73, 254, 88, 234, 141,
23, 137, 112, 159, 38, 234, 210, 139, 152, 223, 29, 181, 149, 60,
183, 216, 57, 104, 245, 80, 243, 66, 88, 188, 194, 180, 177, 8,
46, 4, 202, 65, 64, 109, 66, 97, 95, 73, 246, 254, 161, 100,
147, 199, 40, 232, 228, 104, 101, 158, 211, 213, 94, 240, 169, 109,
76, 89, 18, 85, 196, 45, 138, 63, 168, 157, 89, 55, 111, 134,
133, 64, 232, 195, 5, 35, 88, 128, 102, 195, 5, 151, 4, 250,
224, 25, 113, 22, 24, 10, 96, 241, 32, 230, 31, 67, 84, 0,
221, 83, 184, 108, 220, 243, 9, 78, 52, 33, 161, 35, 221, 104,
221, 138, 85, 230, 99, 75, 125, 82, 74, 226, 168, 170, 25, 211,
130, 146, 242, 24, 46, 243, 63, 109, 240, 244, 129, 98, 227, 252,
111, 246, 114, 9, 162, 9, 189, 85, 14, 250, 54, 172, 217, 139,
15, 42, 225, 103, 143, 15, 71, 10, 84, 99, 176, 145, 209, 231,
218, 115, 32, 199, 25, 11, 202, 46, 36, 86, 30, 179, 154, 202,
190, 208, 164, 159, 125, 142, 205, 119, 84, 159, 41, 202, 141, 57,
25, 141, 93, 78, 63, 155, 109, 51, 21, 216, 3, 239, 211, 93,
211, 213, 101, 158, 248, 39, 254, 6, 7, 169, 246, 76, 95, 141,
148, 15, 204, 116, 196, 90, 179, 210, 205, 160, 48, 178, 87, 129,
121, 33, 213, 83, 102, 11, 181, 89, 50, 92, 137, 41, 36, 243,
119, 153, 29, 189, 30, 112, 238, 71, 209, 240, 22, 57, 236, 64,
68, 245, 83, 23, 211, 96, 16, 209, 205, 175, 211, 65, 137, 109,
116, 7, 205, 255, 166, 175, 51, 74, 47, 239, 8, 117, 10, 244,
70, 94, 59, 137, 5, 7, 24, 165, 133, 174, 210, 231, 206, 71,
20, 205, 41, 92, 234, 38, 220, 199, 60, 2, 178, 50, 70, 165,
155, 189, 20, 227, 151, 37, 60, 95, 166, 54, 239, 162, 63, 29,
111, 71, 193, 123, 229, 8, 213, 143, 75, 230, 70, 248, 66, 123,
180, 20, 155, 26, 48, 22, 192, 119, 38, 241, 200, 133, 190, 233,
224, 65, 88, 75, 139, 24, 44, 190, 40, 222, 121, 102, 13, 188,
99, 73, 149, 239, 26, 174, 87, 247, 18, 12, 192, 0, 172, 147,
58, 236, 210, 193, 46, 151, 241, 75, 130, 234, 191, 84, 24, 190,
34, 87, 71, 90, 101, 198, 205, 79, 234, 142, 25, 175, 97, 27,
182, 9, 77, 160, 78, 206, 78, 92, 37, 113, 232, 2, 89, 92,
239, 250, 209, 82, 42, 43, 140, 214, 189, 52, 165, 217, 14, 122,
158, 152, 17, 87, 128, 54, 20, 234, 170, 111, 194, 242, 157, 0,
195, 37, 250, 19, 178, 75, 28, 142, 51, 116, 152, 56, 162, 219,
59, 182, 59, 40, 194, 192, 88, 39, 94, 164, 105, 80, 67, 75,
49, 93, 36, 118, 199, 3, 231, 153, 117, 126, 72, 54, 50, 149,
250, 67, 124, 164, 130, 245, 222, 175, 161, 27, 162, 14, 116, 205,
184, 231, 176, 235, 14, 164, 250, 249, 136, 109, 199, 122, 229, 13,
227, 194, 48, 86, 191, 164, 27, 237, 50, 38, 81, 74, 113, 0,
192, 76, 139, 105, 70, 26, 187, 45, 237, 171, 6, 113, 249, 6,
213, 61, 28, 100, 127, 0, 146, 78, 228, 234, 228, 220, 123, 174,
188, 32, 117, 171, 110, 235, 125, 143, 236, 109, 128, 101, 240, 104,
221, 233, 28, 111, 94, 38, 150, 125, 108, 166, 246, 252, 133, 143,
18, 227, 109, 28, 141, 132, 104, 73, 25, 223, 72, 193, 12, 138,
229, 12, 226, 180, 33, 196, 99, 221, 187, 102, 231, 191, 85, 44,
162, 185, 20, 204, 93, 156, 233, 98, 60, 170, 91, 155, 80, 235,
66, 219, 242, 246, 98, 18, 191, 80, 139, 47, 222, 200, 102, 129,
166, 65, 66, 142, 197, 254, 137, 87, 193, 223, 195, 228, 16, 196,
106, 240, 7, 180, 84, 193, 141, 142, 113, 56, 81, 250, 58, 23,
62, 22, 39, 100, 36, 160, 106, 142, 100, 154, 78, 155, 236, 17,
125, 208, 111, 58, 250, 188, 137, 151, 171, 203, 209, 59, 18, 159,
30, 131, 203, 48, 2, 49, 139, 173, 189, 135, 89, 185, 190, 43,
169, 240, 205, 140, 76, 231, 91, 101, 227, 204, 112, 239, 153, 104,
119, 116, 41, 219, 155, 120, 155, 34, 33, 250, 88, 174, 154, 183,
243, 239, 28, 230, 186, 177, 35, 56, 173, 179, 30, 152, 112, 156,
108, 209, 45, 169, 4, 31, 222, 10, 224, 185, 47, 76, 228, 52,
2, 19, 217, 161, 217, 24, 51, 212, 254, 111, 236, 119, 87, 12,
247, 146, 106, 2, 68, 58, 224, 99, 114, 71, 145, 241, 219, 207,
241, 0, 233, 127, 197, 196, 52, 41, 173, 151, 0, 163, 114, 97,
220, 209, 138, 51, 211, 28, 177, 167, 51, 163, 58, 97, 212, 250,
43, 198, 168, 30, 248, 229, 197, 20, 144, 33, 41, 100, 16, 174,
167, 89, 3, 7, 128, 204, 236, 55, 190, 148, 157, 208, 143, 171,
58, 58, 176, 14, 192, 228, 8, 138, 35, 220, 189, 129, 234, 53,
247, 193, 26, 215, 202, 211, 88, 44, 193, 137, 1, 242, 118, 212,
123, 162, 242, 63, 210, 48, 107, 106, 71, 246, 196, 129, 85, 166,
154, 216, 149, 96, 14, 96, 102, 206, 92, 94, 220, 172, 85, 51,
111, 137, 108, 185, 62, 123, 155, 186, 254, 215, 50, 37, 26, 103,
224, 87, 238, 0, 90, 116, 183, 58, 47, 25, 240, 79, 129, 164,
171, 49, 128, 18, 34, 156, 154, 62, 183, 94, 105, 161, 239, 146,
21, 82, 102, 232, 5, 239, 99, 147, 118, 151, 113, 242, 208, 157,
254, 103, 88, 98, 102, 103, 234, 38, 4, 71, 31, 64, 243, 89,
210, 85, 200, 233, 143, 23, 166, 204, 60, 106, 6, 100, 64, 34,
224, 237, 89, 175, 119, 173, 146, 135, 92, 122, 181, 46, 137, 227,
90, 100, 125, 255, 220, 85, 215, 100, 80, 120, 141, 73, 119, 26,
158, 8, 32, 96, 238, 151, 89, 219, 33, 254, 147, 224, 26, 17,
78, 44, 27, 189, 99, 55, 135, 177, 250, 138, 57, 140, 205, 24,
123, 111, 50, 5, 239, 194, 22, 33, 156, 195, 255, 50, 26, 229,
22, 102, 16, 227, 60, 222, 179, 180, 118, 99, 220, 140, 140, 96,
23, 42, 112, 42, 34, 119, 13, 211, 58, 237, 213, 109, 229, 98,
156, 41, 32, 165, 55, 40, 116, 229, 1, 58, 78, 120, 105, 38,
63, 247, 127, 11, 184, 189, 31, 110, 232, 151, 168, 59, 24, 252,
196, 104, 154, 240, 38, 132, 57, 126, 118, 223, 192, 47, 33, 198,
129, 83, 138, 124, 74, 24, 251, 60, 123, 43, 54, 210, 101, 31,
171, 84, 122, 197, 41, 75, 106, 212, 13, 210, 243, 255, 92, 74,
218, 214, 186, 227, 167, 202, 84, 185, 89, 132, 183, 150, 241, 170,
234, 130, 8, 70, 84, 7, 222, 236, 7, 174, 240, 92, 171, 244,
22, 44, 29, 178, 28, 62, 151, 20, 72, 201, 65, 244, 125, 152,
97, 110, 52, 1, 209, 198, 188, 166, 108, 11, 63, 44, 68, 170,
174, 196, 194, 195, 118, 250, 23, 188, 156, 5, 146, 243, 24, 223,
44, 0, 33, 14, 5, 44, 91, 172, 69, 118, 123, 209, 32, 22,
151, 94, 65, 180, 44, 73, 229, 182, 60, 120, 245, 56, 38, 22,
192, 176, 91, 181, 39, 33, 23, 24, 123, 159, 8, 68, 194, 29,
119, 180, 109, 240, 39, 134, 173, 50, 67, 239, 12, 142, 57, 156,
108, 61, 23, 133, 44, 229, 210, 148, 115, 83, 120, 39, 89, 129,
172, 163, 203, 146, 223, 240, 243, 208, 235, 177, 206, 149, 237, 92,
78, 79, 26, 241, 134, 219, 204, 4, 187, 158, 3, 26, 199, 26,
247, 232, 247, 193, 202, 87, 164, 62, 66, 39, 232, 87, 183, 156,
152, 231, 20, 61, 191, 242, 29, 238, 221, 36, 212, 200, 180, 35,
249, 46, 234, 232, 22, 209, 242, 108, 187, 10, 42, 83, 31, 177,
204, 62, 89, 95, 58, 62, 109, 175, 134, 203, 184, 65, 11, 231,
69, 28, 244, 153, 53, 130, 83, 181, 199, 112, 171, 27, 16, 119,
185, 116, 12, 216, 138, 64, 148, 189, 123, 25, 202, 86, 100, 155,
212, 29, 9, 207, 43, 5, 192, 149, 165, 3, 138, 144, 102, 202,
148, 205, 91, 150, 11, 129, 208, 56, 201, 175, 255, 57, 196, 124,
63, 255, 74, 39, 32, 132, 113, 36, 238, 139, 222, 135, 70, 215,
130, 198, 233, 184, 244, 64, 67, 248, 188, 226, 2, 137, 82, 28,
3, 121, 146, 216, 186, 0, 102, 177, 59, 173, 122, 11, 89, 83,
178, 122, 182, 66, 254, 48, 103, 77, 14, 43, 249, 88, 249, 47,
210, 246, 134, 239, 255, 18, 125, 21, 192, 187, 158, 197, 34, 93,
243, 125, 239, 0, 39, 140, 73, 63, 161, 133, 172, 84, 174, 122,
217, 244, 49, 172, 83, 196, 34, 130, 39, 113, 154, 34, 85, 129,
31, 28, 20, 9, 36, 53, 166, 135, 169, 143, 196, 89, 156, 107,
113, 44, 213, 143, 196, 82, 237, 77, 41, 130, 130, 206, 99, 43,
20, 59, 104, 103, 208, 17, 94, 49, 196, 89, 8, 9, 147, 206,
158, 154, 68, 51, 235, 73, 102, 0, 37, 146, 220, 80, 253, 34,
32, 131, 234, 200, 31, 38, 159, 209, 165, 138, 53, 79, 159, 111,
79, 234, 42, 136, 202, 15, 14, 234, 34, 71, 174, 80, 207, 145,
59, 34, 207, 209, 22, 140, 231, 49, 75, 42, 143, 10, 166, 104,
173, 86, 112, 35, 60, 157, 223, 122, 120, 90, 197, 230, 114, 140,
7, 31, 197, 95, 94, 172, 57, 67, 150, 64, 129, 245, 19, 82,
83, 200, 83, 160, 237, 119, 247, 112, 157, 105, 62, 204, 166, 64,
32, 211, 12, 27, 157, 229, 205, 197, 3, 169, 248, 177, 183, 94,
10, 2, 228, 235, 96, 39, 226, 217, 227, 231, 213, 58, 176, 86,
187, 77, 29, 45, 74, 97, 235, 24, 111, 217, 158, 37, 201, 54,
97, 228, 38, 234, 81, 97, 250, 30, 186, 242, 184, 201, 243, 127,
35, 33, 213, 203, 102, 55, 141, 61, 113, 223, 29, 52, 178, 87,
246, 107, 216, 6, 220, 45, 81, 100, 13, 116, 148, 186, 198, 180,
12, 2, 230, 196, 72, 149, 202, 196, 41, 195, 54, 80, 52, 229,
22, 142, 31, 236, 211, 34, 251, 19, 166, 243, 128, 244, 70, 74,
93, 2, 247, 0, 46, 131, 22, 3, 64, 24, 170, 86, 138, 227,
2, 151, 248, 238, 49, 251, 36, 224, 253, 106, 139, 215, 157, 29,
223, 223, 195, 89, 238, 241, 172, 109, 130, 100, 62, 130, 146, 20,
52, 210, 139, 58, 156, 105, 143, 182, 228, 96, 32, 141, 191, 5,
48, 0, 169, 98, 129, 120, 176, 132, 39, 0, 12, 128, 238, 218,
237, 57, 246, 125, 23, 200, 201, 131, 63, 211, 25, 199, 99, 201,
233, 180, 59, 249, 30, 19, 4, 195, 239, 187, 100, 94, 195, 117,
148, 95, 117, 48, 66, 229, 80, 0, 106, 190, 64, 37, 146, 249,
25, 57, 64, 221, 230, 160, 100, 225, 23, 51, 173, 82, 4, 139,
58, 105, 25, 166, 240, 95, 196, 214, 60, 151, 149, 3, 146, 242,
159, 186, 160, 252, 13, 144, 219, 109, 107, 13, 185, 162, 188, 251,
143, 140, 198, 234, 60, 96, 143, 243, 121, 180, 130, 195, 156, 218,
55, 208, 105, 4, 18, 12, 132, 203, 116, 176, 163, 237, 174, 129,
24, 65, 87, 240, 107, 63, 79, 144, 254, 69, 206, 88, 120, 59,
77, 74, 6, 47, 130, 159, 108, 205, 135, 41, 130, 138, 223, 146,
233, 42, 31, 221, 85, 149, 27, 62, 193, 92, 108, 50, 85, 135,
183, 210, 93, 112, 139, 204, 54, 148, 216, 0, 152, 127, 218, 188,
155, 120, 6, 78, 23, 28, 30, 161, 78, 123, 142, 220, 29, 232,
19, 170, 38, 195, 194, 94, 55, 118, 146, 84, 152, 101, 26, 149,
104, 182, 44, 47, 153, 154, 193, 183, 245, 93, 250, 191, 223, 124,
85, 42, 27, 106, 240, 17, 159, 32, 30, 58, 175, 80, 76, 107,
190, 230, 3, 122, 229, 84, 164, 76, 2, 156, 227, 217, 192, 19,
31, 165, 217, 240, 29, 59, 33, 165, 150, 245, 171, 77, 14, 247,
46, 16, 218, 127, 111, 103, 43, 33, 4, 83, 63, 247, 24, 206,
145, 246, 125, 244, 106, 4, 68, 184, 123, 147, 151, 172, 109, 149,
155, 161, 20, 92, 34, 124, 128, 212, 140, 62, 116, 10, 32, 252,
225, 248, 32, 54, 26, 44, 199, 73, 209, 183, 212, 153, 149, 184,
195, 7, 226, 227, 11, 106, 185, 111, 122, 160, 46, 237, 234, 160,
110, 224, 98, 82, 54, 57, 133, 199, 11, 60, 32, 171, 112, 40,
115, 178, 60, 81, 194, 246, 169, 40, 69, 101, 162, 130, 199, 198,
226, 166, 198, 23, 146, 108, 162, 224, 3, 61, 241, 196, 224, 235,
242, 233, 184, 228, 212, 6, 234, 118, 114, 211, 195, 141, 119, 20,
146, 50, 115, 27, 160, 249, 128, 105, 160, 112, 105, 3, 184, 1,
190, 79, 113, 127, 108, 68, 213, 164, 163, 138, 152, 44, 2, 27,
98, 25, 247, 219, 245, 168, 69, 168, 54, 4, 60, 139, 210, 235,
41, 42, 221, 43, 20, 86, 68, 229, 186, 47, 228, 171, 70, 187,
22, 228, 239, 115, 168, 60, 27, 130, 222, 74, 25, 131, 87, 200,
207, 78, 118, 229, 23, 28, 61, 121, 61, 103, 137, 248, 205, 98,
142, 113, 116, 74, 2, 51, 81, 202, 227, 214, 76, 195, 201, 167,
253, 123, 28, 98, 243, 244, 138, 237, 23, 219, 227, 18, 79, 159,
71, 230, 117, 67, 54, 53, 172, 196, 21, 172, 87, 99, 121, 72,
119, 132, 178, 0, 69, 85, 177, 228, 119, 131, 165, 156, 75, 17,
38, 221, 201, 142, 3, 214, 200, 125, 248, 29, 156, 7, 196, 1,
190, 90, 167, 116, 112, 218, 107, 96, 69, 156, 72, 128, 210, 43,
76, 209, 210, 38, 246, 41, 212, 3, 184, 180, 149, 36, 239, 156,
56, 253, 194, 242, 178, 160, 38, 174, 98, 51, 97, 117, 161, 88,
20, 250, 100, 185, 102, 91, 14, 67, 177, 105, 247, 47, 163, 95,
252, 25, 162, 255, 111, 131, 220, 152, 210, 248, 22, 169, 27, 81,
170, 10, 254, 206, 20, 151, 152, 73, 251, 55, 124, 180, 163, 141,
12, 48, 90, 13, 102, 91, 83, 104, 45, 81, 147, 134, 114, 226,
7, 170, 53, 56, 232, 161, 255, 225, 64, 103, 110, 120, 79, 123,
21, 249, 218, 163, 171, 51, 41, 149, 251, 177, 187, 236, 206, 159,
143, 14, 11, 20, 90, 121, 161, 232, 174, 152, 61, 134, 240, 101,
119, 191, 253, 213, 244, 156, 203, 37, 214, 206, 220, 190, 165, 118,
56, 9, 249, 49, 89, 147, 80, 152, 254, 23, 90, 151, 163, 184,
148, 55, 206, 151, 157, 220, 33, 241, 152, 163, 234, 178, 213, 27,
136, 227, 235, 9, 172, 169, 68, 54, 231, 247, 156, 155, 133, 240,
42, 220, 199, 82, 155, 232, 40, 124, 2, 231, 147, 152, 169, 156,
73, 73, 235, 236, 159, 181, 206, 1, 24, 83, 52, 6, 225, 112,
145, 157, 58, 132, 168, 16, 229, 168, 137, 252, 4, 149, 208, 69,
232, 93, 171, 113, 60, 207, 203, 80, 49, 73, 229, 89, 13, 205,
86, 132, 225, 38, 48, 244, 212, 199, 204, 164, 144, 26, 88, 133,
249, 29, 171, 47, 61, 139, 217, 252, 109, 162, 170, 117, 146, 13,
122, 13, 185, 56, 43, 173, 159, 13, 15, 111, 48, 119, 103, 140,
50, 19, 50, 101, 247, 36, 112, 77, 2, 131, 221, 165, 67, 112,
178, 53, 24, 251, 250, 88, 85, 18, 21, 63, 235, 207, 199, 77,
203, 154, 114, 243, 143, 234, 141, 191, 223, 132, 199, 61, 222, 232,
92, 230, 31, 145, 19, 100, 3, 243, 116, 220, 25, 155, 41, 40,
206, 18, 13, 60, 244, 21, 134, 25, 37, 213, 213, 220, 247, 177,
153, 179, 159, 249, 136, 225, 238, 223, 77, 171, 83, 140, 40, 10,
134, 126, 238, 115, 59, 88, 101, 86, 220, 31, 222, 123, 6, 156,
119, 17, 12, 211, 113, 88, 226, 196, 4, 135, 28, 211, 240, 55,
117, 213, 204, 28, 169, 103, 15, 169, 42, 106, 34, 80, 215, 25,
81, 80, 251, 223, 157, 41, 188, 132, 96, 52, 10, 55, 181, 188,
165, 193, 34, 23, 80, 23, 32, 150, 253, 192, 205, 148, 227, 76,
113, 182, 117, 0, 45, 118, 106, 115, 243, 229, 31, 217, 22, 113,
69, 176, 222, 71, 209, 252, 251, 154, 202, 219, 106, 87, 196, 179,
9, 193, 28, 72, 69, 189, 76, 93, 64, 37, 148, 123, 53, 253,
101, 147, 32, 49, 104, 251, 89, 219, 163, 16, 168, 39, 48, 6,
149, 165, 193, 131, 15, 254, 149, 236, 0, 63, 158, 168, 201, 200,
40, 44, 161, 208, 37, 114, 211, 31, 13, 35, 93, 45, 115, 124,
4, 10, 54, 42, 33, 134, 103, 177, 157, 193, 132, 131, 149, 203,
50, 189, 193, 12, 33, 97, 41, 100, 179, 8, 134, 120, 178, 191,
199, 160, 167, 206, 214, 33, 53, 10, 235, 130, 151, 44, 156, 243,
6, 107, 209, 248, 207, 255, 195, 192, 22, 242, 165, 185, 231, 203,
118, 81, 204, 237, 77, 204, 173, 29, 165, 221, 115, 154, 186, 88,
224, 189, 250, 46, 59, 92, 223, 186, 20, 192, 67, 202, 132, 198,
169, 37, 86, 62, 190, 177, 192, 84, 49, 32, 255, 170, 111, 100,
209, 224, 50, 221, 6, 81, 219, 222, 160, 224, 105, 18, 31, 53,
101, 253, 131, 195, 8, 243, 41, 193, 147, 186, 144, 12, 129, 75,
165, 231, 14, 179, 53, 189, 236, 11, 13, 200, 34, 100, 162, 217,
57, 194, 53, 5, 181, 59, 97, 81, 159, 129, 212, 21, 39, 147,
38, 65, 102, 71, 186, 144, 198, 12, 219, 254, 202, 163, 175, 252,
229, 112, 96, 121, 82, 223, 87, 23, 4, 193, 250, 198, 143, 106,
34, 12, 120, 155, 22, 35, 113, 14, 100, 194, 82, 122, 243, 64,
116, 134, 132, 80, 239, 13, 1, 223, 4, 0, 34, 102, 149, 115,
176, 46, 243, 214, 118, 106, 158, 202, 16, 53, 125, 132, 79, 75,
46, 209, 104, 255, 254, 143, 146, 11, 91, 79, 205, 72, 161, 133,
161, 125, 205, 96, 117, 212, 10, 56, 237, 71, 29, 40, 208, 157,
22, 105, 43, 237, 98, 171, 142, 49, 91, 246, 41, 152, 95, 37,
3, 181, 86, 168, 234, 108, 174, 131, 139, 143, 103, 46, 153, 156,
167, 194, 192, 118, 138, 151, 170, 175, 133, 61, 52, 113, 148, 123,
95, 125, 10, 26, 31, 223, 232, 90, 217, 86, 121, 25, 134, 217,
46, 252, 197, 118, 202, 231, 20, 161, 190, 181, 91, 9, 195, 94,
227, 113, 190, 208, 235, 69, 92, 249, 136, 231, 46, 4, 66, 124,
83, 224, 183, 108, 11, 103, 240, 38, 226, 95, 12, 84, 226, 124,
84, 234, 58, 116, 188, 254, 166, 151, 203, 112, 230, 117, 161, 6,
100, 125, 134, 89, 19, 172, 132, 218, 66, 70, 27, 95, 20, 175,
116, 147, 221, 177, 174, 162, 78, 66, 69, 31, 54, 163, 184, 61,
61, 213, 230, 29, 91, 133, 198, 223, 96, 184, 108, 188, 149, 28,
85, 232, 50, 154, 60, 253, 93, 253, 91, 103, 139, 111, 25, 12,
207, 135, 10, 173, 138, 140, 9, 192, 65, 4, 47, 93, 181, 65,
194, 230, 226, 37, 211, 200, 59, 216, 113, 228, 183, 35, 64, 103,
90, 197, 133, 80, 47, 139, 150, 40, 155, 117, 87, 80, 206, 18,
83, 37, 8, 182, 65, 26, 156, 82, 84, 194, 87, 130, 11, 134,
137, 215, 62, 193, 86, 26, 215, 86, 17, 7, 244, 58, 16, 206,
143, 31, 222, 1, 207, 133, 9, 155, 9, 118, 33, 238, 241, 134,
24, 143, 165, 79, 92, 66, 30, 149, 236, 254, 72, 197, 93, 226,
166, 131, 142, 232, 118, 77, 175, 107, 100, 48, 18, 100, 200, 166,
197, 151, 91, 62, 61, 247, 255, 129, 124, 216, 117, 162, 236, 83,
46, 175, 83, 207, 142, 154, 153, 149, 220, 225, 76, 179, 144, 187,
183, 17, 168, 29, 116, 34, 232, 13, 168, 35, 59, 248, 94, 212,
137, 249, 172, 59, 72, 191, 118, 239, 59, 144, 189, 166, 62, 239,
84, 239, 218, 22, 188, 162, 59, 156, 131, 242, 40, 208, 251, 252,
249, 93, 168, 155, 206, 46, 182, 39, 142, 100, 78, 132, 186, 36,
135, 164, 199, 134, 218, 114, 82, 128, 250, 26, 93, 15, 141, 162,
92, 193, 79, 114, 246, 76, 242, 29, 18, 135, 251, 7, 171, 51,
65, 30, 202, 79, 110, 211, 143, 83, 123, 35, 40, 52, 139, 11,
42, 209, 51, 113, 236, 133, 84, 187, 198, 145, 178, 213, 134, 159,
27, 192, 6, 52, 160, 190, 226, 33, 12, 85, 89, 83, 15, 211,
34, 54, 200, 205, 232, 217, 83, 119, 224, 211, 247, 56, 120, 167,
37, 237, 168, 48, 190, 14, 123, 115, 114, 250, 64, 218, 119, 198,
45, 191, 14, 29, 16, 105, 176, 87, 177, 145, 169, 176, 192, 103,
59, 243, 195, 92, 66, 125, 167, 190, 223, 34, 246, 247, 163, 123,
72, 121, 236, 139, 185, 231, 227, 38, 85, 159, 191, 39, 195, 139,
227, 183, 3, 158, 88, 130, 169, 187, 205, 240, 31, 176, 128, 126,
149, 82, 169, 142, 14, 222, 244, 168, 62, 165, 90, 223, 248, 243,
19, 238, 126, 160, 89, 76, 220, 2, 42, 190, 26, 99, 129, 248,
160, 14, 109, 45, 31, 254, 190, 138, 30, 102, 46, 242, 213, 144,
59, 98, 107, 91, 72, 7, 86, 160, 210, 126, 14, 15, 172, 137,
190, 205, 175, 161, 246, 226, 2, 145, 254, 217, 139, 34, 136, 35,
148, 217, 197, 227, 155, 207, 93, 227, 9, 23, 12, 72, 88, 168,
20, 129, 3, 92, 169, 212, 132, 189, 95, 159, 16, 226, 245, 0,
229, 103, 140, 5, 38, 181, 67, 39, 131, 111, 170, 1, 196, 132,
166, 124, 110, 108, 21, 230, 15, 228, 37, 21, 36, 117, 47, 60,
118, 158, 131, 85, 60, 31, 138, 165, 150, 92, 152, 121, 0, 6,
4, 198, 203, 102, 135, 122, 121, 18, 230, 87, 92, 87, 14, 9,
174, 151, 112, 1, 192, 200, 147, 2, 61, 64, 77, 87, 88, 187,
160, 196, 176, 52, 2, 96, 93, 96, 217, 157, 236, 74, 252, 218,
165, 32, 126, 250, 31, 27, 151, 9, 190, 146, 173, 112, 206, 227,
202, 31, 203, 239, 84, 98, 28, 41, 117, 29, 60, 185, 224, 3,
136, 235, 208, 215, 191, 130, 117, 134, 205, 115, 138, 254, 144, 153,
96, 63, 249, 69, 63, 232, 140, 19, 164, 141, 142, 182, 86, 255,
92, 107, 138, 179, 193, 21, 77, 179, 123, 86, 176, 2, 66, 45,
193, 215, 74, 22, 247, 108, 124, 196, 207, 147, 153, 190, 233, 28,
153, 146, 31, 4, 145, 34, 91, 209, 178, 98, 15, 73, 11, 171,
11, 240, 60, 190, 249, 153, 202, 26, 179, 146, 63, 109, 0, 23,
200, 149, 134, 248, 47, 151, 199, 75, 58, 43, 137, 58, 162, 93,
32, 176, 155, 32, 113, 57, 62, 222, 20, 198, 38, 126, 162, 175,
87, 29, 84, 237, 254, 151, 239, 46, 24, 46, 172, 29, 176, 108,
60, 137, 67, 223, 229, 65, 114, 83, 102, 4, 126, 163, 98, 37,
170, 200, 112, 7, 251, 49, 58, 250, 196, 221, 29, 217, 222, 53,
47, 18, 184, 55, 84, 96, 46, 78, 220, 41, 172, 214, 233, 240,
45, 57, 240, 199, 10, 40, 232, 225, 236, 24, 63, 23, 42, 62,
173, 70, 197, 150, 98, 55, 199, 145, 180, 75, 212, 152, 192, 191,
255, 85, 58, 83, 190, 46, 81, 50, 161, 252, 61, 251, 8, 119,
15, 34, 61, 149, 172, 236, 95, 99, 17, 234, 77, 92, 225, 209,
219, 39, 220, 123, 247, 150, 79, 247, 15, 23, 225, 57, 212, 194,
199, 53, 188, 110, 47, 125, 71, 95, 6, 244, 81, 37, 232, 80,
182, 209, 109, 231, 87, 22, 13, 78, 109, 209, 173, 248, 150, 157,
212, 70, 161, 165, 136, 53, 248, 149, 34, 95, 223, 182, 59, 83,
178, 250, 75, 212, 44, 172, 78, 211, 142, 240, 247, 29, 197, 170,
122, 19, 197, 166, 215, 96, 113, 198, 225, 87, 61, 217, 2, 251,
158, 163, 90, 28, 2, 182, 65, 210, 248, 51, 57, 140, 38, 186,
59, 219, 51, 253, 188, 249, 34, 146, 6, 129, 39, 240, 220, 163,
243, 77, 55, 124, 81, 168, 255, 100, 181, 31, 180, 224, 131, 241,
174, 26, 158, 48, 167, 121, 117, 241, 9, 56, 211, 188, 104, 36,
211, 108, 90, 73, 24, 140, 212, 234, 122, 82, 229, 33, 95, 190,
124, 32, 189, 224, 202, 32, 213, 146, 119, 60, 29, 219, 44, 174,
103, 62, 50, 59, 135, 41, 246, 39, 204, 148, 68, 66, 7, 182,
14, 237, 252, 104, 124, 2, 112, 180, 176, 133, 29, 130, 246, 74,
135, 56, 97, 19, 147, 70, 200, 158, 227, 156, 181, 64, 120, 170,
243, 47, 115, 121, 69, 95, 175, 11, 252, 73, 214, 12, 242, 216,
232, 76, 158, 52, 99, 226, 112, 1, 89, 166, 207, 13, 177, 85,
182, 6, 44, 81, 109, 109, 245, 129, 141, 246, 56, 227, 36, 106,
155, 217, 188, 205, 216, 175, 61, 30, 110, 160, 64, 28, 84, 81,
227, 100, 174, 58, 244, 120, 83, 237, 64, 206, 109, 9, 153, 111,
115, 207, 158, 136, 165, 233, 133, 107, 187, 16, 235, 16, 219, 74,
5, 139, 152, 207, 239, 81, 10, 224, 67, 29, 60, 140, 245, 235,
158, 206, 252, 249, 130, 42, 253, 234, 184, 46, 190, 226, 87, 180,
50, 228, 179, 136, 208, 158, 7, 121, 191, 176, 157, 21, 183, 143,
56, 199, 125, 55, 29, 86, 144, 100, 24, 124, 52, 17, 5, 247,
172, 234, 86, 248, 21, 103, 130, 1, 107, 147, 140, 243, 72, 33,
94, 228, 16, 40, 220, 52, 237, 214, 185, 221, 51, 73, 210, 90,
120, 53, 221, 109, 15, 178, 231, 194, 229, 83, 7, 132, 117, 173,
201, 25, 228, 195, 102, 41, 147, 70, 138, 216, 254, 109, 88, 214,
71, 245, 84, 242, 9, 137, 114, 59, 27, 78, 222, 56, 143, 128,
219, 72, 68, 242, 196, 135, 248, 206, 157, 22, 182, 100, 234, 27,
225, 139, 227, 214, 79, 114, 234, 14, 185, 45, 145, 190, 163, 249,
235, 174, 194, 83, 174, 252, 86, 90, 132, 86, 42, 179, 32, 107,
128, 121, 117, 230, 158, 245, 178, 33, 51, 207, 224, 66, 131, 244,
192, 156, 173, 40, 198, 169, 155, 100, 75, 126, 8, 85, 15, 120,
143, 117, 49, 235, 223, 78, 50, 228, 251, 175, 114, 210, 20, 167,
35, 73, 109, 136, 130, 90, 215, 166, 49, 125, 70, 35, 140, 111,
156, 182, 71, 163, 51, 200, 127, 185, 212, 99, 45, 175, 134, 151,
39, 155, 93, 3, 158, 218, 221, 51, 230, 126, 68, 213, 248, 153,
232, 232, 110, 248, 182, 239, 228, 139, 230, 71, 18, 104, 147, 197,
88, 121, 207, 102, 219, 16, 110, 235, 149, 133, 44, 90, 221, 135,
151, 88, 161, 40, 117, 215, 68, 176, 223, 235, 166, 81, 17, 96,
108, 166, 248, 98, 243, 217, 224, 57, 203, 230, 72, 8, 230, 29,
213, 150, 186, 250, 42, 203, 128, 170, 115, 107, 232, 54, 205, 207,
90, 147, 198, 180, 245, 181, 152, 52, 93, 92, 137, 83, 75, 186,
180, 250, 48, 51, 114, 179, 7, 23, 194, 208, 148, 204, 147, 137,
254, 245, 168, 107, 189, 230, 212, 175, 46, 71, 208, 61, 92, 56,
86, 4, 108, 235, 190, 43, 23, 146, 233, 177, 254, 201, 111, 13,
172, 60, 2, 130, 247, 223, 77, 102, 232, 83, 222, 40, 111, 72,
142, 197, 93, 84, 10, 48, 77, 152, 215, 103, 239, 57, 122, 192,
23, 60, 242, 230, 169, 153, 152, 183, 33, 58, 166, 105, 40, 107,
58, 246, 40, 8, 146, 148, 134, 0, 189, 213, 47, 77, 75, 154,
167, 87, 113, 54, 207, 119, 47, 133, 2, 183, 245, 237, 103, 88,
191, 79, 22, 181, 10, 224, 189, 97, 91, 146, 204, 114, 200, 132,
246, 173, 59, 137, 49, 84, 13, 31, 146, 111, 204, 81, 35, 172,
207, 81, 76, 75, 24, 196, 205, 73, 251, 224, 110, 227, 146, 70,
97, 67, 89, 167, 54, 192, 62, 87, 195, 136, 170, 6, 13, 246,
192, 237, 230, 174, 172, 2, 237, 84, 7, 64, 4, 224, 252, 163,
204, 89, 117, 121, 159, 175, 86, 129, 250, 231, 106, 47, 227, 34,
103, 173, 181, 107, 99, 107, 135, 222, 156, 67, 36, 89, 236, 133,
105, 185, 171, 83, 46, 50, 236, 223, 208, 191, 147, 158, 185, 27,
115, 233, 52, 235, 202, 20, 240, 173, 228, 119, 39, 52, 194, 92,
191, 36, 154, 78, 135, 44, 59, 224, 13, 109, 164, 23, 137, 190,
90, 195, 119, 204, 237, 254, 125, 128, 60, 185, 177, 111, 141, 100,
79, 214, 92, 160, 51, 1, 226, 75, 50, 17, 54, 56, 140, 18,
32, 152, 11, 156, 252, 84, 151, 167, 126, 39, 17, 252, 215, 109,
174, 177, 223, 43, 120, 4, 251, 51, 113, 148, 173, 81, 249, 80,
113, 129, 58, 107, 170, 36, 123, 228, 15, 7, 249, 154, 155, 118,
121, 78, 8, 193, 45, 127, 117, 19, 118, 228, 191, 195, 168, 38,
159, 202, 241, 171, 215, 95, 145, 143, 89, 58, 7, 230, 32, 51,
192, 92, 227, 40, 141, 218, 5, 84, 143, 130, 137, 107, 15, 101,
215, 167, 155, 234, 242, 133, 139, 88, 31, 179, 137, 151, 104, 210,
157, 103, 55, 95, 149, 76, 232, 248, 186, 92, 149, 141, 73, 12,
74, 57, 168, 174, 167, 16, 64, 213, 220, 82, 24, 100, 77, 11,
99, 235, 31, 156, 46, 186, 198, 30, 23, 193, 78, 29, 80, 240,
213, 84, 245, 82, 187, 104, 227, 253, 163, 201, 194, 199, 57, 68,
67, 162, 167, 45, 3, 22, 145, 107, 86, 63, 110, 32, 211, 170,
194, 30, 226, 75, 64, 195, 153, 64, 12, 225, 237, 30, 122, 229,
252, 228, 4, 139, 118, 8, 20, 101, 48, 252, 174, 67, 158, 49,
70, 75, 59, 20, 41, 222, 123, 246, 146, 137, 94, 120, 17, 1,
178, 141, 138, 132, 122, 10, 84, 111, 232, 230, 145, 140, 80, 249,
32, 27, 5, 7, 177, 175, 100, 117, 226, 31, 138, 47, 224, 188,
131, 212, 52, 78, 255, 226, 88, 192, 87, 81, 66, 3, 255, 160,
235, 91, 160, 67, 114, 136, 13, 22, 184, 6, 232, 182, 162, 36,
65, 46, 200, 214, 190, 118, 107, 167, 128, 189, 146, 212, 42, 169,
214, 169, 244, 172, 53, 17, 166, 96, 252, 215, 251, 39, 63, 238,
97, 182, 164, 72, 206, 241, 238, 223, 143, 46, 207, 235, 170, 225,
255, 84, 251, 79, 59, 145, 221, 66, 124, 121, 185, 76, 148, 220,
68, 29, 68, 190, 103, 78, 75, 201, 231, 104, 202, 23, 109, 200,
108, 125, 182, 19, 84, 145, 38, 195, 183, 213, 56, 208, 131, 247,
117, 241, 108, 241, 149, 26, 85, 182, 102, 51, 51, 206, 52, 47,
225, 131, 52, 11, 238, 247, 202, 57, 252, 221, 93, 201, 88, 82,
67, 144, 154, 174, 251, 47, 133, 237, 96, 146, 252, 67, 75, 100,
65, 243, 58, 28, 125, 177, 97, 52, 227, 235, 68, 37, 219, 37,
6, 77, 232, 39, 94, 65, 202, 142, 152, 139, 91, 27, 66, 16,
49, 113, 202, 76, 33, 57, 196, 62, 95, 193, 15, 244, 143, 245,
33, 80, 107, 204, 149, 138, 171, 127, 231, 37, 214, 31, 176, 75,
131, 129, 211, 186, 3, 185, 4, 28, 223, 125, 211, 39, 21, 197,
94, 1, 213, 208, 137, 107, 156, 81, 82, 253, 115, 51, 79, 20,
215, 180, 182, 193, 35, 30, 86, 52, 151, 223, 147, 203, 243, 225,
212, 54, 48, 41, 133, 66, 166, 189, 75, 43, 58, 128, 78, 22,
54, 95, 192, 182, 222, 161, 61, 239, 245, 114, 40, 191, 108, 141,
89, 152, 142, 19, 120, 201, 203, 247, 9, 221, 110, 204, 2, 84,
168, 178, 6, 245, 112, 221, 93, 146, 18, 30, 11, 12, 235, 77,
102, 240, 207, 141, 41, 189, 31, 28, 166, 144, 229, 150, 191, 208,
146, 92, 185, 137, 92, 188, 102, 183, 194, 136, 228, 93, 98, 131,
239, 153, 227, 48, 28, 249, 247, 112, 179, 217, 7, 149, 82, 79,
92, 161, 100, 244, 215, 122, 176, 28, 233, 90, 139, 97, 251, 35,
98, 18, 245, 237, 100, 181, 186, 219, 24, 215, 68, 24, 113, 211,
31, 125, 143, 245, 95, 49, 144, 1, 82, 154, 7, 159, 47, 201,
64, 179, 197, 232, 21, 53, 36, 24, 68, 75, 148, 157, 26, 113,
3, 65, 71, 96, 28, 39, 70, 250, 135, 154, 236, 201, 53, 55,
203, 6, 114, 52, 29, 91, 10, 129, 252, 90, 239, 61, 214, 139,
248, 30, 32, 91, 72, 43, 3, 251, 16, 193, 176, 160, 71, 2,
228, 84, 190, 121, 82, 187, 53, 207, 245, 11, 188, 204, 69, 115,
254, 180, 57, 115, 98, 203, 143, 20, 212, 68, 205, 242, 42, 124,
246, 162, 232, 78, 42, 19, 190, 107, 120, 229, 254, 218, 133, 123,
223, 18, 89, 132, 85, 177, 252, 199, 31, 213, 90, 106, 143, 248,
112, 82, 96, 20, 177, 246, 184, 171, 159, 77, 162, 254, 37, 221,
90, 91, 135, 192, 20, 106, 141, 162, 246, 36, 103, 227, 183, 183,
236, 79, 165, 138, 70, 243, 85, 47, 130, 166, 183, 25, 177, 110,
191, 88, 29, 215, 218, 194, 191, 121, 57, 17, 157, 143, 116, 81,
168, 191, 82, 183, 31, 97, 119, 213, 250, 21, 220, 143, 217, 247,
245, 137, 87, 175, 157, 207, 148, 227, 52, 135, 124, 223, 157, 158,
117, 30, 35, 196, 56, 33, 18, 205, 130, 159, 110, 183, 55, 108,
83, 249, 108, 66, 58, 95, 204, 187, 65, 90, 164, 83, 63, 79,
27, 11, 244, 23, 26, 173, 170, 85, 25, 30, 161, 102, 137, 115,
32, 177, 1, 1, 161, 128, 81, 160, 192, 193, 21, 3, 90, 229,
74, 143, 194, 184, 113, 232, 10, 15, 117, 11, 205, 197, 39, 154,
66, 189, 124, 38, 122, 26, 154, 104, 178, 73, 164, 154, 242, 118,
23, 99, 62, 212, 7, 54, 199, 118, 67, 232, 157, 91, 227, 115,
194, 49, 65, 110, 74, 202, 79, 226, 156, 184, 72, 48, 215, 131,
106, 181, 206, 222, 135, 55, 42, 155, 60, 13, 186, 10, 200, 172,
223, 26, 206, 21, 64, 232, 39, 131, 137, 229, 58, 36, 145, 114,
155, 52, 37, 104, 70, 47, 35, 26, 97, 252, 89, 236, 150, 230,
251, 159, 24, 130, 43, 219, 164, 79, 62, 44, 162, 217, 189, 32,
160, 164, 163, 155, 199, 72, 47, 119, 1, 205, 88, 67, 151, 169,
116, 88, 0, 103, 102, 205, 191, 60, 129, 246, 39, 154, 129, 218,
191, 59, 172, 85, 1, 10, 196, 122, 192, 251, 66, 217, 16, 171,
205, 115, 17, 78, 130, 247, 138, 240, 64, 137, 244, 136, 165, 243,
242, 93, 177, 115, 255, 183, 127, 210, 116, 48, 46, 23, 27, 38,
201, 211, 167, 52, 57, 113, 202, 156, 139, 36, 75, 26, 213, 235,
120, 6, 184, 2, 175, 12, 111, 125, 228, 217, 19, 107, 136, 179,
82, 199, 56, 141, 72, 223, 17, 189, 253, 94, 186, 249, 232, 10,
248, 38, 44, 189, 0, 133, 19, 72, 172, 161, 166, 159, 132, 4,
207, 12, 196, 16, 108, 152, 130, 49, 254, 30, 97, 70, 187, 129,
6, 4, 80, 106, 32, 189, 79, 111, 45, 240, 142, 19, 239, 167,
5, 211, 23, 126, 58, 185, 4, 112, 74, 96, 120, 210, 101, 143,
196, 142, 74, 190, 16, 211, 122, 122, 248, 163, 202, 26, 247, 82,
227, 241, 187, 107, 195, 159, 250, 96, 192, 167, 208, 254, 43, 64,
205, 142, 227, 188, 53, 29, 196, 126, 132, 246, 255, 67, 69, 26,
37, 187, 219, 25, 179, 31, 205, 217, 88, 83, 186, 76, 169, 90,
38, 251, 79, 130, 105, 254, 137, 211, 142, 192, 217, 169, 134, 82,
176, 207, 207, 67, 40, 52, 186, 47, 69, 50, 53, 245, 73, 174,
118, 184, 12, 33, 196, 44, 88, 102, 86, 175, 94, 104, 195, 97,
227, 243, 129, 210, 207, 85, 3, 180, 145, 71, 236, 97, 180, 111,
73, 95, 189, 234, 15, 250, 37, 7, 24, 99, 204, 142, 39, 91,
28, 12, 44, 127, 190, 241, 242, 165, 223, 166, 239, 46, 18, 6,
26, 22, 87, 129, 186, 169, 36, 251, 76, 82, 61, 167, 144, 176,
13, 4, 170, 111, 171, 186, 44, 29, 42, 114, 11, 55, 243, 188,
21, 87, 144, 41, 108, 24, 179, 222, 151, 87, 124, 147, 207, 84,
113, 27, 236, 81, 52, 153, 152, 99, 71, 14, 158, 102, 153, 84,
109, 184, 171, 181, 90, 99, 141, 159, 110, 230, 6, 202, 236, 140,
188, 168, 176, 79, 51, 43, 20, 240, 127, 9, 60, 82, 210, 152,
21, 244, 46, 81, 104, 214, 225, 72, 43, 127, 51, 174, 255, 10,
174, 11, 20, 173, 124, 143, 240, 172, 43, 25, 63, 239, 152, 22,
45, 230, 134, 88, 190, 148, 251, 90, 30, 147, 148, 84, 150, 250,
18, 199, 175, 22, 191, 79, 164, 12, 155, 119, 40, 1, 57, 227,
69, 39, 164, 111, 123, 50, 212, 192, 137, 7, 209, 11, 216, 47,
55, 247, 140, 217, 153, 78, 150, 32, 101, 203, 224, 75, 4, 86,
199, 26, 147, 62, 119, 57, 119, 206, 83, 110, 179, 75, 70, 178,
132, 133, 206, 91, 109, 155, 151, 22, 111, 44, 157, 226, 190, 117,
73, 42, 159, 146, 42, 73, 237, 172, 109, 141, 191, 232, 72, 67,
12, 102, 72, 154, 244, 132, 159, 129, 112, 66, 161, 169, 157, 164,
14, 166, 74, 91, 111, 86, 9, 237, 151, 215, 140, 179, 228, 126,
75, 119, 129, 237, 254, 89, 189, 14, 154, 214, 110, 214, 50, 87,
78, 215, 206, 227, 157, 194, 216, 181, 181, 204, 144, 127, 216, 88,
44, 111, 171, 112, 134, 236, 90, 229, 53, 149, 144, 123, 231, 141,
251, 5, 140, 126, 156, 94, 2, 57, 244, 34, 203, 155, 111, 218,
214, 44, 83, 218, 50, 94, 240, 21, 146, 99, 43, 130, 227, 108,
43, 30, 152, 119, 168, 192, 254, 198, 22, 70, 171, 250, 203, 213,
55, 1, 71, 162, 116, 184, 0, 177, 133, 227, 42, 57, 179, 26,
109, 19, 37, 27, 126, 94, 89, 134, 170, 10, 43, 148, 155, 65,
7, 200, 6, 136, 75, 221, 180, 161, 97, 64, 221, 64, 229, 96,
153, 202, 246, 76, 108, 86, 250, 54, 141, 176, 32, 44, 219, 146,
243, 247, 27, 194, 70, 229, 252, 211, 95, 38, 172, 111, 136, 20,
134, 224, 94, 193, 14, 139, 236, 254, 124, 31, 209, 189, 230, 122,
134, 15, 230, 121, 242, 177, 113, 207, 124, 123, 128, 102, 42, 176,
117, 95, 173, 231, 236, 230, 57, 12, 10, 55, 94, 141, 239, 216,
156, 49, 167, 106, 69, 117, 78, 248, 221, 243, 239, 171, 5, 25,
174, 142, 22, 72, 125, 176, 5, 134, 248, 197, 233, 58, 233, 246,
69, 204, 180, 72, 170, 120, 148, 27, 13, 221, 82, 162, 152, 156,
17, 86, 237, 120, 44, 125, 156, 77, 108, 67, 233, 193, 231, 204,
17, 230, 199, 62, 61, 249, 203, 245, 244, 156, 211, 216, 65, 169,
118, 228, 50, 127, 144, 172, 101, 0, 129, 5, 81, 5, 136, 218,
247, 52, 88, 69, 103, 173, 223, 201, 255, 138, 116, 92, 68, 54,
65, 227, 1, 199, 225, 62, 203, 210, 252, 26, 182, 80, 105, 100,
68, 137, 61, 206, 212, 205, 148, 153, 28, 127, 38, 251, 234, 234,
189, 163, 82, 240, 29, 165, 244, 71, 201, 166, 202, 175, 144, 190,
142, 224, 205, 50, 11, 37, 188, 9, 221, 149, 198, 178, 87, 174,
136, 176, 211, 193, 117, 2, 47, 85, 244, 16, 194, 215, 36, 247,
224, 221, 85, 104, 7, 12, 38, 67, 225, 120, 161, 245, 195, 87,
167, 61, 243, 147, 144, 152, 217, 192, 226, 148, 178, 53, 10, 123,
190, 213, 190, 110, 134, 131, 123, 74, 147, 162, 88, 120, 18, 115,
31, 213, 143, 219, 211, 25, 0, 47, 179, 57, 156, 255, 157, 233,
120, 172, 131, 90, 40, 191, 28, 41, 53, 115, 72, 50, 181, 201,
167, 10, 216, 61, 132, 20, 49, 39, 184, 193, 86, 73, 22, 200,
238, 154, 5, 125, 174, 98, 159, 79, 165, 199, 214, 57, 100, 68,
158, 106, 86, 215, 155, 57, 226, 225, 26, 154, 63, 105, 125, 88,
86, 220, 118, 31, 134, 212, 84, 109, 140, 189, 244, 222, 191, 233,
133, 85, 80, 50, 84, 49, 248, 75, 153, 126, 156, 236, 244, 187,
226, 206, 63, 147, 35, 233, 41, 42, 106, 50, 125, 184, 17, 206,
169, 210, 170, 132, 150, 197, 227, 45, 81, 189, 159, 165, 162, 4,
185, 144, 203, 248, 114, 4, 84, 140, 48, 159, 23, 165, 176, 169,
47, 133, 145, 215, 129, 22, 200, 162, 65, 61, 181, 207, 240, 226,
35, 229, 191, 52, 254, 147, 184, 213, 254, 148, 34, 19, 104, 60,
46, 138, 89, 15, 78, 196, 252, 135, 48, 44, 241, 96, 149, 95,
87, 64, 67, 10, 37, 97, 8, 71, 87, 232, 45, 208, 248, 51,
175, 227, 34, 162, 19, 7, 39, 194, 128, 113, 179, 47, 182, 245,
109, 118, 81, 239, 115, 232, 26, 129, 243, 3, 98, 80, 8, 129,
201, 53, 2, 218, 132, 141, 158, 65, 96, 138, 235, 224, 132, 208,
64, 26, 211, 21, 106, 61, 138, 136, 144, 216, 158, 198, 80, 18,
56, 185, 209, 252, 254, 220, 112, 49, 208, 129, 108, 253, 171, 99,
206, 200, 137, 53, 85, 230, 86, 191, 129, 249, 158, 12, 80, 43,
9, 0, 129, 91, 172, 125, 182, 212, 190, 144, 211, 71, 211, 149,
58, 241, 131, 124, 113, 75, 174, 255, 207, 190, 122, 143, 204, 180,
254, 222, 211, 19, 191, 83, 102, 120, 33, 170, 179, 194, 112, 80,
93, 187, 92, 151, 47, 67, 210, 14, 81, 97, 199, 13, 87, 247,
34, 43, 129, 82, 174, 122, 30, 205, 129, 33, 133, 111, 69, 125,
209, 88, 242, 200, 142, 126, 63, 173, 201, 97, 202, 126, 215, 27,
176, 73, 112, 24, 40, 191, 229, 127, 228, 187, 116, 44, 237, 255,
4, 75, 219, 132, 59, 60, 4, 241, 223, 172, 124, 143, 165, 217,
156, 211, 77, 20, 47, 244, 91, 18, 201, 125, 198, 14, 211, 131,
22, 173, 202, 129, 214, 140, 116, 116, 194, 12, 23, 191, 211, 8,
210, 214, 241, 83, 236, 20, 3, 183, 231, 163, 230, 178, 99, 116,
122, 45, 84, 45, 167, 29, 217, 116, 36, 160, 124, 243, 13, 132,
119, 253, 144, 93, 150, 116, 98, 82, 12, 93, 156, 163, 43, 165,
94, 198, 135, 25, 75, 152, 158, 81, 37, 0, 25, 48, 66, 200,
177, 46, 56, 86, 206, 176, 136, 211, 115, 172, 62, 61, 0, 136,
85, 63, 59, 161, 221, 144, 58, 228, 78, 6, 199, 149, 123, 29,
119, 176, 79, 253, 109, 251, 107, 181, 23, 189, 66, 1, 210, 223,
112, 3, 5, 32, 42, 144, 59, 32, 223, 121, 208, 10, 192, 71,
5, 20, 188, 64, 240, 200, 178, 228, 175, 142, 13, 93, 251, 102,
129, 19, 144, 230, 210, 236, 252, 130, 244, 223, 138, 222, 198, 188,
166, 108, 62, 167, 238, 28, 27, 112, 95, 210, 242, 236, 223, 235,
130, 208, 60, 253, 22, 194, 163, 238, 53, 49, 165, 61, 7, 72,
91, 6, 42, 139, 150, 7, 208, 136, 238, 142, 238, 225, 75, 95,
34, 184, 7, 196, 107, 202, 162, 237, 52, 107, 226, 135, 30, 210,
70, 126, 155, 11, 71, 125, 24, 64, 91, 198, 175, 74, 198, 118,
16, 52, 136, 39, 203, 227, 11, 186, 39, 50, 135, 127, 164, 199,
31, 121, 127, 23, 184, 107, 76, 109, 223, 216, 34, 115, 35, 249,
26, 25, 197, 40, 231, 32, 4, 118, 237, 53, 49, 56, 132, 190,
192, 20, 6, 199, 247, 14, 23, 210, 81, 2, 213, 21, 230, 63,
99, 55, 221, 218, 102, 223, 202, 238, 192, 251, 63, 58, 67, 66,
95, 35, 154, 23, 108, 71, 247, 235, 99, 66, 179, 252, 194, 134,
247, 66, 178, 189, 6, 158, 158, 67, 112, 69, 217, 203, 53, 34,
79, 98, 172, 156, 78, 187, 37, 55, 163, 204, 231, 143, 233, 181,
54, 117, 116, 217, 73, 7, 44, 120, 163, 51, 183, 88, 176, 93,
165, 198, 62, 178, 125, 36, 140, 170, 41, 254, 27, 208, 208, 243,
209, 188, 40, 143, 141, 97, 167, 180, 30, 15, 175, 160, 233, 235,
37, 82, 182, 71, 74, 225, 140, 210, 87, 10, 22, 62, 112, 160,
195, 157, 71, 159, 67, 30, 17, 113, 227, 212, 184, 157, 8, 81,
112, 97, 245, 91, 174, 109, 32, 245, 84, 146, 76, 215, 64, 87,
201, 95, 143, 121, 252, 21, 23, 53, 92, 162, 164, 203, 117, 21,
228, 245, 69, 238, 49, 11, 51, 232, 212, 16, 84, 186, 122, 36,
37, 203, 244, 137, 139, 182, 19, 221, 129, 212, 147, 93, 111, 125,
184, 142, 227, 141, 118, 164, 19, 254, 179, 60, 28, 66, 254, 77,
188, 224, 46, 161, 155, 56, 198, 19, 6, 187, 94, 67, 59, 234,
24, 5, 144, 75, 89, 39, 108, 57, 25, 127, 113, 209, 164, 139,
56, 91, 235, 228, 99, 81, 245, 126, 109, 163, 46, 57, 122, 176,
191, 190, 141, 56, 23, 4, 0, 182, 200, 187, 183, 111, 99, 220,
115, 125, 108, 82, 90, 156, 108, 213, 126, 110, 213, 3, 248, 8,
101, 84, 187, 22, 199, 32, 115, 163, 70, 214, 108, 62, 152, 177,
176, 242, 7, 248, 149, 44, 128, 59, 178, 121, 197, 192, 159, 2,
246, 128, 65, 36, 97, 165, 232, 211, 225, 85, 123, 172, 203, 53,
44, 90, 163, 43, 249, 214, 31, 163, 119, 102, 208, 248, 239, 54,
217, 182, 181, 106, 79, 9, 229, 31, 137, 43, 85, 77, 86, 51,
193, 52, 209, 95, 84, 132, 49, 9, 54, 83, 86, 74, 182, 248,
98, 66, 15, 95, 76, 240, 52, 87, 133, 187, 145, 212, 135, 240,
4, 76, 19, 196, 30, 5, 132, 26, 198, 218, 248, 51, 108, 58,
33, 122, 189, 200, 235, 181, 45, 25, 35, 118, 62, 206, 87, 155,
183, 227, 177, 175, 203, 220, 97, 235, 55, 222, 242, 41, 42, 71,
56, 196, 236, 136, 197, 206, 246, 95, 241, 233, 7, 158, 254, 0,
52, 167, 247, 31, 188, 40, 18, 223, 253, 232, 10, 196, 41, 166,
169, 81, 236, 174, 217, 84, 233, 45, 247, 109, 167, 50, 4, 218,
60, 202, 159, 112, 144, 169, 219, 151, 112, 206, 44, 109, 211, 245,
194, 29, 202, 194, 7, 167, 21, 0, 137, 47, 27, 66, 183, 68,
89, 189, 138, 118, 44, 202, 34, 242, 227, 176, 124, 142, 99, 84,
34, 132, 73, 24, 102, 199, 53, 108, 140, 121, 88, 44, 187, 138,
182, 227, 185, 122, 159, 102, 40, 115, 66, 209, 2, 47, 87, 187,
106, 35, 91, 11, 97, 54, 42, 223, 47, 108, 219, 53, 122, 13,
239, 17, 20, 101, 45, 115, 87, 108, 93, 178, 185, 177, 64, 167,
104, 29, 20, 188, 193, 145, 170, 175, 7, 126, 20, 155, 210, 184,
178, 226, 115, 234, 96, 189, 110, 249, 191, 225, 219, 239, 94, 48,
253, 133, 151, 27, 208, 107, 58, 32, 62, 74, 251, 24, 230, 38,
40, 34, 24, 221, 215, 240, 160, 163, 0, 166, 116, 251, 48, 182,
141, 109, 115, 86, 122, 112, 207, 59, 54, 44, 43, 255, 85, 9,
237, 196, 48, 173, 254, 168, 233, 46, 117, 6, 52, 110, 192, 209,
202, 68, 230, 21, 85, 239, 112, 62, 96, 79, 220, 156, 255, 205,
230, 189, 50, 117, 90, 96, 98, 100, 44, 17, 71, 141, 78, 52,
109, 82, 218, 200, 55, 119, 64, 228, 132, 21, 40, 136, 36, 77,
193, 225, 75, 80, 163, 237, 20, 211, 106, 93, 18, 121, 230, 167,
136, 178, 109, 91, 17, 221, 9, 126, 205, 7, 184, 104, 176, 163,
28, 119, 25, 55, 135, 77, 24, 27, 104, 206, 146, 226, 41, 22,
65, 225, 50, 220, 135, 161, 44, 221, 124, 117, 97, 87, 5, 63,
131, 107, 96, 103, 96, 13, 204, 161, 163, 140, 215, 22, 237, 164,
166, 218, 64, 83, 52, 176, 117, 59, 39, 156, 206, 211, 223, 63,
78, 220, 159, 138, 77, 23, 227, 181, 153, 220, 39, 226, 165, 81,
89, 26, 199, 245, 13, 171, 45, 29, 10, 79, 106, 147, 104, 207,
28, 194, 233, 44, 177, 57, 143, 73, 170, 52, 46, 30, 24, 171,
97, 13, 16, 31, 138, 136, 0, 119, 35, 167, 119, 35, 231, 236,
136, 197, 112, 81, 17, 116, 54, 148, 213, 119, 242, 209, 155, 55,
49, 134, 202, 202, 48, 199, 217, 67, 64, 86, 87, 166, 245, 65,
37, 54, 125, 126, 228, 170, 10, 113, 83, 157, 179, 73, 208, 188,
99, 1, 198, 113, 11, 163, 243, 55, 198, 164, 57, 237, 83, 228,
11, 206, 143, 139, 19, 28, 230, 213, 232, 171, 213, 129, 226, 120,
238, 104, 198, 208, 124, 25, 176, 197, 52, 62, 21, 179, 89, 237,
217, 187, 232, 202, 6, 10, 69, 150, 236, 122, 120, 91, 164, 249,
116, 95, 206, 221, 4, 107, 204, 79, 73, 254, 138, 112, 225, 187,
145, 140, 62, 75, 32, 202, 7, 181, 242, 74, 101, 185, 24, 5,
44, 157, 0, 54, 157, 22, 56, 209, 216, 96, 220, 154, 241, 155,
136, 49, 243, 249, 84, 9, 99, 164, 236, 33, 78, 128, 38, 228,
249, 212, 60, 206, 99, 241, 191, 71, 173, 175, 92, 193, 152, 190,
93, 43, 172, 61, 56, 85, 232, 219, 156, 221, 59, 232, 158, 168,
162, 163, 173, 26, 226, 220, 85, 244, 11, 231, 30, 249, 30, 223,
45, 184, 190, 53, 29, 61, 160, 63, 168, 155, 254, 93, 106, 40,
190, 224, 57, 178, 174, 236, 142, 161, 121, 88, 33, 115, 92, 226,
10, 151, 167, 218, 240, 50, 84, 226, 139, 226, 227, 206, 169, 245,
253, 41, 92, 111, 37, 125, 56, 232, 86, 12, 177, 35, 105, 157,
176, 191, 104, 107, 93, 49, 11, 6, 199, 45, 211, 182, 93, 212,
177, 157, 5, 164, 54, 0, 110, 255, 225, 23, 3, 236, 199, 224,
203, 151, 87, 17, 180, 22, 59, 209, 187, 215, 116, 101, 122, 105,
102, 158, 195, 82, 166, 18, 156, 55, 89, 131, 107, 11, 210, 170,
82, 182, 45, 236, 128, 136, 90, 93, 105, 130, 9, 245, 219, 96,
155, 34, 133, 34, 220, 219, 26, 207, 38, 217, 91, 128, 212, 43,
155, 151, 100, 254, 110, 7, 153, 139, 53, 136, 3, 77, 168, 199,
9, 50, 52, 149, 119, 72, 225, 157, 219, 69, 155, 45, 98, 178,
254, 141, 14, 7, 64, 147, 252, 57, 202, 239, 78, 37, 76, 134,
113, 228, 96, 116, 224, 198, 74, 53, 95, 223, 25, 28, 237, 82,
21, 214, 65, 172, 121, 37, 133, 55, 192, 28, 71, 113, 184, 145,
216, 117, 103, 247, 149, 3, 115, 51, 94, 49, 12, 232, 152, 122,
118, 217, 20, 64, 114, 50, 30, 76, 128, 33, 54, 242, 147, 220,
243, 72, 87, 94, 1, 180, 253, 30, 91, 92, 75, 1, 94, 182,
47, 71, 7, 96, 246, 143, 65, 134, 32, 126, 218, 112, 72, 226,
147, 41, 168, 88, 234, 232, 92, 250, 132, 138, 103, 211, 91, 69,
186, 63, 237, 14, 146, 139, 135, 189, 225, 4, 248, 135, 194, 250,
69, 84, 205, 95, 104, 18, 105, 201, 78, 200, 32, 72, 154, 4,
63, 195, 235, 143, 199, 138, 41, 173, 55, 187, 45, 254, 80, 237,
1, 92, 166, 145, 197, 136, 61, 9, 49, 161, 237, 242, 121, 207,
11, 254, 3, 65, 63, 49, 123, 203, 166, 110, 2, 221, 86, 102,
133, 35, 12, 206, 53, 35, 47, 58, 60, 174, 123, 43, 126, 50,
29, 153, 130, 49, 101, 127, 243, 72, 214, 0, 204, 236, 66, 191,
138, 255, 3, 131, 75, 242, 192, 118, 34, 152, 84, 187, 63, 39,
71, 239, 159, 152, 241, 12, 78, 72, 56, 0, 111, 174, 238, 210,
141, 140, 114, 68, 114, 105, 118, 135, 170, 127, 5, 75, 75, 213,
142, 168, 182, 105, 160, 38, 187, 85, 171, 234, 149, 19, 47, 191,
206, 157, 136, 203, 181, 77, 255, 17, 109, 54, 96, 111, 134, 249,
102, 158, 5, 69, 123, 6, 118, 1, 64, 95, 245, 173, 201, 35,
54, 41, 144, 164, 40, 117, 212, 100, 89, 107, 137, 2, 180, 4,
103, 193, 134, 68, 131, 30, 44, 136, 171, 171, 101, 201, 92, 106,
89, 19, 162, 11, 138, 10, 54, 35, 155, 65, 163, 21, 189, 92,
26, 200, 188, 234, 86, 181, 245, 3, 120, 149, 110, 49, 146, 125,
154, 2, 93, 123, 7, 108, 57, 224, 29, 123, 150, 94, 167, 74,
152, 223, 30, 124, 197, 201, 176, 165, 163, 213, 34, 12, 16, 56,
94, 140, 218, 121, 146, 50, 215, 173, 84, 229, 184, 33, 254, 222,
129, 166, 223, 243, 62, 234, 76, 217, 98, 83, 178, 248, 75, 236,
228, 41, 47, 17, 37, 94, 94, 149, 85, 211, 167, 1, 137, 162,
2, 69, 139, 215, 174, 127, 155, 127, 202, 19, 109, 218, 137, 86,
214, 183, 15, 113, 59, 93, 74, 81, 146, 152, 102, 113, 247, 57,
253, 82, 57, 115, 13, 22, 106, 31, 224, 191, 103, 154, 5, 71,
250, 84, 4, 30, 27, 228, 124, 99, 83, 80, 148, 181, 34, 138,
34, 20, 90, 9, 122, 50, 109, 193, 119, 201, 156, 112, 195, 164,
56, 34, 251, 4, 238, 231, 206, 240, 212, 109, 86, 170, 93, 204,
210, 238, 158, 167, 144, 108, 33, 246, 122, 207, 238, 215, 196, 195,
223, 187, 137, 143, 95, 62, 15, 168, 13, 216, 212, 56, 41, 84,
22, 62, 137, 247, 16, 42, 8, 112, 0, 224, 49, 150, 248, 31,
139, 163, 98, 35, 187, 132, 228, 226, 47, 36, 97, 15, 48, 236,
85, 30, 228, 12, 96, 219, 129, 39, 28, 213, 54, 56, 145, 225,
204, 246, 186, 10, 29, 28, 97, 168, 217, 112, 213, 186, 89, 243,
175, 4, 23, 149, 62, 123, 101, 219, 100, 27, 227, 70, 144, 213,
144, 232, 30, 102, 231, 85, 76, 35, 174, 183, 254, 67, 162, 161,
219, 96, 34, 2, 122, 224, 205, 169, 136, 154, 21, 252, 247, 86,
20, 40, 45, 242, 204, 223, 159, 89, 118, 32, 18, 4, 199, 4,
95, 65, 121, 130, 179, 213, 204, 209, 246, 4, 83, 198, 150, 237,
153, 233, 193, 163, 170, 52, 161, 159, 134, 34, 206, 247, 219, 101,
250, 73, 155, 198, 28, 97, 78, 11, 48, 138, 168, 153, 63, 230,
237, 111, 240, 176, 207, 26, 66, 13, 124, 41, 65, 94, 202, 184,
39, 5, 86, 121, 90, 254, 131, 156, 199, 19, 77, 125, 227, 102,
154, 73, 221, 214, 223, 245, 8, 240, 249, 98, 64, 252, 26, 29,
39, 124, 43, 122, 54, 163, 224, 75, 36, 181, 171, 158, 124, 35,
146, 179, 2, 83, 177, 179, 113, 34, 114, 168, 30, 88, 182, 161,
129, 63, 37, 162, 63, 155, 76, 95, 109, 216, 74, 156, 126, 187,
189, 159, 69, 122, 108, 70, 191, 90, 235, 186, 80, 72, 227, 195,
124, 192, 187, 8, 5, 6, 9, 129, 144, 142, 223, 128, 43, 29,
221, 29, 90, 47, 69, 94, 126, 164, 141, 52, 12, 140, 154, 66,
100, 211, 137, 138, 140, 177, 23, 5, 150, 36, 102, 158, 134, 35,
85, 14, 103, 240, 200, 2, 132, 52, 65, 143, 168, 75, 143, 239,
41, 89, 153, 80, 217, 194, 89, 115, 28, 82, 180, 163, 168, 61,
30, 196, 172, 210, 182, 105, 240, 253, 252, 170, 233, 3, 137, 181,
59, 64, 242, 69, 145, 249, 216, 94, 102, 130, 186, 126, 234, 78,
253, 114, 30, 116, 26, 62, 137, 26, 156, 176, 47, 254, 186, 235,
108, 241, 21, 200, 0, 249, 53, 83, 175, 236, 238, 46, 185, 73,
185, 224, 128, 30, 115, 113, 166, 35, 0, 163, 69, 190, 126, 71,
58, 83, 171, 162, 31, 146, 215, 68, 237, 193, 206, 15, 144, 47,
6, 173, 233, 101, 20, 161, 96, 114, 140, 165, 195, 52, 207, 239,
135, 238, 152, 190, 94, 172, 199, 2, 36, 159, 21, 123, 226, 178,
115, 197, 244, 147, 52, 193, 234, 174, 184, 2, 175, 201, 118, 46,
121, 103, 213, 26, 223, 40, 125, 174, 92, 47, 218, 130, 92, 114,
203, 251, 115, 185, 163, 223, 104, 1, 125, 70, 35, 128, 152, 201,
155, 249, 170, 63, 149, 102, 54, 201, 198, 49, 213, 229, 41, 220,
194, 33, 252, 59, 137, 38, 74, 246, 138, 225, 24, 123, 145, 76,
237, 192, 188, 135, 223, 215, 176, 210, 91, 96, 172, 255, 100, 209,
188, 80, 84, 245, 77, 161, 215, 49, 105, 195, 219, 99, 143, 50,
186, 46, 109, 124, 2, 46, 147, 199, 78, 204, 197, 41, 15, 157,
198, 197, 234, 248, 188, 98, 206, 85, 189, 164, 89, 21, 4, 218,
125, 177, 145, 134, 121, 242, 28, 209, 223, 10, 21, 241, 32, 151,
202, 113, 216, 106, 234, 23, 206, 220, 14, 21, 178, 115, 234, 131,
62, 193, 65, 152, 72, 145, 111, 163, 141, 229, 188, 255, 111, 134,
98, 79, 48, 26, 129, 40, 236, 175, 138, 200, 68, 250, 66, 117,
28, 130, 113, 181, 242, 95, 40, 130, 17, 90, 115, 10, 241, 48,
212, 95, 172, 233, 239, 248, 203, 89, 11, 212, 244, 56, 115, 144,
150, 143, 64, 177, 162, 202, 21, 178, 76, 72, 68, 98, 142, 73,
219, 171, 152, 22, 208, 10, 123, 153, 65, 39, 202, 115, 50, 202,
78, 123, 26, 43, 117, 232, 190, 25, 215, 184, 117, 109, 239, 219,
128, 252, 249, 131, 196, 232, 205, 205, 153, 130, 0, 41, 219, 60,
204, 156, 64, 108, 150, 104, 62, 135, 156, 88, 25, 69, 156, 177,
223, 76, 110, 217, 224, 182, 0, 76, 200, 28, 248, 153, 65, 144,
195, 244, 146, 80, 191, 48, 193, 5, 231, 143, 71, 109, 97, 186,
94, 93, 232, 248, 104, 35, 84, 165, 94, 108, 3, 104, 130, 67,
77, 241, 128, 253, 69, 41, 121, 15, 1, 247, 84, 196, 251, 242,
216, 149, 164, 41, 152, 21, 0, 24, 50, 103, 113, 244, 86, 206,
101, 44, 229, 49, 210, 119, 111, 76, 223, 242, 0, 119, 242, 149,
141, 160, 47, 241, 146, 230, 69, 53, 126, 219, 31, 174, 59, 125,
172, 45, 83, 234, 36, 87, 113, 177, 82, 177, 1, 83, 15, 84,
138, 94, 43, 169, 134, 161, 193, 126, 107, 94, 148, 184, 79, 173,
52, 127, 118, 129, 193, 157, 249, 130, 162, 168, 191, 175, 58, 161,
30, 2, 20, 196, 92, 179, 242, 124, 142, 124, 213, 154, 206, 55,
180, 68, 156, 8, 50, 118, 6, 148, 209, 8, 190, 127, 53, 162,
7, 32, 73, 108, 24, 70, 246, 59, 28, 23, 104, 243, 54, 205,
66, 93, 100, 244, 97, 198, 11, 24, 9, 26, 125, 6, 40, 125,
134, 252, 210, 139, 166, 9, 102, 245, 188, 176, 179, 223, 3, 101,
211, 190, 58, 210, 42, 236, 103, 154, 72, 186, 69, 201, 244, 233,
248, 136, 178, 167, 207, 166, 116, 192, 62, 0, 188, 155, 178, 25,
114, 191, 60, 124, 195, 201, 73, 89, 63, 189, 6, 250, 98, 83,
61, 96, 56, 82, 109, 31, 211, 245, 198, 121, 31, 228, 84, 229,
216, 84, 17, 231, 71, 193, 20, 8, 9, 160, 134, 124, 207, 192,
231, 181, 251, 22, 156, 10, 92, 64, 74, 76, 54, 214, 162, 15,
225, 124, 178, 196, 17, 241, 192, 6, 69, 49, 235, 167, 154, 128,
34, 131, 85, 81, 65, 171, 163, 229, 183, 25, 242, 238, 165, 33,
145, 130, 66, 133, 99, 119, 154, 168, 217, 150, 214, 192, 117, 198,
38, 187, 157, 201, 71, 187, 227, 173, 43, 251, 141, 109, 15, 235,
147, 164, 189, 148, 30, 151, 179, 158, 190, 62, 18, 205, 61, 6,
52, 93, 227, 37, 117, 2, 167, 247, 10, 124, 233, 250, 109, 37,
205, 84, 10, 243, 129, 13, 214, 31, 25, 18, 95, 52, 50, 112,
71, 206, 250, 184, 77, 168, 157, 164, 201, 149, 2, 10, 112, 166,
156, 171, 154, 15, 91, 206, 179, 165, 208, 240, 29, 144, 243, 223,
27, 137, 68, 31, 118, 164, 181, 80, 44, 147, 14, 39, 229, 163,
124, 68, 176, 6, 190, 193, 55, 183, 213, 205, 221, 242, 129, 141,
209, 181, 23, 157, 242, 218, 155, 98, 171, 253, 26, 106, 75, 140,
27, 149, 100, 67, 244, 165, 31, 177, 57, 46, 252, 153, 78, 85,
86, 58, 2, 108, 134, 53, 24, 189, 146, 223, 108, 116, 60, 150,
124, 249, 143, 6, 120, 223, 94, 224, 109, 27, 135, 80, 166, 147,
53, 104, 69, 71, 9, 14, 200, 149, 161, 222, 63, 197, 101, 223,
148, 246, 80, 237, 137, 85, 85, 201, 29, 98, 149, 114, 245, 223,
18, 240, 137, 168, 35, 58, 64, 166, 243, 13, 177, 190, 253, 40,
87, 10, 195, 67, 75, 21, 93, 45, 116, 189, 104, 137, 100, 244,
25, 140, 118, 245, 34, 216, 32, 127, 177, 136, 107, 146, 22, 53,
61, 233, 86, 31, 14, 201, 124, 195, 235, 174, 64, 45, 50, 146,
94, 47, 224, 86, 116, 18, 196, 183, 108, 101, 105, 131, 71, 87,
64, 2, 84, 8, 97, 2, 193, 95, 175, 25, 148, 181, 220, 9,
117, 128, 222, 139, 159, 47, 52, 31, 154, 101, 168, 153, 217, 89,
93, 68, 226, 76, 161, 32, 148, 171, 118, 86, 148, 179, 10, 115,
90, 20, 63, 255, 176, 253, 199, 171, 57, 174, 67, 97, 146, 45,
196, 160, 121, 190, 117, 202, 44, 118, 33, 241, 249, 126, 219, 187,
45, 254, 224, 235, 185, 239, 94, 120, 229, 143, 211, 159, 33, 196,
3, 76, 116, 16, 162, 246, 162, 181, 145, 58, 234, 252, 74, 122,
40, 243, 160, 70, 188, 188, 165, 99, 138, 112, 76, 201, 8, 53,
208, 53, 245, 193, 202, 59, 31, 187, 117, 219, 26, 77, 27, 95,
164, 215, 49, 22, 184, 228, 79, 164, 171, 117, 74, 195, 51, 176,
96, 134, 247, 25, 49, 202, 206, 110, 126, 146, 9, 14, 191, 226,
5, 164, 73, 172, 204, 96, 229, 79, 73, 180, 76, 218, 87, 36,
152, 223, 145, 181, 27, 49, 168, 228, 129, 76, 122, 13, 4, 30,
58, 251, 38, 117, 93, 67, 150, 117, 123, 208, 214, 236, 134, 191,
54, 166, 180, 34, 0, 197, 240, 166, 24, 141, 32, 110, 187, 209,
217, 34, 228, 32, 48, 37, 62, 101, 50, 253, 137, 131, 236, 232,
43, 41, 185, 141, 85, 112, 95, 152, 80, 102, 127, 247, 209, 77,
57, 165, 208, 50, 125, 247, 127, 97, 168, 99, 68, 67, 43, 72,
98, 162, 193, 74, 227, 3, 88, 95, 153, 173, 205, 32, 30, 145,
193, 34, 150, 78, 44, 91, 80, 33, 31, 116, 143, 92, 218, 65,
89, 140, 75, 250, 97, 213, 142, 160, 69, 115, 165, 120, 165, 206,
166, 142, 201, 56, 4, 163, 80, 77, 216, 158, 198, 37, 11, 75,
198, 61, 127, 168, 208, 196, 9, 47, 32, 143, 41, 184, 156, 45,
42, 236, 177, 211, 122, 191, 5, 188, 70, 182, 68, 106, 55, 79,
12, 101, 245, 97, 185, 177, 132, 32, 162, 165, 56, 110, 15, 181,
7, 22, 182, 140, 117, 226, 229, 90, 217, 225, 141, 118, 249, 168,
5, 158, 105, 137, 38, 215, 3, 125, 9, 202, 246, 87, 243, 97,
46, 67, 48, 99, 233, 252, 155, 71, 147, 141, 47, 176, 99, 248,
165, 254, 190, 107, 214, 61, 36, 224, 176, 185, 145, 213, 207, 204,
212, 47, 135, 79, 56, 105, 119, 41, 156, 129, 16, 84, 110, 91,
172, 72, 200, 217, 127, 1, 251, 122, 244, 55, 16, 219, 82, 206,
114, 218, 151, 74, 246, 215, 56, 154, 183, 245, 152, 43, 196, 111,
37, 214, 163, 250, 243, 141, 215, 182, 131, 82, 228, 249, 198, 23,
84, 172, 122, 7, 7, 20, 54, 64, 85, 49, 167, 0, 21, 100,
53, 255, 127, 37, 5, 91, 237, 17, 83, 17, 234, 105, 52, 252,
149, 219, 101, 52, 154, 86, 148, 102, 66, 85, 230, 234, 90, 82,
12, 154, 168, 26, 51, 133, 18, 213, 146, 119, 13, 181, 203, 90,
144, 190, 88, 132, 99, 174, 219, 204, 76, 174, 108, 155, 242, 178,
216, 35, 140, 21, 124, 234, 198, 6, 183, 212, 247, 250, 126, 171,
150, 99, 175, 62, 34, 201, 47, 178, 210, 247, 148, 108, 47, 150,
209, 83, 198, 124, 6, 24, 166, 119, 19, 24, 175, 227, 110, 43,
47, 36, 222, 156, 73, 3, 175, 180, 119, 35, 88, 233, 244, 111,
83, 117, 66, 145, 138, 96, 241, 86, 221, 148, 0, 170, 29, 75,
110, 90, 83, 121, 147, 189, 54, 14, 62, 83, 120, 240, 116, 58,
134, 15, 138, 82, 216, 39, 147, 111, 222, 106, 129, 40, 99, 122,
81, 200, 23, 152, 188, 85, 55, 183, 186, 107, 10, 236, 56, 73,
63, 29, 227, 23, 148, 250, 103, 124, 232, 146, 48, 143, 57, 244,
179, 214, 161, 240, 247, 211, 161, 221, 75, 37, 157, 4, 73, 88,
40, 116, 90, 202, 114, 0, 11, 61, 68, 159, 134, 135, 186, 42,
124, 129, 151, 247, 221, 6, 166, 34, 217, 175, 61, 138, 78, 9,
26, 215, 168, 30, 133, 7, 189, 208, 40, 131, 110, 56, 214, 221,
95, 168, 173, 193, 220, 80, 170, 140, 60, 68, 231, 167, 136, 84,
215, 196, 141, 243, 6, 234, 130, 161, 50, 110, 106, 240, 160, 101,
100, 191, 225, 190, 231, 180, 51, 77, 132, 2, 231, 134, 112, 35,
92, 121, 95, 91, 176, 64, 192, 250, 5, 162, 142, 236, 29, 169,
113, 130, 245, 43, 154, 229, 86, 187, 171, 226, 222, 193, 230, 114,
169, 58, 62, 62, 129, 8, 88, 34, 76, 104, 254, 200, 219, 151,
92, 46, 117, 172, 107, 121, 149, 215, 60, 141, 74, 178, 224, 34,
82, 60, 228, 207, 236, 109, 176, 240, 49, 164, 119, 192, 97, 80,
99, 135, 14, 47, 220, 67, 236, 229, 14, 242, 141, 113, 141, 74,
82, 198, 135, 14, 126, 21, 207, 115, 98, 14, 162, 127, 66, 19,
150, 226, 103, 153, 254, 221, 135, 134, 3, 34, 74, 145, 31, 1,
162, 193, 124, 254, 2, 40, 208, 178, 186, 5, 143, 159, 202, 128,
113, 105, 77, 173, 184, 101, 18, 215, 100, 2, 4, 166, 12, 197,
150, 188, 89, 115, 52, 110, 211, 204, 123, 42, 247, 87, 105, 94,
232, 71, 201, 249, 201, 139, 37, 174, 11, 2, 86, 51, 224, 205,
32, 55, 129, 1, 2, 77, 211, 102, 117, 235, 149, 167, 218, 99,
147, 103, 104, 33, 214, 154, 165, 138, 207, 150, 28, 169, 167, 245,
61, 242, 187, 194, 40, 150, 97, 113, 116, 210, 104, 212, 112, 6,
26, 18, 116, 241, 143, 209, 240, 110, 21, 138, 246, 235, 182, 215,
192, 143, 17, 174, 132, 114, 114, 10, 230, 5, 156, 67, 74, 105,
4, 96, 204, 218, 97, 105, 135, 202, 207, 14, 159, 9, 113, 28,
181, 46, 148, 43, 139, 145, 134, 152, 62, 185, 75, 47, 129, 69,
69, 25, 248, 126, 198, 115, 119, 207, 241, 214, 132, 81, 2, 209,
250, 49, 193, 19, 205, 36, 118, 85, 193, 63, 123, 181, 163, 35,
23, 243, 102, 17, 77, 14, 12, 45, 63, 91, 189, 79, 66, 193,
28, 102, 34, 58, 119, 253, 171, 155, 73, 128, 110, 100, 195, 42,
153, 62, 128, 31, 190, 192, 177, 174, 56, 229, 175, 175, 137, 127,
205, 185, 188, 180, 74, 230, 203, 57, 92, 43, 55, 209, 23, 95,
106, 61, 28, 87, 24, 201, 192, 234, 56, 79, 184, 83, 30, 138,
225, 212, 231, 218, 205, 123, 227, 57, 33, 156, 146, 198, 242, 246,
195, 95, 220, 248, 118, 114, 25, 212, 33, 102, 154, 90, 165, 74,
72, 21, 243, 49, 61, 215, 112, 207, 209, 156, 34, 102, 91, 204,
56, 154, 166, 6, 244, 234, 37, 88, 210, 237, 164, 9, 231, 100,
188, 11, 235, 177, 178, 92, 73, 70, 49, 9, 47, 81, 213, 68,
8, 151, 110, 216, 218, 29, 199, 131, 184, 240, 194, 113, 141, 95,
46, 96, 251, 119, 89, 115, 200, 86, 81, 41, 69, 251, 24, 140,
217, 3, 27, 201, 72, 202, 154, 229, 70, 10, 213, 178, 218, 96,
44, 3, 244, 54, 40, 203, 175, 171, 34, 40, 27, 16, 244, 53,
153, 135, 80, 38, 34, 200, 70, 247, 193, 148, 96, 231, 49, 246,
80, 123, 95, 218, 135, 7, 77, 84, 170, 20, 19, 238, 106, 78,
207, 4, 220, 136, 149, 177, 205, 207, 90, 246, 128, 252, 169, 207,
249, 90, 45, 43, 202, 73, 178, 221, 227, 40, 171, 178, 205, 178,
148, 248, 234, 194, 137, 220, 54, 71, 238, 33, 216, 32, 111, 58,
106, 253, 183, 3, 118, 224, 193, 205, 187, 152, 247, 133, 252, 122,
88, 39, 16, 49, 122, 19, 91, 3, 92, 143, 187, 29, 161, 233,
195, 201, 103, 97, 85, 92, 230, 197, 61, 164, 10, 67, 82, 103,
149, 99, 240, 214, 96, 65, 87, 249, 157, 151, 43, 141, 38, 69,
237, 131, 191, 83, 184, 223, 198, 59, 89, 6, 19, 13, 214, 135,
221, 48, 180, 24, 21, 175, 14, 178, 122, 234, 135, 222, 132, 156,
185, 9, 37, 242, 100, 92, 180, 66, 172, 217, 235, 133, 36, 59,
32, 166, 68, 83, 39, 194, 203, 118, 167, 141, 236, 122, 97, 104,
81, 203, 38, 195, 254, 254, 76, 31, 59, 213, 204, 254, 237, 212,
156, 190, 19, 150, 124, 183, 15, 99, 33, 114, 97, 114, 50, 182,
126, 67, 229, 128, 7, 132, 82, 171, 146, 110, 47, 196, 97, 32,
26, 132, 79, 184, 188, 6, 106, 229, 245, 151, 169, 233, 87, 106,
62, 182, 170, 38, 181, 244, 85, 232, 136, 227, 176, 102, 174, 22,
112, 203, 253, 245, 211, 108, 59, 101, 44, 123, 217, 167, 123, 112,
25, 214, 25, 194, 111, 160, 193, 184, 55, 243, 158, 49, 192, 97,
154, 79, 140, 130, 66, 23, 46, 183, 250, 32, 231, 57, 128, 94,
240, 170, 74, 86, 179, 62, 198, 49, 160, 192, 247, 241, 77, 238,
175, 66, 153, 48, 46, 219, 153, 111, 109, 98, 193, 244, 54, 37,
71, 157, 245, 60, 120, 242, 38, 196, 80, 95, 91, 131, 175, 182,
46, 62, 20, 40, 188, 217, 208, 30, 188, 37, 235, 38, 203, 57,
218, 109, 157, 31, 229, 248, 53, 50, 212, 198, 175, 55, 132, 137,
238, 149, 128, 187, 118, 177, 157, 97, 186, 55, 38, 205, 19, 132,
191, 67, 174, 245, 129, 227, 208, 148, 8, 255, 209, 233, 193, 27,
109, 206, 137, 152, 145, 194, 66, 230, 54, 239, 217, 180, 100, 21,
8, 179, 160, 78, 59, 104, 93, 121, 174, 181, 192, 164, 158, 194,
32, 22, 9, 63, 197, 184, 70, 179, 164, 14, 6, 71, 165, 230,
144, 147, 51, 184, 216, 202, 196, 214, 144, 124, 113, 28, 244, 112,
127, 44, 91, 90, 146, 134, 161, 52, 159, 131, 133, 107, 191, 137,
34, 121, 193, 178, 125, 78, 91, 135, 3, 33, 109, 216, 83, 39,
102, 243, 96, 99, 180, 162, 130, 193, 21, 27, 232, 198, 181, 86,
46, 250, 15, 143, 165, 91, 37, 125, 226, 51, 137, 237, 1, 24,
13, 38, 180, 222, 84, 144, 50, 43, 148, 153, 154, 43, 163, 20,
108, 25, 194, 97, 22, 166, 161, 164, 245, 175, 163, 210, 189, 10,
207, 171, 121, 199, 99, 132, 245, 253, 120, 178, 55, 135, 143, 191,
218, 183, 94, 193, 168, 56, 100, 123, 21, 139, 4, 189, 182, 38,
211, 27, 193, 38, 244, 151, 106, 245, 245, 141, 160, 236, 182, 1,
58, 76, 129, 13, 20, 47, 8, 124, 233, 119, 91, 98, 54, 94,
237, 95, 243, 23, 12, 24, 28, 37, 192, 86, 88, 172, 46, 242,
251, 65, 97, 203, 252, 38, 46, 81, 248, 204, 125, 112, 169, 21,
194, 100, 245, 32, 44, 33, 98, 67, 140, 10, 30, 64, 99, 102,
221, 152, 251, 176, 106, 180, 132, 232, 191, 221, 63, 4, 113, 78,
169, 67, 61, 76, 88, 179, 112, 215, 22, 9, 248, 29, 159, 102,
227, 252, 188, 226, 10, 226, 101, 89, 70, 52, 227, 217, 30, 244,
75, 80, 5, 70, 240, 121, 194, 47, 164, 85, 232, 252, 144, 243,
102, 64, 190, 93, 4, 0, 155, 191, 54, 60, 171, 20, 189, 137,
91, 32, 115, 75, 139, 100, 158, 188, 12, 97, 53, 44, 236, 238,
87, 179, 238, 245, 37, 180, 170, 174, 80, 209, 74, 241, 20, 204,
148, 95, 226, 136, 132, 47, 29, 114, 58, 66, 161, 71, 189, 139,
59, 210, 227, 184, 200, 135, 10, 74, 109, 92, 87, 139, 246, 151,
33, 254, 176, 137, 242, 90, 147, 35, 67, 239, 65, 223, 29, 83,
69, 152, 64, 24, 49, 173, 101, 143, 16, 249, 36, 209, 31, 101,
32, 171, 222, 74, 242, 125, 255, 71, 21, 126, 125, 99, 132, 32,
44, 101, 3, 33, 195, 148, 2, 172, 97, 162, 135, 47, 210, 134,
19, 182, 230, 112, 188, 140, 29, 237, 242, 160, 8, 166, 217, 52,
34, 15, 166, 157, 140, 121, 116, 41, 31, 185, 64, 134, 111, 138,
212, 91, 0, 113, 220, 143, 188, 20, 104, 227, 22, 65, 113, 84,
29, 226, 21, 241, 229, 170, 126, 112, 229, 78, 223, 188, 226, 215,
52, 68, 17, 239, 9, 47, 175, 115, 237, 133, 154, 175, 91, 12,
69, 98, 254, 19, 173, 176, 6, 175, 213, 225, 200, 128, 30, 37,
226, 70, 54, 140, 142, 12, 190, 33, 213, 88, 25, 197, 157, 209,
168, 90, 234, 254, 169, 113, 31, 85, 7, 113, 156, 140, 122, 24,
173, 41, 105, 148, 78, 238, 72, 168, 54, 207, 41, 97, 3, 205,
33, 45, 146, 53, 159, 141, 250, 122, 238, 184, 115, 166, 46, 89,
222, 58, 158, 160, 180, 172, 16, 122, 69, 217, 140, 236, 73, 24,
236, 219, 137, 223, 63, 44, 147, 128, 67, 74, 218, 219, 83, 255,
241, 225, 58, 24, 232, 25, 54, 83, 229, 151, 116, 246, 22, 237,
229, 98, 58, 85, 112, 205, 229, 27, 56, 1, 88, 143, 225, 67,
81, 10, 222, 19, 62, 215, 194, 163, 186, 162, 243, 221, 116, 49,
250, 163, 73, 208, 159, 73, 72, 49, 187, 56, 30, 210, 8, 203,
175, 35, 84, 215, 53, 165, 235, 35, 81, 124, 77, 245, 192, 23,
54, 204, 93, 91, 50, 230, 180, 188, 87, 88, 207, 149, 178, 252,
213, 43, 45, 66, 166, 24, 56, 219, 237, 151, 104, 123, 192, 6,
249, 232, 235, 180, 155, 80, 49, 139, 125, 175, 3, 235, 151, 243,
35, 188, 28, 168, 245, 238, 1, 131, 194, 130, 30, 10, 168, 112,
15, 17, 61, 187, 243, 80, 121, 220, 185, 95, 22, 150, 186, 109,
132, 175, 43, 191, 237, 11, 203, 211, 143, 70, 14, 127, 168, 57,
241, 47, 208, 90, 183, 0, 144, 231, 213, 224, 193, 47, 204, 209,
51, 172, 40, 40, 47, 132, 254, 130, 201, 20, 9, 247, 126, 52,
35, 150, 62, 255, 94, 108, 17, 76, 116, 123, 191, 156, 65, 107,
235, 246, 202, 80, 236, 140, 244, 127, 176, 115, 112, 74, 70, 170,
244, 43, 180, 108, 231, 72, 134, 78, 218, 23, 111, 7, 24, 255,
41, 134, 220, 99, 37, 118, 222, 122, 116, 78, 34, 128, 233, 11,
48, 235, 248, 64, 251, 25, 61, 77, 43, 175, 186, 48, 136, 188,
112, 226, 4, 39, 77, 9, 68, 219, 58, 252, 49, 207, 193, 181,
117, 134, 127, 148, 193, 175, 123, 130, 135, 148, 104, 141, 208, 251,
161, 78, 96, 18, 118, 168, 23, 0, 96, 185, 199, 141, 130, 56,
205, 240, 97, 181, 254, 12, 2, 35, 18, 71, 33, 233, 45, 241,
113, 0, 127, 17, 149, 63, 108, 90, 49, 226, 79, 206, 82, 42,
174, 193, 89, 162, 221, 164, 98, 25, 129, 179, 147, 50, 18, 106,
9, 35, 156, 126, 89, 0, 182, 67, 192, 251, 84, 106, 210, 6,
170, 224, 185, 191, 183, 16, 5, 6, 217, 190, 12, 177, 80, 142,
239, 209, 135, 93, 242, 224, 142, 218, 74, 70, 193, 44, 173, 190,
24, 47, 121, 190, 226, 185, 120, 168, 95, 173, 46, 135, 184, 71,
234, 196, 80, 137, 199, 230, 253, 56, 77, 39, 145, 74, 179, 253,
150, 156, 156, 73, 228, 140, 89, 149, 60, 72, 180, 37, 15, 163,
121, 184, 144, 206, 144, 193, 67, 194, 186, 51, 163, 78, 17, 127,
150, 30, 180, 78, 209, 137, 176, 8, 134, 192, 222, 86, 99, 94,
65, 97, 203, 248, 234, 28, 225, 47, 61, 125, 103, 103, 30, 124,
14, 100, 216, 22, 20, 18, 94, 63, 83, 119, 158, 68, 111, 175,
194, 126, 194, 219, 76, 191, 165, 232, 153, 32, 53, 133, 159, 106,
178, 245, 191, 211, 96, 117, 143, 22, 162, 245, 86, 139, 188, 240,
60, 212, 187, 82, 9, 217, 179, 170, 32, 143, 188, 64, 168, 59,
169, 112, 72, 63, 221, 136, 191, 228, 15, 235, 219, 209, 10, 101,
57, 81, 231, 98, 214, 135, 51, 39, 91, 172, 131, 167, 149, 169,
98, 149, 162, 84, 196, 53, 102, 150, 91, 118, 65, 156, 50, 47,
83, 152, 82, 23, 53, 242, 77, 98, 68, 169, 167, 68, 21, 204,
170, 194, 163, 159, 171, 21, 176, 230, 45, 212, 103, 66, 114, 212,
177, 42, 1, 180, 103, 18, 112, 232, 11, 194, 196, 204, 190, 238,
143, 224, 214, 65, 123, 30, 75, 29, 247, 174, 198, 135, 65, 108,
9, 186, 216, 217, 1, 43, 227, 66, 209, 11, 247, 102, 1, 167,
37, 96, 116, 22, 107, 129, 60, 244, 32, 160, 84, 58, 141, 19,
202, 28, 46, 237, 163, 211, 53, 114, 180, 105, 116, 199, 190, 12,
157, 238, 132, 8, 159, 51, 195, 6, 8, 116, 51, 47, 137, 193,
188, 210, 72, 225, 1, 245, 79, 207, 175, 68, 217, 134, 205, 238,
133, 164, 76, 36, 101, 48, 149, 11, 118, 246, 218, 43, 162, 78,
159, 202, 12, 172, 240, 38, 101, 253, 189, 19, 209, 226, 111, 142,
109, 68, 125, 24, 212, 59, 50, 169, 1, 167, 186, 235, 72, 62,
14, 110, 251, 108, 66, 163, 40, 187, 14, 17, 9, 44, 41, 173,
231, 40, 49, 179, 29, 247, 87, 32, 117, 83, 22, 119, 70, 104,
30, 237, 59, 207, 206, 82, 84, 68, 3, 236, 85, 67, 89, 104,
224, 63, 187, 49, 17, 89, 122, 247, 46, 220, 38, 10, 142, 9,
233, 36, 113, 140, 251, 1, 132, 47, 143, 167, 29, 175, 8, 220,
149, 60, 211, 52, 39, 199, 9, 214, 23, 86, 209, 8, 40, 126,
212, 109, 91, 74, 69, 40, 209, 58, 147, 51, 148, 78, 136, 19,
164, 199, 161, 187, 196, 185, 45, 151, 243, 188, 47, 35, 66, 19,
216, 37, 82, 220, 160, 181, 255, 109, 203, 93, 255, 74, 107, 178,
23, 252, 158, 65, 137, 2, 106, 64, 243, 2, 189, 80, 116, 124,
218, 176, 142, 104, 20, 72, 137, 74, 179, 50, 227, 90, 222, 106,
77, 188, 233, 210, 61, 44, 33, 95, 91, 119, 94, 248, 49, 199,
83, 75, 234, 64, 114, 17, 214, 40, 63, 57, 64, 72, 105, 200,
131, 114, 151, 78, 26, 45, 140, 110, 253, 227, 178, 165, 79, 83,
149, 16, 185, 0, 153, 79, 12, 164, 74, 198, 198, 129, 103, 106,
251, 100, 230, 89, 79, 137, 185, 143, 249, 233, 206, 37, 144, 183,
99, 167, 162, 190, 11, 130, 113, 179, 119, 220, 236, 65, 64, 24,
45, 235, 86, 226, 147, 123, 214, 151, 193, 113, 244, 60, 119, 248,
29, 48, 185, 187, 80, 240, 99, 207, 236, 1, 44, 203, 199, 238,
182, 118, 1, 183, 51, 87, 179, 253, 248, 25, 226, 202, 36, 27,
239, 215, 242, 148, 174, 125, 88, 142, 255, 157, 201, 208, 72, 35,
75, 249, 175, 210, 19, 151, 11, 62, 27, 37, 163, 231, 40, 25,
162, 30, 191, 175, 61, 240, 235, 141, 204, 108, 177, 77, 229, 153,
118, 106, 73, 51, 112, 234, 11, 54, 96, 36, 198, 90, 22, 123,
35, 201, 205, 160, 55, 36, 190, 20, 129, 79, 204, 141, 88, 234,
12, 41, 238, 185, 68, 227, 170, 202, 156, 147, 251, 120, 157, 16,
228, 128, 95, 17, 221, 30, 234, 120, 91, 174, 242, 24, 15, 79,
75, 130, 82, 99, 8, 99, 107, 253, 196, 87, 59, 239, 229, 188,
66, 93, 226, 12, 184, 233, 29, 213, 185, 12, 8, 185, 190, 33,
107, 119, 122, 245, 100, 183, 248, 243, 213, 133, 126, 59, 92, 223,
253, 203, 79, 136, 121, 116, 200, 56, 215, 27, 165, 175, 7, 63,
136, 187, 161, 253, 96, 190, 117, 34, 101, 109, 158, 13, 179, 90,
67, 172, 61, 8, 37, 65, 229, 148, 43, 49, 205, 150, 43, 125,
196, 197, 35, 73, 177, 10, 105, 141, 242, 69, 214, 233, 93, 74,
29, 219, 224, 24, 130, 207, 231, 90, 58, 71, 238, 181, 103, 230,
34, 236, 144, 64, 83, 218, 171, 99, 155, 186, 17, 64, 169, 181,
68, 163, 227, 187, 2, 195, 210, 104, 128, 126, 156, 191, 54, 26,
122, 91, 79, 203, 195, 214, 11, 55, 198, 87, 57, 61, 163, 47,
84, 113, 52, 193, 221, 209, 144, 88, 214, 240, 116, 138, 74, 96,
159, 150, 31, 212, 75, 16, 66, 76, 161, 145, 105, 210, 183, 236,
156, 47, 207, 183, 83, 54, 75, 140, 214, 201, 62, 83, 83, 116,
221, 29, 232, 118, 41, 246, 87, 3, 170, 207, 115, 145, 228, 113,
172, 254, 30, 71, 22, 18, 30, 37, 158, 157, 77, 196, 202, 35,
55, 166, 150, 206, 29, 90, 53, 8, 235, 184, 184, 31, 19, 58,
57, 215, 85, 97, 226, 229, 27, 138, 15, 145, 219, 32, 205, 133,
64, 181, 61, 60, 162, 1, 76, 187, 83, 28, 8, 17, 251, 188,
172, 242, 227, 67, 113, 215, 4, 62, 97, 102, 242, 85, 165, 85,
83, 4, 241, 111, 184, 66, 236, 57, 216, 200, 234, 192, 158, 241,
87, 181, 129, 237, 208, 234, 23, 41, 171, 109, 142, 41, 135, 1,
200, 119, 244, 195, 170, 232, 217, 6, 41, 235, 118, 9, 180, 169,
220, 9, 141, 175, 193, 160, 194, 57, 24, 156, 40, 200, 184, 246,
114, 63, 160, 81, 130, 71, 43, 74, 116, 159, 53, 124, 126, 145,
91, 241, 190, 57, 27, 109, 174, 120, 247, 60, 221, 1, 134, 8,
71, 222, 35, 170, 128, 249, 127, 188, 250, 112, 68, 195, 166, 139,
163, 39, 82, 3, 159, 101, 140, 81, 150, 79, 195, 102, 36, 16,
202, 56, 51, 48, 161, 98, 90, 231, 181, 236, 244, 186, 1, 67,
60, 36, 186, 47, 147, 54, 25, 165, 21, 169, 88, 120, 181, 15,
39, 163, 126, 100, 214, 0, 86, 102, 76, 173, 247, 181, 211, 101,
232, 208, 213, 200, 145, 124, 36, 90, 221, 158, 88, 122, 214, 165,
245, 155, 56, 173, 202, 80, 105, 100, 214, 1, 54, 97, 43, 163,
228, 23, 56, 158, 59, 150, 166, 224, 226, 64, 84, 21, 176, 115,
115, 97, 202, 52, 232, 139, 23, 12, 170, 108, 207, 159, 8, 242,
120, 65, 211, 89, 192, 224, 35, 22, 17, 69, 9, 204, 61, 253,
247, 213, 50, 94, 100, 88, 246, 233, 131, 215, 45, 240, 194, 180,
231, 175, 42, 46, 109, 103, 95, 73, 124, 234, 69, 180, 133, 130,
203, 141, 125, 125, 93, 159, 22, 55, 245, 25, 12, 100, 155, 4,
173, 70, 231, 157, 37, 156, 194, 32, 47, 167, 41, 40, 54, 19,
66, 43, 172, 183, 49, 160, 9, 85, 180, 56, 159, 19, 170, 37,
34, 205, 90, 91, 59, 178, 255, 64, 1, 47, 12, 232, 34, 206,
62, 82, 2, 168, 41, 18, 183, 99, 123, 119, 43, 145, 199, 142,
196, 95, 230, 199, 179, 53, 94, 178, 146, 15, 41, 78, 101, 10,
14, 35, 192, 180, 23, 169, 227, 44, 255, 250, 5, 224, 49, 125,
224, 174, 147, 245, 144, 122, 35, 186, 197, 162, 80, 101, 98, 189,
246, 114, 220, 223, 183, 197, 18, 176, 63, 144, 80, 161, 204, 109,
240, 241, 66, 59, 198, 171, 111, 13, 190, 218, 165, 75, 86, 45,
16, 18, 67, 223, 129, 224, 139, 5, 44, 238, 228, 0, 118, 51,
74, 77, 76, 34, 51, 113, 41, 188, 26, 171, 34, 143, 200, 211,
54, 123, 39, 197, 71, 248, 52, 139, 14, 143, 28, 104, 24, 177,
224, 180, 237, 166, 197, 9, 24, 48, 200, 89, 216, 242, 247, 245,
192, 17, 70, 62, 32, 181, 217, 199, 112, 111, 194, 202, 87, 164,
62, 121, 88, 71, 150, 245, 180, 183, 122, 16, 123, 170, 127, 79,
201, 116, 68, 33, 1, 205, 32, 4, 50, 253, 7, 48, 253, 45,
237, 131, 71, 132, 76, 39, 86, 218, 96, 91, 28, 123, 43, 24,
244, 56, 108, 88, 59, 35, 96, 171, 110, 180, 44, 215, 62, 68,
132, 42, 12, 222, 33, 11, 253, 241, 100, 116, 93, 200, 8, 76,
17, 167, 128, 188, 176, 78, 136, 102, 215, 135, 43, 169, 0, 163,
130, 118, 202, 241, 52, 122, 115, 135, 11, 113, 247, 146, 238, 157,
191, 73, 198, 145, 54, 237, 230, 181, 100, 71, 38, 205, 113, 120,
20, 157, 154, 186, 250, 148, 122, 218, 64, 111, 213, 95, 140, 141,
13, 137, 79, 179, 225, 205, 250, 243, 29, 82, 107, 215, 128, 46,
43, 196, 208, 139, 254, 153, 233, 162, 167, 180, 148, 218, 240, 23,
123, 148, 156, 163, 121, 28, 233, 88, 173, 138, 0, 187, 193, 211,
137, 39, 50, 254, 32, 252, 223, 150, 58, 49, 222, 181, 209, 89,
79, 168, 185, 143, 4, 79, 237, 154, 242, 101, 187, 156, 33, 75,
192, 167, 6, 183, 252, 140, 243, 99, 122, 30, 201, 176, 250, 121,
167, 194, 230, 81, 253, 27, 113, 183, 35, 151, 148, 3, 240, 26,
18, 77, 238, 32, 151, 191, 64, 97, 83, 164, 76, 88, 215, 87,
55, 51, 147, 108, 58, 169, 210, 64, 250, 80, 35, 7, 191, 64,
137, 124, 111, 194, 193, 164, 241, 39, 50, 24, 249, 14, 186, 78,
31, 212, 132, 136, 228, 210, 181, 167, 52, 162, 15, 99, 29, 195,
122, 222, 83, 227, 203, 227, 71, 74, 202, 175, 43, 89, 123, 101,
112, 45, 218, 168, 93, 43, 86, 245, 140, 214, 6, 158, 214, 190,
170, 19, 207, 236, 16, 205, 236, 175, 5, 208, 223, 3, 83, 161,
54, 192, 115, 88, 253, 174, 166, 181, 1, 30, 252, 209, 221, 11,
27, 72, 236, 83, 238, 249, 6, 190, 254, 36, 106, 118, 4, 140,
243, 207, 29, 2, 64, 128, 94, 106, 52, 134, 87, 248, 51, 137,
192, 208, 235, 70, 236, 81, 186, 177, 59, 245, 15, 40, 74, 139,
26, 162, 61, 161, 194, 92, 197, 217, 84, 34, 193, 241, 51, 95,
112, 44, 194, 194, 95, 189, 137, 166, 52, 83, 145, 195, 119, 137,
149, 243, 184, 36, 159, 111, 147, 88, 250, 101, 23, 237, 69, 138,
131, 210, 220, 253, 240, 197, 191, 181, 159, 152, 211, 150, 56, 19,
69, 126, 132, 29, 199, 56, 190, 217, 246, 9, 56, 43, 127, 52,
137, 32, 26, 68, 159, 239, 154, 121, 59, 230, 54, 181, 56, 144,
34, 179, 196, 74, 145, 92, 0, 164, 213, 39, 102, 58, 208, 111,
158, 126, 242, 231, 205, 242, 13, 90, 55, 218, 169, 116, 93, 131,
40, 117, 87, 191, 251, 179, 157, 124, 123, 14, 24, 224, 43, 225,
223, 63, 16, 39, 176, 31, 244, 129, 199, 246, 184, 140, 208, 44,
165, 122, 115, 58, 236, 232, 22, 127, 103, 134, 108, 251, 3, 67,
19, 189, 120, 129, 223, 164, 155, 181, 84, 124, 170, 223, 113, 228,
205, 79, 32, 83, 28, 203, 131, 113, 94, 242, 2, 210, 162, 199,
159, 217, 152, 78, 252, 83, 0, 135, 147, 37, 208, 146, 4, 167,
50, 29, 216, 151, 102, 163, 100, 158, 28, 243, 251, 9, 88, 55,
103, 143, 159, 118, 254, 145, 169, 130, 136, 44, 57, 120, 248, 104,
87, 46, 164, 14, 108, 188, 31, 97, 132, 103, 209, 13, 93, 46,
246, 159, 126, 113, 190, 139, 125, 74, 24, 93, 63, 195, 99, 145,
120, 22, 179, 13, 95, 141, 68, 105, 184, 234, 104, 15, 140, 49,
142, 165, 23, 33, 101, 193, 158, 151, 165, 218, 1, 40, 118, 139,
33, 187, 70, 227, 86, 251, 12, 205, 196, 211, 143, 113, 11, 55,
88, 42, 243, 208, 60, 210, 113, 25, 30, 178, 114, 166, 111, 156,
151, 231, 81, 22, 96, 233, 201, 130, 180, 153, 91, 173, 147, 171,
172, 83, 249, 33, 181, 217, 129, 73, 94, 245, 160, 31, 85, 198,
158, 11, 129, 147, 248, 165, 42, 137, 215, 67, 190, 99, 207, 29,
222, 99, 17, 232, 134, 25, 223, 58, 157, 132, 233, 189, 217, 27,
142, 171, 155, 41, 53, 230, 27, 29, 109, 38, 21, 121, 8, 58,
220, 113, 22, 1, 246, 114, 83, 6, 165, 20, 25, 82, 252, 193,
215, 238, 144, 212, 210, 111, 228, 139, 105, 136, 12, 148, 229, 69,
41, 93, 65, 160, 192, 76, 79, 50, 108, 91, 58, 107, 125, 73,
237, 219, 123, 210, 187, 173, 8, 48, 223, 12, 44, 52, 153, 150,
166, 146, 247, 158, 157, 229, 222, 133, 232, 15, 141, 199, 50, 30,
173, 51, 150, 56, 60, 144, 169, 103, 91, 255, 231, 81, 240, 65,
134, 84, 8, 33, 167, 70, 2, 79, 190, 62, 230, 54, 113, 51,
27, 178, 99, 14, 114, 31, 176, 244, 253, 239, 81, 27, 26, 18,
100, 19, 104, 164, 71, 56, 112, 170, 223, 158, 167, 12, 51, 99,
223, 101, 74, 84, 102, 183, 188, 37, 244, 38, 77, 68, 152, 239,
16, 17, 130, 131, 163, 224, 105, 140, 75, 205, 23, 89, 226, 11,
209, 206, 116, 131, 7, 222, 243, 58, 232, 126, 61, 45, 170, 160,
188, 111, 157, 161, 120, 124, 76, 156, 143, 207, 44, 166, 210, 214,
16, 23, 35, 234, 51, 47, 220, 201, 52, 26, 234, 92, 231, 74,
65, 164, 209, 196, 94, 209, 63, 22, 158, 139, 65, 217, 242, 251,
21, 201, 236, 122, 196, 93, 164, 53, 238, 104, 185, 188, 64, 89,
47, 202, 157, 231, 116, 250, 73, 88, 190, 70, 233, 70, 231, 54,
5, 243, 125, 252, 241, 206, 53, 19, 71, 210, 212, 183, 223, 15,
226, 22, 109, 74, 229, 6, 193, 149, 53, 216, 116, 108, 135, 14,
66, 228, 102, 242, 17, 90, 44, 58, 131, 224, 227, 73, 45, 93,
253, 134, 177, 99, 15, 217, 222, 117, 179, 147, 205, 216, 74, 222,
68, 15, 198, 167, 30, 17, 142, 167, 6, 246, 163, 157, 156, 140,
119, 216, 37, 215, 230, 213, 109, 148, 168, 115, 18, 20, 38, 17,
24, 37, 103, 24, 96, 240, 128, 165, 244, 7, 173, 205, 167, 109,
204, 77, 132, 167, 151, 250, 78, 127, 108, 17, 120, 145, 164, 194,
59, 125, 126, 15, 115, 37, 178, 8, 154, 117, 166, 75, 116, 97,
228, 242, 42, 252, 184, 168, 146, 96, 156, 67, 207, 60, 135, 202,
203, 120, 62, 126, 16, 90, 157, 90, 206, 215, 63, 249, 239, 3,
207, 68, 67, 224, 202, 241, 126, 253, 61, 108, 89, 247, 51, 113,
211, 74, 249, 156, 154, 184, 212, 221, 162, 125, 154, 77, 91, 200,
56, 102, 57, 58, 218, 129, 54, 243, 151, 78, 50, 140, 234, 32,
61, 91, 49, 226, 36, 216, 159, 64, 101, 150, 105, 76, 67, 56,
60, 152, 152, 215, 138, 90, 184, 83, 191, 234, 54, 191, 85, 231,
95, 193, 208, 28, 253, 231, 237, 51, 176, 187, 76, 235, 25, 103,
51, 97, 165, 173, 158, 118, 141, 231, 199, 65, 91, 48, 155, 52,
236, 182, 133, 35, 21, 204, 237, 237, 218, 195, 147, 0, 186, 29,
112, 9, 152, 204, 42, 224, 202, 35, 51, 253, 18, 107, 200, 42,
234, 25, 250, 197, 73, 33, 77, 160, 121, 74, 239, 13, 57, 65,
163, 168, 74, 240, 121, 104, 116, 119, 220, 194, 82, 172, 76, 122,
96, 156, 251, 204, 36, 163, 253, 202, 52, 135, 113, 155, 198, 190,
206, 236, 157, 56, 157, 201, 114, 222, 155, 77, 138, 178, 65, 229,
209, 40, 166, 251, 200, 12, 68, 248, 245, 80, 147, 121, 88, 74,
189, 144, 77, 9, 150, 65, 148, 254, 2, 245, 46, 210, 151, 224,
158, 27, 29, 218, 235, 188, 97, 20, 96, 83, 12, 254, 127, 39,
20, 158, 19, 102, 101, 3, 190, 222, 241, 96, 15, 102, 82, 249,
68, 202, 116, 229, 134, 170, 212, 79, 88, 125, 48, 126, 232, 61,
3, 234, 159, 2, 166, 30, 5, 239, 109, 24, 126, 126, 123, 46,
73, 170, 42, 157, 54, 233, 58, 123, 111, 126, 118, 18, 38, 118,
226, 70, 209, 244, 195, 139, 83, 228, 213, 158, 139, 171, 98, 209,
63, 96, 40, 247, 162, 17, 255, 189, 79, 2, 152, 97, 255, 244,
222, 138, 42, 63, 98, 105, 189, 164, 95, 97, 223, 249, 52, 213,
184, 52, 133, 191, 252, 26, 158, 143, 8, 170, 14, 151, 115, 65,
140, 40, 204, 107, 26, 170, 34, 68, 49, 93, 182, 18, 69, 129,
106, 187, 3, 234, 151, 233, 202, 34, 135, 249, 221, 254, 154, 116,
125, 214, 89, 73, 147, 44, 42, 129, 114, 65, 251, 91, 92, 6,
146, 90, 129, 203, 192, 222, 112, 50, 139, 212, 3, 187, 216, 224,
140, 142, 103, 180, 31, 112, 159, 205, 109, 231, 26, 171, 135, 204,
78, 94, 243, 227, 216, 75, 222, 20, 208, 172, 181, 240, 150, 184,
135, 233, 85, 155, 78, 180, 188, 228, 236, 221, 39, 239, 247, 158,
23, 28, 20, 190, 146, 81, 236, 188, 64, 168, 150, 209, 215, 120,
70, 32, 59, 185, 7, 113, 12, 91, 135, 184, 184, 47, 111, 27,
75, 210, 255, 227, 71, 45, 168, 161, 151, 192, 111, 117, 29, 5,
29, 128, 136, 64, 103, 231, 107, 52, 8, 237, 213, 198, 121, 49,
95, 226, 10, 200, 169, 63, 155, 214, 164, 197, 170, 95, 84, 180,
111, 13, 193, 200, 18, 131, 246, 206, 10, 104, 28, 22, 255, 15,
249, 181, 150, 204, 228, 57, 73, 67, 165, 21, 64, 109, 104, 188,
206, 92, 252, 30, 222, 229, 235, 75, 182, 69, 183, 223, 200, 102,
214, 239, 129, 139, 213, 188, 53, 223, 119, 235, 43, 88, 183, 255,
22, 68, 252, 115, 128, 213, 7, 193, 149, 89, 229, 171, 229, 198,
15, 118, 40, 251, 132, 27, 76, 250, 43, 228, 140, 97, 227, 180,
240, 74, 27, 61, 167, 174, 183, 87, 82, 183, 167, 78, 222, 183,
212, 8, 139, 18, 105, 16, 242, 48, 22, 180, 239, 235, 0, 37,
255, 202, 204, 127, 97, 56, 38, 10, 71, 81, 31, 135, 71, 172,
24, 186, 210, 240, 201, 171, 145, 146, 25, 65, 80, 106, 103, 51,
217, 245, 112, 213, 115, 247, 182, 6, 247, 178, 53, 67, 146, 16,
57, 139, 134, 173, 124, 28, 248, 10, 22, 104, 227, 169, 220, 246,
104, 133, 194, 95, 101, 0, 121, 136, 42, 156, 243, 196, 228, 244,
85, 107, 137, 112, 39, 57, 100, 254, 221, 182, 51, 30, 34, 96,
78, 2, 138, 101, 166, 146, 56, 145, 24, 247, 63, 130, 11, 105,
186, 43, 77, 153, 48, 7, 197, 110, 190, 109, 44, 0, 229, 149,
211, 95, 79, 3, 28, 159, 26, 166, 117, 234, 235, 78, 199, 167,
139, 240, 5, 177, 81, 83, 119, 251, 218, 156, 67, 7, 74, 170,
23, 236, 107, 128, 185, 75, 211, 233, 164, 62, 7, 105, 112, 65,
68, 82, 12, 204, 76, 136, 157, 177, 215, 136, 99, 137, 2, 177,
244, 102, 75, 77, 202, 210, 30, 158, 144, 219, 28, 72, 98, 185,
191, 228, 37, 79, 99, 32, 184, 5, 181, 96, 208, 135, 77, 63,
251, 126, 15, 185, 107, 200, 3, 135, 121, 215, 218, 187, 55, 116,
170, 19, 232, 44, 94, 145, 183, 24, 185, 177, 244, 202, 217, 243,
117, 116, 17, 31, 176, 27, 33, 23, 217, 53, 21, 10, 31, 151,
20, 74, 212, 60, 237, 214, 249, 67, 123, 28, 222, 119, 239, 68,
166, 12, 217, 18, 19, 210, 6, 132, 173, 253, 230, 115, 136, 124,
153, 205, 16, 241, 47, 196, 145, 145, 138, 18, 5, 191, 156, 77,
13, 104, 106, 147, 63, 54, 213, 194, 27, 23, 249, 233, 172, 150,
11, 116, 221, 29, 51, 41, 197, 170, 45, 154, 116, 246, 226, 164,
219, 90, 221, 173, 159, 29, 125, 127, 128, 42, 246, 183, 220, 23,
21, 14, 157, 144, 150, 126, 177, 110, 190, 83, 134, 113, 82, 66,
86, 140, 253, 97, 163, 135, 142, 19, 207, 117, 95, 97, 175, 15,
111, 192, 182, 34, 34, 115, 75, 232, 83, 96, 117, 250, 202, 15,
51, 193, 208, 254, 34, 67, 212, 148, 118, 162, 50, 217, 240, 34,
151, 164, 38, 242, 59, 170, 70, 143, 168, 96, 80, 25, 74, 60,
3, 221, 254, 176, 79, 132, 204, 195, 170, 249, 220, 218, 28, 179,
157, 11, 208, 114, 222, 221, 74, 115, 91, 199, 135, 181, 213, 9,
134, 14, 30, 207, 70, 186, 246, 145, 9, 106, 15, 1, 69, 244,
69, 29, 33, 7, 189, 173, 161, 159, 127, 67, 208, 147, 38, 230,
214, 137, 229, 250, 55, 201, 174, 177, 139, 55, 219, 72, 83, 106,
203, 76, 163, 51, 113, 234, 32, 43, 138, 34, 235, 139, 113, 109,
211, 238, 227, 203, 153, 212, 222, 209, 234, 232, 242, 245, 83, 83,
95, 100, 88, 122, 219, 113, 29, 23, 31, 190, 88, 87, 129, 95,
81, 88, 100, 131, 217, 216, 242, 156, 143, 36, 108, 38, 89, 114,
110, 215, 243, 31, 133, 83, 67, 12, 42, 155, 98, 88, 228, 213,
245, 19, 203, 47, 194, 33, 147, 72, 209, 22, 118, 180, 224, 108,
218, 226, 159, 102, 166, 165, 67, 171, 54, 77, 158, 154, 2, 36,
143, 61, 6, 70, 248, 117, 167, 27, 20, 180, 158, 13, 195, 41,
72, 78, 56, 186, 111, 55, 234, 62, 202, 24, 53, 36, 152, 32,
31, 115, 240, 168, 128, 11, 116, 232, 78, 252, 129, 105, 15, 242,
101, 82, 117, 253, 122, 0, 0, 8, 183, 201, 207, 241, 214, 32,
195, 232, 105, 95, 63, 213, 251, 136, 201, 147, 136, 74, 206, 249,
61, 32, 191, 221, 145, 61, 250, 90, 167, 221, 234, 30, 216, 10,
237, 207, 188, 157, 65, 102, 91, 60, 64, 65, 8, 67, 50, 218,
242, 136, 242, 89, 1, 214, 109, 237, 8, 139, 179, 160, 16, 185,
87, 228, 213, 171, 106, 160, 59, 77, 191, 230, 42, 135, 35, 123,
200, 183, 194, 75, 126, 131, 83, 40, 18, 243, 53, 56, 148, 230,
141, 185, 82, 188, 224, 186, 110, 35, 224, 130, 30, 36, 84, 139,
101, 163, 158, 199, 63, 192, 84, 153, 11, 49, 166, 77, 89, 156,
94, 3, 255, 128, 253, 57, 190, 114, 43, 37, 91, 29, 79, 119,
250, 206, 157, 148, 104, 121, 158, 177, 6, 231, 89, 233, 135, 245,
144, 137, 102, 151, 52, 243, 24, 2, 237, 148, 224, 196, 184, 240,
48, 17, 118, 153, 107, 46, 233, 95, 156, 93, 204, 89, 81, 17,
39, 115, 191, 42, 64, 95, 159, 27, 165, 21, 112, 52, 179, 113,
126, 34, 52, 161, 250, 168, 78, 223, 59, 238, 14, 80, 130, 151,
78, 175, 210, 66, 218, 221, 103, 125, 111, 201, 221, 133, 123, 60,
4, 88, 28, 56, 31, 218, 222, 102, 119, 78, 39, 182, 73, 11,
158, 134, 197, 26, 100, 80, 24, 194, 155, 141, 108, 99, 30, 37,
134, 190, 33, 75, 166, 80, 21, 214, 243, 111, 64, 176, 115, 56,
197, 232, 229, 68, 5, 131, 88, 69, 12, 65, 175, 42, 178, 103,
153, 223, 197, 41, 59, 40, 187, 93, 65, 183, 186, 209, 248, 228,
44, 120, 7, 65, 101, 153, 105, 204, 104, 57, 122, 203, 96, 116,
233, 217, 54, 54, 98, 80, 206, 80, 183, 39, 183, 250, 69, 253,
0, 85, 121, 165, 29, 187, 184, 38, 176, 185, 223, 230, 228, 42,
241, 251, 201, 174, 241, 133, 249, 174, 133, 80, 163, 249, 113, 28,
32, 50, 255, 101, 70, 104, 64, 111, 63, 218, 108, 170, 48, 245,
61, 40, 137, 234, 173, 6, 2, 76, 114, 234, 150, 97, 75, 36,
61, 25, 59, 19, 130, 254, 33, 251, 126, 171, 244, 28, 17, 231,
67, 140, 184, 245, 160, 212, 23, 141, 48, 120, 158, 226, 41, 143,
70, 179, 215, 149, 29, 216, 152, 89, 129, 135, 116, 125, 227, 81,
100, 76, 126, 122, 4, 105, 229, 129, 174, 252, 105, 231, 136, 26,
160, 39, 121, 155, 164, 27, 240, 137, 241, 96, 40, 245, 71, 27,
123, 149, 199, 99, 189, 75, 143, 149, 134, 215, 253, 13, 3, 178,
229, 56, 211, 240, 239, 173, 229, 202, 255, 30, 88, 43, 70, 162,
234, 174, 126, 81, 42, 171, 99, 10, 148, 147, 40, 224, 19, 238,
230, 186, 53, 45, 233, 153, 209, 105, 199, 93, 142, 193, 174, 106,
109, 21, 177, 110, 94, 39, 247, 238, 173, 149, 76, 34, 107, 83,
52, 137, 26, 133, 78, 17, 39, 213, 55, 82, 111, 2, 39, 54,
197, 192, 240, 215, 126, 179, 8, 29, 192, 241, 98, 97, 249, 175,
253, 113, 174, 155, 14, 114, 141, 51, 145, 172, 237, 41, 0, 184,
97, 164, 145, 40, 171, 191, 166, 246, 20, 89, 151, 12, 124, 70,
181, 183, 68, 22, 178, 167, 53, 196, 104, 139, 204, 149, 193, 225,
117, 35, 215, 41, 228, 173, 22, 107, 19, 9, 198, 79, 64, 152,
239, 164, 173, 75, 63, 224, 224, 72, 65, 107, 238, 129, 249, 91,
191, 137, 171, 12, 42, 210, 88, 45, 202, 232, 224, 110, 252, 103,
50, 159, 5, 219, 177, 97, 174, 93, 93, 43, 106, 48, 89, 181,
46, 16, 28, 252, 67, 44, 186, 67, 10, 88, 241, 19, 233, 83,
122, 246, 218, 30, 37, 26, 188, 253, 163, 6, 241, 225, 115, 96,
159, 90, 109, 122, 240, 12, 39, 235, 110, 244, 62, 254, 19, 245,
175, 171, 124, 49, 253, 23, 121, 228, 96, 65, 106, 134, 173, 57,
239, 203, 238, 50, 15, 98, 51, 219, 172, 193, 148, 17, 109, 68,
10, 146, 107, 10, 233, 133, 20, 36, 236, 163, 72, 27, 150, 131,
141, 124, 220, 59, 29, 138, 197, 147, 33, 77, 7, 31, 153, 66,
210, 71, 80, 70, 224, 162, 118, 198, 250, 169, 67, 148, 139, 58,
227, 75, 219, 22, 141, 253, 21, 188, 183, 10, 66, 13, 81, 208,
117, 138, 205, 226, 107, 99, 0, 116, 33, 189, 21, 189, 84, 121,
73, 173, 227, 115, 127, 112, 83, 142, 69, 86, 240, 250, 48, 240,
70, 0, 215, 164, 80, 210, 64, 240, 120, 32, 62, 238, 115, 218,
99, 22, 144, 189, 12, 183, 19, 132, 243, 74, 139, 168, 169, 73,
18, 114, 75, 165, 209, 211, 16, 61, 58, 77, 72, 97, 238, 220,
62, 219, 223, 249, 196, 93, 227, 77, 101, 73, 23, 56, 191, 78,
151, 74, 244, 253, 211, 17, 229, 204, 150, 28, 183, 224, 170, 55,
27, 209, 141, 194, 170, 227, 88, 233, 238, 170, 128, 147, 80, 85,
124, 181, 144, 52, 160, 117, 82, 60, 30, 57, 63, 190, 150, 185,
178, 134, 19, 174, 137, 146, 254, 44, 218, 161, 201, 166, 155, 155,
124, 172, 127, 248, 120, 56, 210, 182, 131, 206, 120, 252, 132, 115,
197, 186, 53, 164, 113, 250, 199, 230, 69, 166, 233, 14, 104, 59,
11, 124, 20, 185, 173, 160, 119, 225, 108, 156, 78, 199, 154, 150,
247, 9, 242, 229, 101, 158, 234, 114, 60, 39, 114, 19, 202, 192,
4, 21, 44, 98, 43, 77, 3, 175, 226, 178, 45, 17, 180, 89,
133, 32, 35, 73, 194, 217, 2, 116, 238, 178, 115, 251, 245, 69,
183, 39, 58, 40, 243, 153, 50, 219, 165, 59, 30, 193, 101, 250,
126, 61, 161, 220, 194, 148, 214, 197, 17, 39, 50, 248, 86, 98,
135, 94, 90, 235, 202, 233, 161, 204, 62, 177, 46, 91, 70, 110,
180, 141, 64, 244, 54, 154, 38, 89, 51, 171, 242, 119, 13, 64,
57, 112, 51, 171, 200, 66, 185, 236, 224, 41, 133, 208, 196, 60,
141, 81, 231, 77, 11, 235, 76, 116, 53, 132, 100, 222, 40, 202,
90, 1, 16, 3, 123, 74, 155, 6, 32, 103, 127, 238, 84, 89,
93, 28, 135, 97, 117, 23, 198, 243, 185, 34, 238, 241, 135, 6,
80, 171, 228, 109, 114, 73, 194, 129, 23, 180, 44, 102, 77, 8,
183, 187, 165, 236, 190, 31, 100, 97, 213, 222, 51, 23, 61, 163,
229, 14, 87, 91, 231, 34, 27, 113, 135, 139, 166, 48, 57, 26,
118, 6, 120, 163, 201, 195, 245, 70, 125, 154, 140, 202, 223, 198,
234, 60, 114, 64, 141, 252, 199, 251, 20, 54, 5, 159, 54, 31,
101, 187, 77, 115, 115, 126, 153, 230, 72, 112, 92, 102, 114, 0,
65, 39, 198, 240, 197, 213, 231, 207, 236, 60, 75, 35, 32, 176,
106, 184, 215, 85, 177, 174, 116, 46, 45, 227, 204, 178, 63, 21,
115, 185, 224, 232, 73, 235, 31, 183, 124, 181, 179, 116, 2, 72,
124, 131, 204, 59, 142, 141, 193, 127, 99, 77, 4, 169, 215, 41,
43, 55, 252, 12, 171, 62, 249, 124, 190, 208, 129, 244, 154, 36,
219, 122, 89, 243, 219, 180, 248, 240, 139, 10, 195, 113, 19, 189,
169, 31, 228, 98, 25, 43, 157, 115, 167, 84, 175, 127, 34, 102,
107, 159, 234, 172, 198, 188, 181, 146, 4, 129, 38, 181, 227, 129,
132, 74, 139, 253, 1, 93, 159, 76, 14, 157, 77, 187, 158, 253,
255, 47, 76, 112, 127, 75, 71, 23, 55, 158, 191, 95, 180, 88,
105, 201, 88, 58, 4, 246, 155, 224, 152, 10, 30, 35, 108, 220,
232, 96, 27, 34, 100, 73, 98, 70, 226, 125, 249, 45, 232, 211,
12, 237, 188, 150, 98, 151, 6, 212, 58, 200, 6, 228, 84, 40,
135, 87, 145, 155, 80, 61, 211, 105, 207, 70, 173, 29, 46, 193,
234, 236, 113, 172, 90, 108, 157, 169, 162, 209, 186, 83, 56, 66,
232, 54, 218, 28, 43, 241, 115, 146, 168, 65, 127, 175, 53, 42,
231, 199, 117, 161, 248, 219, 189, 2, 15, 121, 181, 89, 75, 29,
216, 121, 209, 68, 28, 202, 193, 60, 119, 219, 190, 131, 55, 27,
164, 116, 88, 114, 36, 199, 155, 160, 42, 12, 244, 28, 125, 153,
19, 192, 88, 131, 211, 14, 50, 143, 252, 136, 55, 145, 90, 158,
180, 184, 10, 86, 246, 158, 197, 95, 137, 244, 154, 61, 18, 250,
1, 96, 247, 237, 41, 57, 173, 7, 94, 190, 149, 78, 33, 221,
209, 33, 84, 219, 215, 177, 163, 197, 165, 70, 1, 147, 250, 114,
186, 25, 41, 20, 76, 254, 17, 129, 200, 52, 115, 242, 158, 143,
178, 72, 109, 201, 246, 32, 76, 73, 203, 237, 231, 3, 193, 248,
225, 68, 13, 252, 105, 87, 8, 93, 34, 17, 110, 227, 36, 171,
97, 195, 103, 195, 55, 118, 151, 68, 110, 144, 122, 29, 126, 191,
100, 177, 34, 116, 52, 121, 87, 55, 39, 223, 97, 65, 215, 38,
52, 132, 91, 130, 219, 242, 182, 198, 33, 35, 37, 250, 235, 39,
90, 75, 123, 30, 50, 31, 93, 160, 236, 234, 116, 112, 196, 130,
153, 129, 198, 167, 137, 72, 86, 40, 116, 182, 122, 127, 21, 133,
253, 119, 105, 11, 34, 6, 56, 199, 94, 231, 73, 111, 171, 125,
31, 130, 245, 138, 86, 83, 174, 199, 180, 203, 190, 68, 188, 66,
52, 144, 174, 182, 193, 217, 215, 164, 47, 182, 15, 74, 196, 78,
75, 94, 190, 223, 208, 32, 34, 19, 165, 235, 253, 113, 181, 108,
71, 238, 31, 5, 139, 170, 152, 80, 103, 169, 161, 131, 13, 107,
26, 248, 13, 156, 89, 138, 177, 142, 84, 112, 191, 209, 8, 17,
19, 93, 66, 62, 18, 97, 41, 114, 142, 38, 80, 129, 14, 160,
194, 175, 13, 93, 202, 245, 251, 70, 207, 181, 91, 14, 14, 81,
169, 235, 153, 230, 6, 77, 253, 70, 141, 218, 189, 94, 201, 121,
46, 221, 52, 52, 172, 213, 61, 69, 125, 135, 235, 250, 42, 49,
180, 24, 65, 19, 120, 119, 74, 55, 45, 99, 159, 88, 102, 227,
155, 98, 52, 77, 94, 67, 64, 174, 167, 134, 59, 55, 73, 96,
37, 8, 69, 56, 97, 150, 127, 130, 183, 203, 23, 239, 220, 65,
73, 118, 251, 219, 213, 236, 161, 164, 155, 112, 39, 231, 9, 147,
173, 41, 26, 48, 82, 195, 45, 6, 157, 189, 217, 58, 100, 20,
195, 124, 209, 14, 198, 182, 208, 131, 26, 120, 236, 123, 222, 95,
163, 0, 147, 182, 228, 210, 85, 168, 249, 101, 197, 39, 75, 188,
33, 198, 64, 35, 72, 230, 200, 220, 30, 98, 2, 94, 50, 179,
235, 194, 42, 161, 96, 191, 210, 161, 214, 138, 158, 46, 223, 39,
119, 77, 153, 104, 132, 24, 124, 44, 204, 169, 36, 130, 120, 33,
65, 134, 114, 205, 54, 242, 25, 122, 9, 250, 0, 98, 65, 131,
121, 182, 28, 40, 110, 168, 125, 192, 207, 150, 158, 72, 85, 63,
22, 184, 76, 190, 27, 17, 242, 41, 221, 79, 57, 225, 143, 17,
252, 42, 100, 0, 51, 111, 132, 38, 2, 12, 245, 109, 28, 160,
33, 112, 102, 156, 34, 172, 90, 253, 170, 20, 145, 244, 18, 251,
238, 238, 214, 18, 224, 217, 134, 203, 214, 50, 113, 170, 60, 6,
139, 208, 252, 77, 83, 211, 18, 26, 17, 12, 112, 237, 104, 66,
46, 74, 32, 23, 240, 189, 48, 144, 207, 109, 159, 84, 215, 28,
192, 179, 188, 7, 53, 53, 73, 69, 147, 249, 168, 11, 97, 112,
162, 13, 126, 111, 237, 45, 210, 159, 124, 106, 231, 185, 151, 92,
8, 110, 171, 114, 57, 48, 129, 17, 130, 222, 10, 228, 247, 195,
194, 127, 237, 23, 176, 11, 93, 232, 237, 116, 234, 62, 66, 218,
213, 165, 59, 138, 53, 98, 7, 167, 214, 26, 246, 107, 33, 119,
124, 61, 224, 240, 202, 102, 187, 17, 89, 157, 215, 123, 167, 174,
76, 249, 14, 216, 206, 55, 25, 86, 205, 105, 223, 53, 209, 186,
55, 86, 196, 245, 88, 16, 201, 133, 144, 132, 191, 8, 122, 128,
127, 27, 164, 231, 210, 242, 221, 112, 202, 66, 157, 38, 28, 201,
107, 120, 238, 61, 97, 74, 71, 103, 13, 47, 33, 161, 87, 52,
1, 50, 215, 116, 81, 214, 90, 49, 175, 219, 206, 248, 124, 254,
177, 62, 168, 102, 234, 40, 159, 146, 88, 57, 245, 93, 182, 20,
95, 99, 218, 127, 79, 150, 231, 132, 190, 128, 18, 36, 211, 30,
208, 131, 220, 148, 16, 166, 45, 232, 233, 187, 182, 43, 101, 159,
189, 139, 20, 238, 222, 239, 199, 21, 155, 156, 247, 154, 87, 164,
242, 54, 199, 70, 86, 140, 145, 116, 98, 252, 174, 241, 47, 244,
217, 70, 59, 137, 133, 184, 104, 208, 224, 180, 21, 2, 149, 150,
121, 183, 223, 14, 174, 150, 77, 157, 145, 198, 2, 43, 204, 204,
242, 206, 189, 232, 18, 251, 187, 34, 239, 94, 65, 28, 0, 78,
101, 39, 14, 73, 210, 170, 230, 85, 252, 61, 12, 146, 151, 37,
187, 151, 227, 22, 104, 19, 26, 28, 213, 53, 209, 25, 36, 165,
51, 222, 88, 146, 139, 18, 253, 219, 217, 22, 101, 220, 194, 89,
11, 2, 247, 170, 76, 12, 181, 214, 217, 82, 93, 136, 93, 124,
106, 249, 236, 162, 223, 96, 238, 208, 50, 144, 13, 240, 143, 216,
194, 73, 113, 244, 99, 12, 236, 14, 167, 238, 122, 39, 130, 42,
204, 240, 65, 10, 228, 231, 163, 196, 227, 178, 125, 250, 30, 168,
125, 31, 85, 106, 2, 52, 178, 245, 5, 220, 76, 214, 18, 44,
150, 136, 61, 68, 198, 54, 161, 209, 140, 112, 179, 135, 86, 10,
213, 91, 154, 113, 55, 244, 107, 176, 204, 242, 56, 237, 12, 110,
121, 65, 143, 216, 10, 203, 55, 22, 126, 205, 78, 216, 66, 233,
181, 121, 153, 94, 51, 189, 133, 6, 46, 234, 1, 137, 209, 167,
69, 101, 181, 136, 109, 137, 213, 40, 215, 140, 103, 217, 217, 25,
129, 222, 49, 241, 117, 195, 94, 201, 255, 155, 70, 32, 53, 88,
213, 99, 150, 27, 253, 41, 91, 72, 123, 230, 114, 239, 195, 115,
174, 57, 175, 237, 165, 88, 221, 204, 6, 102, 127, 254, 35, 255,
62, 143, 84, 74, 192, 7, 34, 124, 22, 54, 79, 102, 133, 201,
140, 22, 31, 225, 157, 109, 142, 169, 244, 111, 242, 50, 154, 144,
182, 183, 192, 173, 167, 136, 140, 28, 180, 160, 163, 139, 10, 205,
95, 150, 229, 111, 109, 201, 53, 64, 252, 241, 74, 198, 159, 187,
40, 126, 181, 111, 162, 127, 30, 28, 29, 244, 224, 126, 44, 145,
236, 162, 81, 169, 27, 217, 201, 9, 5, 119, 130, 83, 129, 109,
199, 87, 246, 7, 136, 27, 11, 69, 82, 160, 74, 146, 62, 63,
5, 191, 20, 236, 10, 168, 119, 4, 139, 144, 40, 95, 63, 18,
249, 75, 184, 238, 216, 36, 2, 184, 44, 163, 19, 161, 205, 193,
78, 226, 213, 55, 16, 42, 227, 55, 39, 158, 159, 37, 50, 233,
41, 81, 212, 173, 25, 18, 219, 210, 63, 42, 199, 149, 158, 162,
18, 161, 242, 187, 131, 115, 39, 25, 237, 212, 148, 186, 55, 73,
242, 147, 244, 199, 195, 125, 115, 30, 83, 144, 34, 189, 185, 130,
3, 21, 79, 214, 44, 242, 122, 177, 115, 173, 34, 142, 4, 0,
128, 93, 193, 215, 233, 171, 56, 32, 48, 181, 192, 186, 1, 224,
162, 252, 107, 201, 159, 188, 187, 56, 3, 115, 28, 122, 57, 107,
202, 17, 116, 155, 7, 0, 23, 206, 207, 213, 92, 249, 137, 212,
174, 119, 85, 124, 134, 96, 194, 151, 73, 135, 42, 49, 15, 121,
9, 22, 33, 146, 191, 183, 76, 208, 180, 94, 80, 161, 37, 90,
72, 191, 65, 175, 98, 200, 96, 11, 81, 118, 97, 28, 95, 246,
253, 200, 14, 175, 112, 95, 110, 244, 117, 113, 123, 176, 137, 161,
72, 96, 200, 73, 137, 203, 251, 227, 110, 158, 167, 173, 8, 152,
70, 121, 109, 61, 163, 144, 132, 60, 28, 47, 144, 230, 237, 81,
238, 123, 212, 250, 197, 249, 117, 67, 206, 42, 63, 166, 161, 78,
81, 113, 62, 170, 83, 240, 44, 155, 156, 8, 215, 163, 225, 210,
12, 224, 232, 122, 241, 177, 168, 231, 18, 98, 238, 190, 118, 206,
118, 252, 243, 9, 193, 195, 193, 108, 111, 198, 24, 176, 136, 35,
60, 190, 20, 16, 45, 12, 212, 73, 215, 205, 151, 36, 25, 66,
248, 83, 167, 185, 44, 173, 155, 83, 185, 234, 9, 245, 163, 122,
78, 116, 169, 85, 252, 176, 157, 177, 144, 171, 74, 48, 220, 108,
128, 197, 132, 145, 136, 159, 243, 37, 79, 114, 209, 236, 54, 8,
220, 195, 121, 29, 100, 172, 78, 30, 193, 48, 166, 54, 44, 107,
142, 248, 166, 200, 114, 205, 184, 173, 32, 172, 36, 166, 219, 40,
111, 81, 55, 255, 21, 185, 251, 172, 109, 56, 144, 205, 135, 216,
230, 229, 216, 207, 98, 234, 123, 46, 79, 22, 212, 21, 11, 85,
160, 188, 196, 205, 188, 176, 87, 11, 119, 214, 137, 226, 104, 185,
64, 111, 215, 254, 165, 1, 131, 237, 37, 222, 141, 58, 79, 220,
188, 93, 189, 249, 231, 23, 124, 36, 122, 157, 222, 124, 104, 199,
47, 129, 53, 83, 81, 217, 159, 79, 105, 176, 216, 138, 172, 58,
147, 25, 236, 98, 87, 140, 185, 168, 210, 119, 198, 50, 255, 235,
241, 37, 249, 21, 212, 127, 212, 164, 66, 174, 177, 88, 137, 109,
204, 183, 222, 119, 9, 212, 138, 198, 214, 41, 120, 226, 42, 251,
92, 79, 17, 112, 193, 35, 10, 249, 66, 4, 55, 22, 155, 16,
66, 116, 32, 112, 233, 218, 51, 107, 77, 209, 9, 202, 85, 90,
201, 191, 38, 148, 78, 157, 22, 175, 99, 9, 84, 250, 170, 0,
241, 108, 146, 34, 4, 113, 180, 191, 180, 212, 255, 117, 49, 194,
138, 166, 202, 148, 113, 192, 14, 104, 193, 139, 116, 27, 93, 158,
59, 211, 130, 204, 130, 23, 127, 195, 65, 102, 144, 81, 175, 166,
200, 199, 136, 102, 187, 249, 168, 62, 247, 246, 157, 120, 138, 49,
103, 232, 109, 199, 67, 129, 149, 87, 237, 245, 87, 139, 172, 44,
129, 132, 93, 200, 149, 116, 222, 85, 220, 213, 185, 68, 223, 153,
34, 119, 42, 121, 101, 126, 13, 111, 34, 238, 92, 178, 63, 92,
23, 174, 134, 199, 104, 83, 62, 44, 214, 254, 146, 106, 198, 69,
248, 202, 189, 168, 99, 238, 25, 184, 170, 215, 197, 155, 55, 196,
111, 236, 12, 106, 80, 145, 21, 228, 184, 143, 16, 211, 113, 214,
240, 221, 249, 66, 37, 56, 0, 203, 236, 163, 202, 229, 214, 69,
82, 176, 160, 178, 110, 179, 12, 189, 58, 197, 6, 13, 214, 116,
181, 113, 246, 138, 97, 238, 29, 3, 244, 24, 31, 88, 140, 176,
94, 10, 88, 182, 38, 246, 172, 18, 180, 167, 235, 148, 154, 14,
34, 201, 90, 184, 247, 136, 213, 200, 169, 128, 145, 90, 210, 20,
0, 193, 104, 13, 250, 170, 244, 74, 130, 56, 112, 241, 136, 180,
147, 102, 15, 161, 132, 180, 155, 247, 248, 253, 115, 158, 161, 28,
36, 75, 4, 59, 125, 45, 176, 60, 177, 39, 190, 243, 215, 155,
163, 50, 209, 74, 192, 6, 164, 128, 148, 164, 247, 13, 233, 104,
73, 164, 123, 81, 48, 168, 254, 240, 240, 242, 25, 107, 6, 87,
253, 27, 203, 65, 245, 1, 58, 201, 145, 107, 96, 120, 211, 238,
188, 161, 46, 121, 235, 26, 153, 20, 123, 108, 192, 4, 57, 191,
101, 131, 131, 64, 57, 213, 191, 73, 42, 49, 166, 236, 230, 217,
254, 34, 99, 82, 136, 238, 234, 12, 155, 151, 0, 105, 30, 58,
14, 183, 217, 243, 212, 43, 2, 58, 91, 144, 132, 127, 77, 252,
191, 255, 61, 218, 83, 87, 70, 188, 56, 145, 207, 110, 7, 29,
94, 56, 175, 192, 10, 231, 199, 71, 57, 3, 246, 252, 189, 130,
199, 54, 201, 22, 185, 118, 86, 19, 130, 48, 160, 164, 97, 138,
138, 2, 1, 218, 242, 8, 36, 247, 24, 4, 30, 247, 85, 13,
227, 165, 58, 235, 123, 147, 121, 210, 0, 171, 75, 63, 20, 35,
63, 172, 157, 225, 55, 137, 122, 45, 141, 134, 113, 109, 72, 107,
111, 79, 248, 30, 128, 10, 82, 144, 72, 250, 127, 219, 120, 231,
226, 80, 54, 224, 104, 44, 170, 110, 151, 129, 192, 225, 231, 119,
213, 22, 230, 21, 50, 224, 130, 198, 98, 234, 249, 186, 201, 66,
92, 138, 193, 86, 156, 26, 178, 93, 188, 209, 210, 13, 26, 116,
90, 219, 235, 145, 253, 98, 145, 205, 58, 8, 142, 254, 175, 25,
100, 84, 7, 174, 242, 9, 243, 255, 71, 39, 222, 117, 141, 171,
103, 219, 233, 21, 24, 239, 241, 7, 92, 184, 137, 103, 26, 12,
166, 46, 215, 241, 122, 53, 237, 40, 227, 36, 96, 243, 184, 119,
167, 233, 138, 47, 199, 200, 218, 250, 105, 59, 119, 65, 111, 213,
230, 151, 31, 96, 26, 215, 134, 252, 53, 142, 10, 52, 85, 110,
229, 91, 172, 179, 223, 243, 130, 62, 48, 33, 223, 249, 153, 160,
49, 94, 190, 251, 44, 195, 163, 161, 38, 32, 224, 160, 48, 160,
7, 211, 101, 76, 161, 153, 157, 185, 45, 132, 188, 187, 10, 83,
204, 196, 126, 45, 137, 197, 58, 166, 130, 224, 254, 245, 89, 30,
199, 137, 46, 185, 30, 93, 110, 91, 135, 254, 212, 15, 199, 172,
43, 15, 156, 247, 32, 182, 239, 65, 247, 76, 56, 115, 242, 27,
180, 4, 108, 178, 154, 43, 87, 76, 205, 221, 179, 213, 219, 174,
97, 8, 221, 80, 122, 73, 215, 149, 234, 165, 95, 2, 125, 210,
255, 178, 192, 111, 32, 6, 79, 75, 111, 0, 0, 16, 126, 219,
122, 77, 165, 132, 49, 61, 95, 179, 33, 53, 253, 126, 170, 172,
246, 84, 237, 159, 99, 167, 209, 229, 89, 31, 242, 98, 153, 226,
3, 17, 92, 186, 62, 123, 232, 220, 48, 83, 128, 104, 74, 218,
226, 105, 110, 251, 128, 214, 132, 233, 162, 123, 222, 68, 174, 179,
114, 118, 242, 145, 52, 123, 255, 153, 61, 4, 204, 120, 236, 190,
218, 159, 15, 205, 46, 215, 118, 102, 37, 132, 139, 202, 65, 45,
160, 25, 73, 208, 87, 29, 184, 48, 64, 195, 65, 208, 176, 122,
158, 182, 218, 220, 7, 48, 37, 43, 248, 44, 97, 190, 206, 102,
189, 5, 93, 14, 238, 202, 218, 125, 96, 107, 228, 46, 17, 123,
130, 39, 147, 147, 200, 131, 123, 33, 189, 194, 194, 71, 109, 22,
68, 170, 92, 19, 59, 59, 46, 216, 161, 75, 20, 245, 181, 60,
207, 115, 56, 128, 91, 160, 194, 96, 25, 85, 46, 157, 53, 119,
77, 243, 229, 151, 35, 44, 232, 218, 49, 54, 64, 16, 94, 77,
217, 42, 120, 145, 239, 172, 79, 91, 129, 226, 28, 211, 251, 224,
241, 89, 56, 49, 162, 103, 69, 133, 182, 58, 151, 124, 104, 42,
99, 128, 21, 129, 4, 159, 197, 58, 215, 250, 169, 119, 209, 5,
199, 62, 161, 106, 41, 97, 51, 229, 107, 173, 197, 214, 84, 157,
139, 252, 7, 175, 74, 234, 39, 46, 82, 236, 204, 192, 52, 167,
43, 170, 9, 3, 73, 17, 194, 218, 71, 249, 74, 112, 250, 203,
61, 183, 57, 209, 242, 49, 136, 32, 195, 239, 142, 247, 76, 105,
112, 248, 17, 226, 162, 32, 91, 180, 113, 3, 135, 165, 122, 122,
205, 130, 245, 140, 156, 19, 140, 102, 67, 189, 51, 135, 232, 152,
21, 166, 63, 30, 224, 223, 37, 216, 116, 51, 73, 108, 18, 137,
136, 181, 201, 11, 96, 213, 168, 39, 114, 135, 27, 38, 186, 33,
157, 234, 173, 239, 125, 72, 97, 125, 67, 98, 67, 135, 126, 238,
192, 155, 183, 42, 18, 201, 120, 220, 226, 158, 75, 88, 111, 220,
114, 74, 112, 107, 170, 160, 180, 6, 111, 159, 98, 174, 207, 98,
57, 246, 100, 102, 191, 84, 142, 197, 34, 206, 135, 22, 243, 100,
15, 219, 235, 128, 73, 147, 205, 118, 107, 79, 195, 248, 194, 215,
237, 239, 21, 164, 212, 51, 93, 223, 11, 68, 172, 188, 178, 62,
197, 114, 17, 14, 161, 165, 174, 218, 201, 143, 65, 194, 102, 125,
247, 253, 215, 89, 55, 170, 201, 49, 72, 181, 255, 195, 249, 172,
149, 197, 28, 106, 142, 254, 23, 248, 7, 165, 12, 29, 238, 109,
177, 247, 64, 53, 235, 91, 229, 153, 103, 158, 176, 139, 234, 78,
126, 97, 22, 138, 27, 241, 98, 2, 54, 226, 5, 36, 196, 181,
216, 60, 114, 92, 226, 142, 228, 209, 102, 140, 3, 240, 10, 13,
92, 138, 87, 202, 34, 25, 235, 175, 170, 92, 69, 189, 134, 154,
24, 45, 0, 230, 96, 183, 124, 248, 139, 9, 71, 160, 172, 243,
139, 52, 82, 86, 245, 19, 223, 192, 162, 224, 173, 50, 231, 22,
13, 43, 113, 129, 164, 172, 223, 92, 166, 108, 45, 198, 186, 40,
122, 90, 109, 190, 203, 64, 64, 67, 7, 2, 212, 153, 208, 154,
105, 117, 100, 203, 213, 72, 17, 198, 104, 49, 29, 251, 18, 208,
95, 236, 85, 49, 31, 120, 134, 207, 231, 236, 150, 23, 196, 29,
194, 246, 235, 225, 48, 115, 56, 231, 114, 93, 206, 97, 69, 48,
191, 25, 240, 211, 116, 33, 14, 182, 168, 97, 198, 104, 252, 250,
213, 225, 117, 161, 105, 255, 217, 134, 29, 55, 154, 83, 33, 87,
216, 112, 228, 75, 51, 165, 41, 207, 208, 208, 26, 69, 126, 180,
224, 144, 138, 121, 194, 209, 131, 104, 181, 50, 1, 98, 91, 233,
152, 93, 246, 237, 111, 162, 26, 35, 184, 217, 153, 212, 238, 255,
109, 131, 246, 143, 130, 42, 148, 63, 129, 15, 14, 2, 93, 155,
101, 113, 200, 17, 122, 127, 191, 14, 38, 164, 104, 81, 165, 26,
242, 101, 116, 156, 228, 178, 57, 20, 122, 71, 93, 100, 5, 88,
25, 16, 92, 38, 220, 198, 72, 230, 151, 116, 172, 103, 174, 243,
8, 180, 166, 151, 237, 103, 133, 55, 123, 94, 241, 211, 219, 35,
207, 158, 44, 213, 32, 168, 192, 49, 89, 37, 148, 214, 71, 175,
239, 229, 76, 168, 9, 213, 112, 206, 92, 34, 241, 157, 72, 98,
150, 51, 101, 178, 30, 214, 158, 89, 5, 91, 240, 155, 138, 62,
146, 234, 142, 77, 201, 201, 135, 218, 211, 254, 36, 151, 100, 129,
219, 172, 70, 36, 106, 54, 67, 117, 96, 95, 124, 193, 172, 217,
213, 71, 105, 214, 146, 34, 87, 54, 252, 218, 222, 222, 148, 38,
81, 254, 32, 195, 41, 30, 14, 239, 71, 147, 235, 93, 159, 19,
147, 3, 166, 50, 78, 135, 212, 55, 133, 168, 228, 172, 27, 14,
206, 15, 98, 165, 227, 179, 92, 11, 221, 105, 235, 162, 12, 80,
36, 212, 205, 90, 176, 229, 46, 135, 252, 161, 32, 167, 207, 226,
205, 191, 152, 69, 81, 105, 214, 245, 232, 128, 160, 190, 91, 254,
179, 13, 244, 83, 162, 247, 153, 44, 140, 147, 211, 180, 249, 82,
33, 137, 92, 10, 119, 61, 89, 207, 88, 59, 50, 171, 155, 99,
210, 244, 115, 33, 180, 18, 154, 225, 62, 253, 91, 208, 208, 140,
189, 217, 209, 70, 243, 4, 238, 117, 66, 98, 48, 152, 54, 255,
128, 61, 247, 193, 88, 168, 125, 194, 90, 49, 209, 201, 40, 168,
247, 79, 75, 244, 4, 15, 3, 106, 5, 80, 71, 160, 240, 42,
17, 228, 135, 80, 247, 147, 74, 148, 135, 223, 145, 243, 121, 42,
181, 221, 188, 106, 124, 252, 226, 50, 116, 98, 30, 33, 96, 13,
199, 79, 219, 254, 78, 165, 113, 52, 122, 142, 231, 30, 145, 198,
148, 215, 45, 176, 38, 61, 32, 72, 178, 54, 2, 211, 119, 133,
107, 38, 105, 77, 230, 122, 6, 250, 254, 15, 148, 33, 249, 113,
47, 41, 253, 24, 41, 7, 34, 118, 100, 58, 224, 96, 63, 184,
191, 145, 32, 227, 22, 146, 131, 180, 9, 141, 25, 58, 188, 102,
55, 74, 188, 222, 253, 195, 151, 214, 98, 161, 152, 239, 43, 125,
194, 186, 36, 166, 111, 17, 10, 100, 58, 157, 133, 167, 121, 229,
61, 22, 101, 8, 60, 42, 37, 217, 210, 87, 185, 251, 235, 102,
210, 109, 99, 28, 9, 108, 162, 96, 137, 48, 117, 43, 80, 56,
29, 178, 19, 73, 112, 164, 132, 28, 110, 157, 101, 234, 191, 247,
123, 82, 229, 159, 123, 160, 136, 252, 230, 132, 101, 116, 26, 140,
166, 157, 87, 204, 236, 151, 90, 107, 97, 141, 182, 124, 27, 52,
73, 198, 34, 101, 45, 44, 133, 255, 56, 163, 6, 235, 77, 146,
155, 213, 64, 49, 214, 33, 140, 195, 29, 39, 184, 9, 123, 169,
32, 11, 59, 173, 189, 172, 8, 118, 19, 250, 228, 83, 239, 90,
27, 20, 13, 64, 49, 224, 88, 17, 231, 148, 15, 23, 110, 199,
65, 54, 87, 3, 253, 254, 68, 73, 175, 0, 207, 189, 74, 81,
94, 56, 59, 234, 139, 65, 87, 83, 32, 161, 138, 132, 163, 134,
228, 238, 29, 47, 166, 139, 168, 217, 247, 168, 165, 67, 211, 73,
108, 96, 211, 4, 1, 23, 202, 160, 135, 231, 168, 243, 77, 137,
241, 179, 230, 47, 77, 84, 192, 247, 202, 91, 212, 12, 130, 178,
148, 131, 76, 175, 9, 146, 96, 42, 2, 155, 168, 103, 31, 15,
92, 12, 155, 204, 166, 37, 155, 123, 8, 222, 199, 51, 250, 60,
30, 109, 69, 98, 193, 31, 97, 214, 109, 102, 9, 39, 96, 111,
148, 123, 26, 61, 163, 9, 242, 125, 116, 106, 184, 174, 66, 117,
63, 242, 235, 238, 113, 23, 230, 79, 44, 121, 11, 148, 107, 181,
36, 113, 89, 207, 246, 146, 43, 105, 166, 91, 23, 239, 248, 92,
66, 167, 51, 10, 247, 232, 59, 109, 6, 197, 128, 251, 43, 85,
100, 142, 214, 170, 198, 22, 120, 47, 243, 28, 154, 218, 84, 67,
236, 185, 141, 169, 208, 63, 75, 22, 78, 230, 87, 144, 1, 252,
237, 152, 191, 181, 44, 33, 231, 50, 163, 122, 68, 75, 242, 89,
143, 171, 219, 102, 63, 196, 249, 80, 149, 53, 125, 80, 34, 246,
234, 101, 17, 55, 199, 56, 19, 153, 97, 203, 37, 93, 84, 116,
63, 171, 231, 109, 84, 160, 3, 24, 187, 6, 99, 249, 241, 181,
234, 83, 152, 220, 169, 18, 189, 30, 59, 8, 143, 239, 237, 82,
14, 220, 62, 89, 201, 174, 72, 176, 0, 144, 51, 77, 151, 232,
233, 157, 242, 197, 234, 90, 51, 161, 45, 144, 30, 158, 79, 185,
155, 123, 161, 20, 8, 76, 148, 63, 208, 81, 18, 250, 91, 112,
154, 177, 227, 20, 245, 204, 66, 218, 11, 151, 37, 28, 29, 147,
234, 24, 103, 168, 55, 144, 104, 3, 36, 252, 140, 165, 38, 199,
234, 81, 245, 201, 2, 229, 29, 12, 230, 32, 248, 5, 244, 157,
175, 111, 252, 224, 159, 116, 84, 31, 52, 182, 171, 204, 49, 126,
41, 143, 177, 12, 236, 142, 156, 148, 200, 206, 192, 50, 243, 64,
182, 112, 68, 200, 144, 100, 152, 237, 216, 119, 26, 11, 105, 237,
144, 56, 158, 91, 10, 245, 30, 223, 18, 255, 5, 240, 202, 69,
161, 184, 168, 114, 183, 202, 91, 46, 53, 95, 230, 126, 2, 156,
103, 225, 99, 65, 86, 21, 156, 197, 179, 225, 240, 179, 197, 246,
101, 184, 15, 2, 201, 13, 81, 79, 94, 140, 28, 124, 77, 221,
63, 174, 68, 159, 178, 77, 68, 10, 140, 52, 66, 239, 43, 247,
108, 63, 225, 193, 210, 107, 207, 211, 44, 69, 95, 81, 9, 106,
5, 212, 240, 171, 117, 155, 100, 207, 46, 186, 101, 61, 120, 98,
91, 84, 40, 50, 115, 138, 216, 20, 74, 33, 93, 49, 26, 217,
143, 57, 43, 5, 147, 91, 147, 184, 90, 121, 168, 73, 164, 233,
218, 110, 2, 80, 150, 41, 191, 205, 138, 177, 145, 6, 102, 229,
41, 131, 187, 230, 91, 201, 172, 78, 43, 203, 109, 28, 91, 43,
250, 138, 134, 134, 228, 177, 41, 50, 96, 98, 162, 189, 229, 107,
4, 99, 78, 107, 52, 0, 153, 183, 166, 41, 0, 25, 132, 127,
160, 185, 226, 195, 144, 121, 80, 239, 142, 102, 175, 95, 14, 175,
82, 98, 186, 153, 153, 214, 137, 145, 69, 154, 242, 10, 9, 92,
7, 239, 209, 76, 210, 8, 129, 47, 44, 205, 65, 105, 186, 84,
130, 203, 15, 149, 16, 43, 184, 4, 230, 18, 30, 18, 209, 146,
169, 103, 157, 115, 202, 14, 123, 118, 84, 201, 61, 73, 173, 117,
194, 211, 198, 182, 148, 231, 27, 175, 17, 24, 0, 20, 229, 240,
76, 152, 235, 90, 192, 129, 46, 91, 31, 89, 223, 63, 190, 47,
144, 6, 19, 136, 10, 169, 187, 162, 86, 253, 247, 32, 195, 39,
39, 45, 170, 30, 99, 84, 17, 174, 77, 168, 40, 247, 109, 41,
173, 8, 74, 185, 3, 127, 118, 175, 204, 176, 168, 41, 92, 81,
32, 119, 228, 3, 97, 75, 26, 86, 9, 82, 125, 5, 107, 34,
201, 48, 8, 180, 217, 17, 3, 166, 80, 46, 151, 116, 36, 208,
115, 176, 36, 228, 180, 123, 166, 4, 192, 147, 98, 177, 54, 162,
67, 39, 137, 143, 63, 162, 127, 157, 12, 36, 92, 124, 75, 167,
60, 249, 142, 133, 98, 40, 133, 195, 139, 191, 143, 244, 230, 56,
42, 132, 96, 30, 5, 200, 242, 31, 161, 190, 162, 234, 123, 25,
248, 20, 7, 122, 220, 220, 35, 189, 236, 219, 246, 78, 65, 158,
184, 140, 103, 39, 185, 33, 75, 199, 114, 211, 70, 61, 236, 37,
73, 58, 15, 132, 155, 141, 160, 243, 110, 23, 158, 145, 32, 46,
94, 46, 106, 60, 104, 65, 204, 246, 210, 97, 247, 116, 235, 200,
59, 41, 13, 65, 174, 107, 40, 201, 112, 26, 239, 16, 148, 240,
238, 65, 113, 32, 185, 96, 201, 17, 242, 135, 82, 164, 196, 2,
4, 21, 154, 4, 200, 122, 60, 237, 98, 79, 153, 23, 177, 233,
9, 233, 148, 17, 77, 89, 5, 229, 167, 165, 113, 34, 64, 16,
68, 255, 181, 7, 254, 62, 40, 173, 79, 73, 255, 219, 206, 230,
208, 125, 189, 179, 253, 129, 95, 230, 166, 198, 239, 145, 142, 85,
27, 66, 70, 115, 122, 176, 232, 21, 224, 126, 53, 245, 151, 127,
140, 227, 10, 143, 147, 53, 63, 206, 156, 233, 105, 225, 118, 89,
184, 159, 204, 117, 7, 193, 24, 166, 58, 24, 216, 217, 36, 76,
91, 81, 185, 157, 56, 134, 214, 57, 112, 15, 73, 55, 147, 66,
158, 159, 248, 80, 148, 147, 174, 132, 71, 52, 94, 61, 187, 203,
113, 122, 24, 169, 105, 113, 33, 132, 56, 56, 215, 58, 204, 193,
245, 211, 64, 111, 173, 242, 7, 88, 48, 40, 45, 178, 129, 240,
49, 93, 67, 45, 238, 197, 149, 4, 117, 12, 84, 6, 169, 141,
115, 172, 20, 108, 57, 206, 182, 194, 70, 111, 10, 29, 131, 77,
173, 78, 184, 242, 68, 19, 62, 159, 25, 175, 196, 255, 131, 1,
184, 131, 3, 172, 215, 33, 59, 144, 243, 228, 44, 160, 211, 192,
43, 42, 99, 123, 97, 182, 75, 249, 122, 226, 101, 121, 43, 3,
255, 242, 106, 181, 165, 8, 123, 99, 174, 91, 254, 160, 80, 110,
179, 48, 193, 65, 201, 93, 228, 227, 106, 48, 185, 96, 188, 82,
158, 69, 177, 254, 117, 146, 82, 172, 37, 109, 103, 216, 74, 66,
49, 30, 22, 231, 106, 184, 18, 110, 144, 186, 234, 235, 93, 177,
225, 129, 113, 143, 172, 199, 226, 54, 79, 122, 31, 110, 177, 224,
118, 6, 54, 46, 232, 239, 182, 103, 167, 82, 153, 128, 1, 215,
162, 134, 87, 198, 226, 92, 99, 42, 217, 69, 158, 119, 15, 94,
5, 236, 205, 166, 16, 238, 193, 137, 54, 27, 87, 129, 152, 254,
183, 225, 27, 28, 207, 199, 100, 70, 112, 251, 97, 122, 145, 50,
255, 84, 224, 229, 198, 43, 160, 141, 142, 249, 100, 177, 222, 146,
1, 101, 13, 215, 121, 56, 247, 134, 21, 107, 118, 175, 11, 60,
96, 152, 194, 62, 17, 122, 53, 249, 238, 245, 101, 108, 203, 87,
112, 63, 109, 59, 157, 30, 210, 113, 11, 103, 212, 136, 82, 117,
225, 82, 244, 101, 124, 165, 159, 125, 133, 13, 216, 229, 39, 63,
236, 33, 57, 23, 0, 68, 182, 154, 35, 250, 179, 94, 99, 68,
96, 79, 164, 235, 254, 121, 243, 53, 216, 6, 181, 190, 219, 165,
70, 122, 64, 142, 30, 226, 21, 58, 44, 68, 142, 171, 81, 139,
53, 42, 235, 240, 204, 126, 40, 167, 13, 106, 0, 5, 253, 240,
147, 141, 114, 115, 246, 165, 48, 217, 6, 222, 119, 223, 214, 132,
82, 157, 215, 236, 168, 31, 16, 84, 118, 70, 38, 11, 62, 128,
180, 106, 46, 150, 132, 231, 177, 184, 206, 218, 74, 157, 254, 194,
200, 58, 219, 139, 93, 243, 40, 157, 82, 100, 134, 114, 232, 5,
97, 112, 254, 191, 242, 95, 137, 69, 94, 79, 173, 91, 172, 113,
178, 158, 15, 14, 210, 144, 115, 252, 129, 142, 34, 32, 250, 195,
141, 62, 99, 98, 127, 212, 248, 184, 36, 110, 203, 201, 178, 112,
229, 111, 232, 7, 133, 192, 196, 217, 201, 166, 115, 42, 185, 126,
158, 226, 150, 55, 167, 69, 251, 121, 16, 61, 158, 175, 5, 22,
213, 197, 122, 255, 96, 51, 50, 233, 137, 178, 110, 13, 70, 241,
235, 95, 124, 207, 213, 103, 118, 39, 65, 68, 16, 204, 149, 163,
149, 104, 210, 170, 142, 221, 88, 21, 200, 243, 228, 199, 229, 92,
132, 75, 190, 193, 205, 102, 167, 8, 27, 63, 45, 3, 144, 249,
174, 14, 114, 230, 238, 43, 50, 19, 49, 161, 154, 86, 138, 179,
38, 198, 22, 9, 156, 126, 60, 255, 233, 53, 183, 190, 218, 124,
231, 230, 24, 170, 178, 93, 153, 121, 67, 180, 123, 88, 84, 223,
170, 168, 50, 217, 74, 73, 181, 66, 109, 114, 2, 18, 26, 114,
160, 8, 150, 34, 38, 154, 244, 141, 152, 254, 186, 111, 89, 38,
154, 99, 41, 58, 148, 93, 33, 171, 72, 144, 77, 246, 93, 2,
159, 206, 7, 244, 174, 140, 159, 3, 190, 255, 237, 202, 65, 96,
162, 25, 245, 96, 252, 166, 92, 144, 108, 70, 239, 158, 21, 176,
118, 43, 255, 70, 179, 20, 12, 141, 192, 196, 160, 228, 167, 109,
176, 250, 243, 240, 239, 232, 73, 173, 148, 165, 249, 245, 227, 14,
89, 71, 52, 124, 199, 60, 114, 243, 88, 127, 89, 231, 11, 111,
80, 31, 253, 62, 56, 78, 166, 66, 63, 196, 103, 10, 242, 26,
84, 103, 30, 46, 245, 46, 102, 50, 20, 70, 237, 34, 236, 9,
242, 221, 210, 143, 239, 114, 57, 73, 103, 242, 54, 108, 172, 57,
168, 126, 138, 48, 244, 41, 22, 60, 158, 121, 33, 109, 74, 168,
251, 118, 86, 50, 184, 221, 60, 238, 165, 117, 116, 166, 210, 19,
163, 99, 28, 67, 114, 183, 55, 161, 68, 22, 7, 124, 67, 161,
75, 230, 151, 237, 118, 25, 251, 2, 96, 216, 9, 186, 12, 252,
75, 140, 2, 8, 13, 95, 117, 25, 216, 227, 25, 219, 247, 52,
20, 53, 207, 175, 176, 154, 149, 143, 0, 67, 114, 42, 101, 60,
3, 226, 107, 244, 244, 94, 240, 243, 248, 122, 2, 61, 141, 184,
241, 172, 92, 10, 112, 133, 75, 92, 3, 147, 168, 72, 39, 80,
194, 152, 51, 233, 252, 21, 98, 78, 5, 134, 93, 254, 39, 207,
30, 43, 8, 140, 197, 106, 27, 136, 61, 246, 204, 155, 80, 32,
161, 247, 211, 237, 10, 28, 24, 231, 87, 82, 52, 216, 81, 155,
141, 108, 221, 169, 92, 128, 221, 31, 116, 38, 31, 95, 142, 117,
243, 107, 181, 143, 134, 189, 108, 207, 80, 44, 56, 199, 73, 219,
23, 163, 97, 157, 37, 69, 230, 179, 137, 98, 19, 211, 250, 146,
197, 170, 61, 172, 193, 80, 53, 56, 50, 109, 214, 250, 55, 149,
96, 188, 37, 6, 63, 191, 90, 41, 103, 222, 230, 194, 167, 48,
112, 180, 48, 192, 194, 198, 5, 80, 149, 4, 226, 253, 41, 218,
37, 236, 39, 145, 8, 12, 179, 61, 91, 40, 76, 68, 134, 86,
77, 64, 205, 249, 140, 156, 212, 53, 154, 115, 63, 97, 159, 124,
94, 71, 108, 71, 182, 121, 221, 105, 98, 231, 101, 109, 198, 70,
51, 220, 108, 64, 204, 150, 137, 117, 27, 81, 199, 14, 148, 219,
158, 63, 232, 161, 39, 130, 38, 2, 105, 6, 136, 245, 14, 175,
244, 230, 73, 181, 18, 79, 55, 207, 233, 58, 80, 34, 23, 64,
61, 22, 12, 15, 232, 154, 99, 140, 107, 252, 215, 89, 4, 228,
64, 55, 68, 168, 71, 233, 148, 18, 226, 79, 129, 118, 109, 130,
4, 15, 85, 104, 161, 147, 78, 135, 225, 192, 138, 114, 230, 230,
225, 118, 150, 169, 8, 243, 241, 204, 93, 222, 178, 131, 97, 145,
211, 207, 233, 45, 38, 237, 93, 7, 215, 12, 27, 240, 142, 149,
196, 147, 20, 236, 142, 77, 241, 249, 132, 218, 109, 182, 250, 241,
125, 136, 149, 19, 196, 198, 4, 222, 72, 157, 222, 53, 185, 210,
24, 100, 19, 146, 210, 122, 39, 173, 13, 183, 138, 26, 70, 43,
235, 225, 47, 88, 56, 92, 1, 197, 236, 98, 210, 250, 35, 159,
71, 198, 20, 217, 162, 182, 13, 72, 30, 152, 170, 173, 101, 40,
78, 109, 126, 153, 40, 182, 62, 9, 217, 229, 206, 124, 62, 71,
62, 18, 85, 173, 171, 251, 38, 234, 163, 214, 242, 207, 135, 48,
78, 192, 125, 194, 164, 30, 162, 39, 5, 211, 160, 82, 66, 209,
218, 8, 123, 104, 69, 92, 80, 241, 53, 209, 44, 10, 23, 147,
91, 31, 71, 207, 240, 222, 243, 18, 4, 0, 248, 118, 2, 78,
197, 120, 38, 42, 5, 248, 27, 245, 162, 73, 254, 254, 130, 106,
164, 68, 188, 118, 180, 200, 6, 96, 42, 183, 153, 149, 176, 14,
134, 78, 185, 34, 146, 203, 105, 207, 35, 56, 26, 176, 35, 17,
81, 207, 105, 243, 40, 7, 118, 116, 209, 219, 247, 33, 228, 91,
73, 193, 32, 146, 174, 100, 146, 40, 107, 44, 135, 127, 31, 93,
142, 243, 128, 236, 47, 13, 115, 66, 35, 163, 236, 156, 250, 2,
113, 60, 103, 106, 202, 42, 193, 12, 212, 201, 253, 135, 207, 252,
74, 111, 123, 247, 5, 72, 41, 255, 234, 174, 187, 82, 175, 168,
65, 68, 110, 14, 205, 79, 58, 80, 190, 105, 242, 176, 0, 187,
202, 153, 248, 137, 237, 28, 135, 111, 80, 164, 118, 151, 93, 152,
114, 77, 77, 3, 135, 25, 19, 214, 170, 94, 167, 206, 162, 50,
1, 149, 21, 185, 222, 127, 240, 129, 137, 232, 213, 107, 199, 131,
218, 92, 189, 63, 29, 6, 59, 230, 88, 168, 200, 9, 38, 85,
222, 66, 35, 138, 230, 155, 176, 183, 230, 149, 236, 47, 74, 101,
16, 53, 110, 140, 74, 27, 13, 237, 174, 127, 67, 231, 187, 235,
153, 12, 153, 122, 216, 236, 140, 89, 131, 66, 129, 158, 192, 227,
226, 159, 176, 62, 232, 157, 44, 91, 191, 142, 198, 8, 29, 75,
40, 234, 106, 141, 94, 85, 165, 45, 252, 72, 169, 108, 149, 25,
180, 218, 97, 190, 20, 161, 52, 114, 111, 4, 174, 23, 38, 6,
11, 182, 2, 124, 232, 14, 50, 184, 99, 250, 38, 128, 245, 210,
142, 177, 17, 251, 223, 10, 174, 49, 89, 164, 115, 49, 11, 207,
11, 233, 91, 246, 77, 254, 93, 152, 186, 24, 195, 19, 50, 50,
9, 31, 140, 31, 79, 55, 127, 91, 158, 30, 112, 245, 224, 222,
200, 197, 178, 200, 14, 18, 151, 214, 171, 128, 222, 101, 117, 144,
48, 42, 102, 22, 241, 61, 208, 94, 250, 245, 211, 246, 75, 46,
226, 126, 111, 108, 30, 43, 110, 109, 55, 96, 63, 40, 128, 246,
0, 30, 221, 208, 52, 89, 19, 117, 207, 16, 84, 168, 164, 16,
89, 129, 86, 240, 49, 67, 209, 233, 195, 16, 47, 54, 1, 228,
220, 140, 175, 87, 71, 33, 246, 85, 202, 127, 125, 130, 175, 233,
53, 174, 49, 182, 62, 238, 236, 19, 13, 40, 177, 94, 164, 70,
255, 21, 228, 28, 99, 119, 147, 226, 255, 19, 46, 135, 254, 48,
207, 151, 166, 162, 133, 20, 124, 62, 244, 25, 5, 127, 159, 64,
87, 160, 180, 222, 109, 127, 111, 85, 190, 40, 184, 230, 59, 89,
141, 250, 189, 120, 184, 136, 97, 186, 86, 235, 103, 55, 130, 225,
240, 110, 200, 73, 158, 79, 7, 40, 118, 181, 125, 32, 134, 67,
133, 230, 220, 183, 104, 105, 201, 173, 109, 105, 193, 60, 16, 26,
37, 32, 84, 41, 55, 195, 144, 116, 121, 48, 132, 179, 206, 150,
145, 135, 152, 149, 107, 78, 15, 118, 112, 51, 145, 104, 128, 4,
189, 247, 76, 109, 22, 86, 67, 40, 87, 206, 69, 228, 205, 102,
105, 61, 51, 48, 103, 111, 14, 236, 35, 46, 93, 246, 133, 143,
18, 249, 159, 156, 95, 121, 89, 11, 164, 106, 208, 106, 7, 84,
197, 3, 129, 132, 8, 137, 39, 179, 49, 98, 112, 92, 136, 113,
119, 213, 37, 38, 99, 36, 210, 132, 148, 114, 57, 249, 17, 148,
125, 107, 37, 111, 18, 111, 40, 195, 94, 10, 245, 72, 244, 96,
164, 158, 106, 246, 73, 183, 114, 170, 160, 109, 58, 111, 90, 127,
70, 14, 177, 80, 66, 71, 63, 143, 215, 29, 54, 81, 220, 46,
207, 195, 20, 44, 76, 221, 44, 91, 16, 99, 201, 62, 128, 156,
214, 12, 135, 68, 47, 34, 136, 106, 169, 215, 127, 214, 255, 255,
107, 111, 35, 220, 208, 28, 141, 236, 93, 142, 190, 119, 130, 65,
122, 250, 193, 55, 203, 229, 241, 38, 4, 174, 86, 210, 197, 252,
51, 18, 44, 181, 217, 204, 222, 217, 160, 145, 163, 122, 212, 150,
221, 242, 34, 106, 188, 74, 218, 227, 123, 204, 40, 171, 181, 136,
57, 116, 213, 63, 192, 26, 63, 12, 140, 230, 42, 124, 26, 176,
175, 190, 68, 181, 241, 111, 235, 212, 12, 158, 106, 75, 171, 92,
231, 74, 123, 20, 150, 155, 137, 6, 80, 26, 231, 181, 39, 11,
241, 64, 172, 46, 9, 24, 131, 250, 69, 138, 5, 55, 14, 164,
235, 142, 29, 226, 91, 32, 243, 196, 86, 27, 188, 174, 140, 217,
169, 14, 62, 108, 217, 252, 144, 128, 206, 223, 222, 52, 1, 128,
146, 231, 169, 174, 159, 202, 40, 127, 64, 238, 211, 246, 111, 43,
173, 60, 181, 25, 20, 91, 67, 121, 233, 84, 111, 95, 196, 66,
28, 217, 25, 28, 108, 19, 242, 139, 245, 238, 197, 97, 38, 86,
221, 197, 43, 208, 87, 232, 25, 142, 34, 159, 136, 209, 97, 43,
87, 86, 134, 219, 138, 100, 62, 11, 40, 129, 44, 41, 115, 62,
210, 178, 120, 203, 242, 254, 223, 210, 54, 159, 10, 176, 90, 214,
128, 178, 202, 22, 101, 146, 53, 175, 68, 230, 67, 10, 168, 89,
189, 103, 247, 104, 197, 209, 57, 185, 27, 244, 20, 254, 62, 9,
209, 77, 239, 251, 26, 155, 187, 7, 149, 246, 157, 47, 175, 203,
224, 247, 145, 239, 213, 240, 97, 79, 183, 22, 17, 150, 227, 66,
31, 127, 238, 153, 255, 41, 52, 130, 38, 73, 118, 1, 226, 165,
224, 100, 223, 236, 141, 198, 235, 33, 240, 91, 201, 212, 134, 123,
217, 213, 140, 146, 201, 190, 157, 252, 109, 174, 24, 34, 9, 49,
229, 27, 57, 151, 49, 140, 99, 246, 235, 142, 127, 20, 70, 64,
116, 126, 249, 178, 17, 152, 67, 201, 162, 150, 109, 55, 185, 184,
100, 90, 214, 8, 133, 157, 30, 100, 139, 122, 121, 0, 211, 252,
86, 48, 199, 75, 231, 148, 118, 54, 243, 25, 208, 106, 68, 20,
80, 133, 69, 194, 29, 86, 56, 12, 151, 92, 241, 98, 249, 40,
112, 248, 235, 169, 248, 236, 84, 62, 147, 161, 66, 29, 201, 167,
236, 230, 123, 47, 202, 69, 188, 133, 121, 36, 254, 50, 217, 109,
17, 67, 246, 19, 10, 124, 190, 162, 56, 105, 128, 254, 196, 242,
13, 152, 44, 233, 68, 38, 187, 2, 244, 46, 122, 121, 199, 197,
84, 66, 146, 68, 151, 7, 216, 201, 223, 136, 9, 132, 243, 141,
14, 10, 65, 234, 13, 221, 90, 70, 246, 156, 183, 156, 210, 73,
101, 118, 229, 43, 114, 237, 98, 162, 22, 196, 183, 93, 202, 58,
220, 1, 25, 151, 60, 207, 82, 7, 233, 114, 116, 144, 255, 71,
241, 90, 244, 116, 92, 111, 108, 13, 98, 25, 137, 24, 241, 187,
82, 140, 170, 39, 81, 228, 185, 164, 143, 101, 46, 204, 129, 166,
164, 38, 34, 100, 140, 55, 246, 6, 223, 182, 53, 199, 245, 109,
76, 209, 112, 120, 42, 99, 58, 51, 85, 163, 185, 148, 209, 237,
240, 75, 239, 102, 102, 11, 78, 215, 130, 23, 178, 33, 207, 63,
247, 245, 243, 101, 230, 236, 251, 145, 25, 114, 222, 229, 117, 88,
32, 139, 231, 27, 163, 225, 255, 247, 175, 40, 71, 182, 193, 28,
236, 76, 55, 154, 82, 12, 42, 110, 135, 122, 33, 227, 242, 13,
157, 35, 119, 73, 33, 76, 156, 120, 27, 74, 192, 92, 172, 135,
5, 29, 7, 167, 61, 101, 73, 249, 66, 82, 223, 198, 182, 207,
194, 183, 124, 228, 157, 30, 108, 128, 70, 186, 208, 16, 92, 8,
137, 223, 150, 47, 228, 211, 34, 192, 228, 61, 82, 176, 93, 165,
198, 100, 190, 137, 173, 48, 203, 117, 58, 70, 178, 198, 49, 40,
61, 17, 171, 130, 127, 192, 45, 224, 184, 83, 131, 171, 18, 134,
201, 90, 147, 218, 203, 150, 43, 221, 86, 206, 10, 9, 250, 20,
147, 157, 173, 130, 30, 221, 228, 221, 65, 11, 78, 125, 204, 101,
237, 209, 22, 187, 45, 154, 113, 146, 14, 171, 199, 224, 234, 51,
201, 108, 25, 7, 38, 89, 47, 66, 61, 231, 206, 52, 150, 29,
118, 27, 143, 162, 74, 153, 180, 216, 240, 94, 215, 29, 185, 221,
107, 127, 172, 251, 115, 41, 25, 26, 97, 4, 152, 22, 192, 25,
153, 64, 79, 30, 192, 152, 74, 185, 252, 96, 43, 173, 14, 34,
119, 63, 62, 70, 52, 180, 35, 136, 118, 4, 132, 0, 147, 243,
73, 45, 95, 209, 10, 143, 69, 11, 178, 17, 6, 254, 93, 165,
89, 50, 198, 129, 157, 163, 50, 208, 25, 180, 170, 145, 46, 27,
13, 17, 241, 155, 243, 121, 244, 34, 166, 175, 230, 30, 75, 195,
242, 230, 148, 143, 104, 129, 58, 38, 13, 165, 248, 128, 4, 20,
57, 15, 200, 163, 255, 200, 127, 166, 142, 176, 192, 10, 244, 150,
251, 255, 252, 72, 204, 89, 237, 221, 19, 125, 248, 66, 221, 118,
235, 237, 129, 157, 61, 232, 39, 243, 120, 234, 242, 200, 179, 252,
223, 72, 3, 116, 133, 81, 219, 23, 142, 71, 24, 177, 49, 62,
74, 39, 26, 251, 37, 181, 158, 230, 98, 117, 52, 3, 167, 54,
3, 166, 8, 2, 92, 230, 1, 186, 194, 23, 252, 175, 6, 242,
4, 52, 12, 202, 155, 114, 103, 207, 142, 209, 88, 67, 41, 41,
91, 166, 220, 179, 182, 143, 205, 82, 241, 169, 128, 53, 90, 34,
67, 103, 252, 250, 180, 152, 228, 59, 222, 159, 9, 22, 78, 129,
11, 26, 66, 91, 111, 135, 7, 53, 117, 246, 218, 53, 221, 134,
51, 138, 171, 240, 54, 18, 184, 134, 222, 127, 112, 243, 159, 54,
204, 23, 161, 70, 111, 74, 92, 148, 83, 197, 215, 184, 66, 227,
20, 99, 146, 84, 245, 240, 5, 123, 140, 248, 108, 167, 140, 137,
78, 63, 117, 43, 225, 85, 69, 143, 165, 133, 165, 118, 1, 43,
13, 157, 50, 193, 96, 140, 15, 188, 129, 219, 99, 249, 85, 123,
84, 129, 101, 24, 215, 206, 215, 140, 118, 72, 125, 123, 49, 224,
254, 87, 143, 21, 99, 105, 72, 126, 154, 13, 117, 145, 251, 237,
60, 41, 164, 60, 64, 105, 135, 234, 19, 80, 154, 228, 35, 126,
199, 251, 0, 124, 211, 209, 37, 74, 95, 171, 192, 187, 33, 226,
50, 218, 95, 142, 189, 145, 63, 123, 218, 66, 228, 150, 149, 73,
60, 49, 105, 153, 193, 177, 44, 168, 121, 151, 47, 190, 93, 138,
6, 109, 253, 147, 97, 118, 141, 230, 198, 208, 111, 64, 254, 196,
48, 93, 127, 35, 40, 162, 13, 13, 133, 49, 255, 232, 234, 52,
123, 240, 57, 15, 185, 162, 204, 174, 140, 70, 139, 103, 227, 117,
19, 207, 123, 0, 194, 53, 161, 10, 74, 148, 14, 170, 226, 68,
157, 245, 100, 46, 83, 53, 70, 21, 251, 176, 105, 3, 66, 241,
229, 7, 175, 48, 69, 24, 231, 48, 88, 108, 123, 90, 25, 200,
214, 237, 11, 1, 76, 28, 138, 193, 44, 59, 90, 29, 77, 177,
128, 62, 60, 80, 175, 7, 71, 92, 254, 67, 50, 95, 35, 16,
124, 72, 210, 11, 226, 112, 174, 141, 145, 250, 212, 109, 217, 138,
56, 187, 168, 207, 1, 194, 14, 54, 28, 194, 76, 33, 83, 85,
51, 21, 30, 150, 19, 103, 10, 49, 23, 130, 99, 251, 88, 243,
59, 191, 202, 180, 27, 199, 164, 101, 144, 240, 0, 215, 236, 72,
148, 186, 207, 202, 13, 88, 174, 139, 86, 170, 131, 17, 199, 74,
24, 192, 101, 160, 174, 250, 0, 176, 235, 62, 48, 38, 130, 23,
205, 111, 165, 17, 173, 246, 242, 255, 129, 252, 93, 116, 245, 64,
5, 64, 139, 12, 71, 247, 167, 181, 129, 204, 147, 154, 20, 152,
70, 154, 250, 54, 180, 95, 81, 175, 97, 189, 185, 48, 192, 31,
34, 143, 46, 158, 149, 172, 114, 104, 154, 141, 10, 146, 135, 10,
156, 240, 67, 4, 2, 100, 40, 4, 29, 31, 176, 175, 50, 91,
145, 95, 231, 65, 249, 241, 224, 19, 60, 9, 123, 181, 94, 135,
234, 93, 31, 145, 125, 97, 120, 13, 99, 251, 231, 229, 197, 201,
150, 38, 79, 245, 88, 211, 17, 98, 144, 56, 135, 207, 146, 146,
232, 89, 103, 227, 162, 253, 186, 128, 236, 68, 114, 84, 38, 96,
97, 220, 215, 176, 226, 215, 102, 18, 190, 152, 42, 139, 27, 210,
212, 170, 227, 165, 246, 136, 197, 253, 226, 25, 52, 15, 111, 28,
3, 247, 123, 46, 231, 32, 100, 182, 141, 142, 10, 226, 226, 2,
185, 236, 10, 180, 83, 36, 242, 182, 115, 50, 38, 7, 44, 37,
172, 209, 1, 18, 110, 85, 252, 253, 166, 147, 84, 219, 222, 78,
101, 236, 106, 202, 151, 76, 13, 176, 154, 42, 141, 167, 180, 27,
88, 35, 80, 140, 87, 126, 221, 210, 84, 254, 185, 81, 7, 44,
196, 25, 49, 143, 254, 173, 195, 215, 239, 152, 119, 133, 83, 107,
141, 200, 41, 64, 24, 83, 108, 0, 244, 21, 18, 182, 113, 148,
20, 14, 25, 199, 4, 136, 144, 23, 46, 22, 22, 72, 247, 51,
210, 248, 15, 140, 203, 131, 165, 52, 139, 224, 49, 97, 175, 231,
13, 142, 233, 40, 199, 8, 238, 156, 127, 22, 9, 81, 31, 23,
145, 242, 117, 96, 243, 8, 181, 198, 113, 30, 21, 255, 118, 207,
140, 165, 190, 61, 142, 57, 77, 0, 153, 54, 57, 126, 201, 78,
158, 100, 191, 109, 196, 15, 217, 76, 97, 6, 66, 5, 75, 15,
235, 238, 185, 79, 145, 179, 143, 241, 227, 80, 89, 3, 58, 132,
124, 85, 25, 190, 59, 187, 167, 115, 113, 197, 23, 95, 204, 210,
144, 224, 5, 73, 63, 34, 10, 173, 86, 222, 18, 74, 59, 135,
186, 111, 7, 188, 104, 1, 119, 153, 149, 234, 8, 174, 223, 172,
213, 195, 89, 100, 3, 26, 221, 149, 149, 223, 119, 147, 20, 105,
25, 129, 178, 226, 83, 54, 217, 186, 118, 73, 80, 114, 253, 248,
37, 55, 19, 237, 188, 105, 35, 17, 97, 126, 226, 80, 125, 214,
238, 139, 183, 3, 139, 36, 248, 44, 2, 24, 30, 137, 44, 25,
72, 70, 51, 220, 79, 82, 157, 107, 34, 249, 111, 227, 125, 88,
189, 189, 140, 114, 243, 40, 44, 164, 216, 106, 184, 17, 125, 5,
240, 43, 110, 241, 183, 125, 21, 146, 44, 153, 207, 136, 174, 173,
205, 91, 110, 11, 239, 251, 161, 141, 15, 225, 130, 217, 197, 164,
31, 221, 82, 101, 154, 18, 52, 249, 155, 121, 207, 193, 195, 138,
67, 90, 220, 15, 110, 233, 166, 24, 240, 107, 19, 138, 104, 133,
157, 180, 5, 208, 48, 152, 154, 59, 101, 3, 254, 179, 69, 195,
58, 185, 69, 251, 65, 107, 90, 128, 93, 238, 41, 36, 164, 10,
73, 133, 207, 36, 237, 210, 115, 123, 147, 130, 22, 198, 67, 32,
119, 129, 7, 78, 99, 166, 219, 229, 48, 135, 254, 175, 198, 59,
129, 229, 101, 207, 195, 58, 244, 90, 222, 158, 14, 178, 237, 144,
118, 227, 159, 82, 3, 44, 57, 92, 246, 152, 3, 183, 77, 71,
39, 142, 82, 200, 122, 240, 71, 125, 12, 64, 171, 60, 56, 15,
170, 85, 188, 188, 77, 71, 192, 85, 50, 83, 136, 227, 74, 195,
31, 105, 153, 158, 171, 102, 90, 32, 241, 1, 201, 144, 225, 61,
101, 36, 221, 137, 234, 228, 161, 150, 162, 251, 146, 114, 26, 215,
121, 69, 178, 96, 150, 105, 223, 232, 161, 249, 221, 199, 135, 74,
178, 236, 191, 16, 248, 171, 178, 74, 119, 155, 247, 226, 114, 17,
108, 252, 142, 151, 161, 176, 137, 225, 110, 29, 124, 149, 49, 231,
100, 237, 105, 165, 126, 191, 33, 45, 69, 69, 60, 37, 125, 238,
194, 187, 161, 22, 27, 222, 68, 15, 142, 207, 237, 173, 68, 137,
116, 207, 1, 108, 50, 75, 9, 143, 195, 127, 128, 56, 135, 229,
34, 170, 67, 100, 146, 243, 166, 197, 210, 30, 185, 207, 201, 193,
90, 102, 26, 100, 195, 216, 133, 178, 66, 29, 238, 25, 140, 226,
0, 96, 18, 243, 91, 245, 154, 75, 172, 18, 49, 70, 24, 221,
86, 86, 38, 224, 55, 231, 128, 103, 75, 222, 141, 179, 21, 175,
11, 4, 225, 84, 198, 36, 123, 5, 196, 29, 51, 35, 226, 32,
214, 198, 32, 128, 68, 155, 64, 130, 68, 236, 11, 96, 7, 247,
198, 152, 9, 106, 202, 237, 50, 104, 72, 162, 62, 100, 65, 127,
1, 218, 127, 252, 39, 118, 91, 29, 133, 130, 195, 242, 130, 147,
196, 32, 227, 49, 200, 72, 95, 166, 74, 60, 164, 45, 79, 130,
201, 61, 26, 172, 61, 81, 52, 221, 104, 204, 87, 14, 162, 62,
26, 142, 158, 185, 242, 80, 33, 154, 155, 26, 63, 241, 1, 76,
8, 251, 174, 93, 40, 98, 38, 35, 105, 46, 59, 83, 94, 245,
104, 151, 232, 124, 81, 198, 31, 12, 238, 242, 165, 47, 131, 219,
91, 58, 155, 47, 109, 51, 130, 176, 176, 62, 194, 78, 1, 179,
34, 51, 19, 229, 194, 112, 12, 43, 102, 220, 240, 58, 60, 187,
199, 9, 241, 26, 9, 136, 210, 211, 194, 127, 153, 34, 8, 164,
120, 126, 19, 80, 234, 56, 40, 176, 120, 158, 135, 191, 202, 56,
135, 82, 200, 206, 236, 60, 172, 240, 162, 7, 56, 83, 194, 74,
103, 20, 245, 202, 75, 7, 30, 59, 221, 247, 254, 48, 117, 232,
76, 174, 88, 151, 109, 219, 26, 118, 160, 103, 175, 191, 150, 176,
184, 183, 211, 125, 48, 80, 144, 219, 11, 69, 171, 125, 185, 198,
4, 59, 239, 241, 102, 154, 67, 252, 205, 49, 155, 230, 98, 87,
117, 196, 67, 134, 90, 43, 40, 68, 107, 123, 143, 46, 133, 121,
139, 243, 98, 121, 225, 93, 197, 99, 42, 112, 251, 13, 53, 162,
62, 178, 104, 28, 47, 25, 10, 239, 6, 232, 30, 111, 176, 124,
235, 117, 197, 13, 145, 161, 100, 175, 53, 128, 96, 134, 234, 118,
83, 103, 29, 250, 4, 184, 16, 195, 52, 102, 44, 115, 15, 206,
162, 184, 122, 105, 99, 166, 210, 108, 80, 139, 237, 172, 121, 96,
40, 57, 22, 53, 75, 106, 51, 126, 17, 9, 150, 208, 144, 128,
114, 182, 127, 65, 51, 91, 200, 124, 107, 44, 169, 62, 45, 167,
57, 155, 198, 1, 1, 243, 184, 121, 200, 2, 185, 125, 187, 129,
168, 163, 255, 101, 186, 232, 81, 53, 252, 16, 233, 168, 177, 243,
229, 55, 43, 143, 247, 45, 238, 148, 235, 152, 29, 154, 222, 212,
128, 188, 160, 190, 57, 123, 159, 3, 249, 49, 92, 198, 68, 230,
74, 245, 115, 242, 244, 64, 229, 4, 140, 22, 131, 177, 55, 63,
243, 154, 184, 15, 190, 212, 100, 244, 68, 122, 186, 17, 20, 159,
115, 65, 153, 20, 71, 110, 44, 21, 38, 22, 159, 102, 149, 170,
13, 42, 145, 237, 47, 78, 1, 195, 210, 68, 175, 250, 142, 163,
167, 181, 244, 63, 179, 119, 232, 73, 118, 50, 120, 37, 6, 134,
35, 22, 58, 124, 109, 197, 135, 82, 47, 219, 180, 26, 2, 32,
247, 8, 236, 24, 206, 252, 132, 77, 90, 153, 185, 61, 179, 103,
143, 254, 220, 48, 120, 23, 211, 186, 1, 10, 69, 14, 131, 76,
196, 229, 216, 73, 198, 34, 240, 133, 174, 153, 190, 147, 175, 8,
132, 126, 33, 211, 138, 147, 121, 230, 104, 40, 17, 16, 239, 219,
71, 32, 98, 207, 238, 243, 107, 78, 232, 146, 5, 3, 239, 214,
246, 80, 0, 25, 78, 134, 53, 77, 194, 21, 151, 213, 128, 114,
203, 204, 138, 144, 80, 107, 69, 149, 132, 225, 156, 143, 147, 156,
117, 71, 161, 196, 78, 21, 232, 162, 106, 58, 155, 70, 99, 187,
24, 172, 99, 225, 75, 97, 68, 42, 2, 117, 51, 184, 155, 74,
15, 59, 45, 221, 79, 231, 222, 102, 201, 26, 30, 214, 101, 240,
205, 35, 229, 152, 116, 222, 185, 93, 125, 118, 139, 83, 16, 138,
173, 176, 51, 87, 56, 14, 12, 159, 244, 96, 144, 110, 72, 52,
239, 61, 236, 150, 30, 235, 25, 125, 246, 126, 127, 16, 170, 233,
207, 156, 33, 91, 202, 222, 141, 118, 214, 199, 153, 219, 235, 177,
227, 174, 16, 111, 85, 156, 192, 89, 177, 43, 246, 117, 183, 135,
161, 184, 127, 54, 60, 82, 141, 135, 192, 1, 180, 244, 40, 11,
213, 86, 16, 132, 134, 245, 55, 29, 170, 14, 14, 148, 206, 243,
61, 213, 228, 82, 149, 218, 171, 76, 78, 8, 6, 219, 4, 226,
230, 50, 19, 118, 85, 202, 194, 170, 53, 222, 71, 126, 167, 209,
254, 21, 223, 90, 197, 154, 177, 253, 253, 71, 215, 187, 242, 175,
10, 168, 6, 79, 92, 161, 204, 66, 148, 143, 232, 61, 52, 186,
44, 149, 162, 184, 103, 132, 113, 173, 17, 24, 156, 1, 29, 180,
56, 15, 234, 230, 200, 43, 164, 210, 184, 109, 146, 86, 35, 77,
215, 212, 240, 44, 28, 174, 194, 2, 3, 175, 68, 1, 153, 179,
254, 101, 87, 164, 101, 15, 105, 145, 0, 87, 86, 150, 6, 18,
160, 75, 196, 224, 100, 160, 240, 140, 94, 222, 121, 87, 8, 89,
170, 116, 84, 165, 102, 177, 37, 25, 5, 234, 107, 13, 159, 68,
12, 95, 137, 165, 152, 48, 171, 193, 87, 135, 129, 51, 219, 95,
66, 94, 125, 128, 17, 178, 208, 41, 155, 187, 189, 186, 252, 145,
141, 199, 39, 115, 84, 57, 137, 58, 142, 94, 0, 59, 30, 225,
41, 32, 228, 82, 153, 42, 59, 174, 164, 146, 179, 255, 134, 237,
13, 66, 82, 110, 44, 35, 125, 58, 142, 212, 180, 69, 24, 211,
170, 41, 91, 245, 247, 204, 241, 35, 5, 17, 156, 123, 138, 151,
129, 109, 117, 148, 250, 172, 194, 46, 77, 214, 175, 143, 81, 174,
171, 231, 132, 107, 12, 44, 103, 80, 113, 117, 12, 39, 25, 58,
253, 168, 145, 180, 176, 55, 159, 160, 101, 109, 98, 231, 86, 129,
185, 176, 87, 117, 9, 231, 233, 62, 90, 226, 61, 117, 6, 210,
164, 117, 177, 179, 47, 16, 119, 197, 242, 195, 51, 88, 5, 203,
42, 230, 175, 25, 240, 49, 96, 161, 183, 151, 115, 234, 130, 201,
205, 188, 226, 107, 27, 191, 134, 199, 42, 59, 93, 122, 84, 94,
110, 158, 172, 229, 18, 154, 244, 56, 30, 222, 187, 190, 233, 30,
44, 110, 104, 175, 173, 240, 210, 191, 243, 94, 166, 38, 201, 12,
117, 122, 213, 222, 35, 144, 213, 27, 235, 131, 73, 148, 232, 113,
248, 171, 246, 178, 171, 112, 201, 189, 181, 152, 44, 5, 135, 161,
137, 165, 1, 183, 67, 105, 14, 242, 173, 19, 166, 166, 165, 38,
108, 28, 117, 75, 97, 198, 127, 37, 7, 224, 88, 228, 132, 149,
192, 234, 177, 130, 247, 42, 54, 62, 133, 129, 154, 74, 6, 174,
79, 211, 123, 196, 147, 105, 80, 247, 184, 198, 25, 121, 61, 158,
137, 15, 95, 218, 15, 97, 183, 190, 45, 44, 51, 225, 164, 5,
98, 78, 174, 56, 230, 58, 50, 139, 79, 93, 116, 83, 81, 125,
75, 95, 122, 81, 138, 56, 40, 213, 106, 225, 124, 101, 7, 171,
4, 62, 208, 115, 62, 25, 116, 143, 3, 116, 46, 162, 220, 48,
23, 240, 239, 169, 186, 91, 184, 22, 181, 114, 242, 97, 44, 82,
53, 2, 168, 209, 199, 20, 17, 167, 96, 101, 165, 140, 137, 179,
128, 161, 226, 175, 87, 96, 199, 237, 76, 173, 128, 17, 191, 246,
214, 158, 9, 132, 145, 132, 231, 70, 33, 141, 16, 213, 201, 0,
53, 77, 211, 36, 33, 126, 76, 113, 59, 117, 65, 77, 20, 70,
223, 36, 118, 25, 17, 160, 135, 39, 77, 88, 111, 148, 125, 164,
100, 160, 147, 125, 63, 29, 124, 159, 119, 252, 28, 68, 150, 39,
165, 115, 163, 177, 122, 152, 209, 200, 132, 153, 153, 144, 140, 29,
75, 102, 196, 136, 97, 58, 126, 135, 82, 238, 161, 154, 241, 68,
171, 120, 247, 33, 149, 253, 93, 109, 93, 91, 207, 192, 129, 79,
187, 96, 174, 58, 229, 80, 247, 44, 156, 125, 18, 23, 188, 208,
219, 115, 42, 88, 177, 36, 5, 111, 34, 184, 56, 175, 150, 102,
219, 64, 37, 192, 32, 53, 77, 102, 61, 196, 235, 66, 189, 148,
88, 120, 16, 194, 0, 90, 175, 165, 180, 87, 130, 29, 222, 148,
215, 91, 181, 81, 214, 55, 102, 88, 176, 116, 32, 150, 32, 232,
113, 33, 111, 87, 218, 175, 18, 159, 126, 108, 170, 142, 184, 91,
0, 117, 14, 230, 77, 198, 80, 140, 220, 52, 46, 171, 176, 98,
93, 237, 125, 105, 180, 59, 234, 228, 5, 195, 72, 124, 121, 126,
40, 96, 248, 115, 231, 119, 231, 151, 206, 11, 144, 179, 45, 210,
97, 36, 123, 213, 138, 197, 62, 126, 106, 41, 170, 169, 89, 115,
178, 134, 55, 7, 60, 163, 99, 95, 217, 198, 186, 6, 79, 96,
85, 196, 126, 163, 177, 249, 87, 222, 125, 205, 95, 162, 108, 131,
144, 245, 154, 8, 107, 108, 172, 222, 3, 77, 212, 118, 245, 93,
68, 175, 242, 102, 222, 15, 65, 31, 112, 110, 57, 191, 4, 74,
51, 178, 34, 209, 87, 128, 180, 160, 107, 244, 140, 48, 184, 179,
152, 201, 248, 188, 163, 204, 69, 169, 251, 227, 126, 169, 109, 69,
93, 186, 234, 178, 175, 210, 207, 223, 67, 142, 127, 231, 159, 238,
243, 78, 152, 211, 123, 167, 10, 161, 130, 33, 77, 117, 5, 169,
113, 205, 25, 14, 78, 28, 198, 93, 76, 203, 113, 163, 126, 225,
103, 230, 29, 163, 51, 156, 149, 40, 243, 149, 144, 167, 196, 174,
3, 119, 222, 221, 126, 211, 90, 4, 203, 73, 234, 44, 94, 96,
65, 56, 172, 239, 160, 60, 67, 111, 92, 180, 83, 163, 2, 246,
61, 59, 184, 52, 106, 205, 246, 48, 106, 191, 14, 126, 146, 144,
189, 14, 53, 172, 78, 135, 113, 187, 80, 179, 202, 47, 163, 14,
12, 210, 5, 243, 126, 32, 16, 143, 172, 10, 196, 246, 135, 97,
180, 74, 60, 17, 112, 57, 245, 66, 217, 167, 238, 86, 17, 124,
138, 144, 226, 28, 211, 255, 193, 41, 30, 39, 141, 37, 63, 36,
80, 151, 12, 3, 88, 74, 159, 32, 45, 175, 157, 103, 85, 240,
84, 87, 148, 165, 90, 166, 188, 101, 162, 201, 162, 175, 9, 114,
181, 53, 227, 48, 54, 137, 218, 252, 3, 234, 59, 98, 163, 186,
151, 56, 119, 178, 156, 250, 115, 36, 112, 246, 115, 232, 63, 192,
160, 86, 34, 188, 156, 139, 163, 147, 91, 23, 146, 252, 236, 164,
240, 185, 53, 88, 234, 140, 40, 188, 83, 255, 45, 82, 180, 69,
53, 101, 78, 197, 116, 177, 208, 126, 93, 204, 169, 46, 155, 204,
207, 130, 63, 197, 246, 66, 6, 163, 210, 131, 140, 211, 205, 73,
141, 59, 45, 189, 169, 90, 84, 69, 231, 140, 206, 19, 165, 55,
34, 245, 245, 54, 15, 28, 98, 97, 63, 236, 42, 45, 208, 197,
245, 98, 182, 61, 232, 127, 176, 14, 218, 156, 226, 20, 117, 253,
200, 34, 118, 75, 207, 88, 100, 39, 150, 243, 23, 84, 66, 3,
212, 8, 28, 103, 156, 175, 36, 241, 65, 150, 203, 207, 61, 51,
135, 186, 205, 235, 204, 168, 159, 120, 171, 161, 135, 131, 231, 87,
210, 56, 120, 100, 252, 81, 124, 16, 157, 179, 211, 119, 80, 68,
50, 66, 148, 106, 208, 39, 4, 218, 132, 181, 155, 187, 190, 45,
189, 154, 94, 51, 13, 0, 142, 115, 174, 5, 164, 191, 154, 50,
44, 27, 135, 120, 250, 147, 190, 83, 226, 13, 88, 174, 89, 64,
214, 66, 199, 32, 202, 73, 79, 81, 176, 215, 88, 178, 19, 51,
181, 249, 176, 224, 170, 182, 69, 176, 148, 93, 255, 37, 190, 41,
250, 122, 147, 23, 184, 218, 228, 139, 75, 171, 16, 100, 110, 163,
200, 131, 146, 237, 156, 239, 201, 3, 89, 113, 93, 222, 180, 239,
200, 137, 180, 212, 35, 142, 150, 50, 95, 212, 18, 246, 172, 79,
156, 64, 24, 79, 11, 84, 175, 121, 148, 241, 197, 90, 233, 57,
122, 192, 31, 152, 3, 55, 140, 105, 202, 225, 213, 245, 69, 129,
61, 245, 242, 226, 156, 153, 123, 174, 182, 74, 55, 53, 158, 154,
131, 77, 172, 78, 220, 27, 206, 181, 28, 164, 8, 226, 31, 7,
34, 131, 234, 77, 214, 219, 16, 119, 168, 35, 73, 98, 21, 255,
225, 87, 74, 39, 198, 31, 226, 237, 0, 66, 46, 168, 32, 157,
47, 147, 2, 217, 29, 219, 76, 203, 47, 140, 216, 166, 236, 240,
244, 22, 216, 70, 252, 226, 69, 96, 32, 62, 201, 21, 40, 230,
160, 212, 72, 188, 234, 199, 4, 200, 215, 238, 96, 222, 58, 202,
65, 182, 211, 9, 249, 176, 60, 197, 183, 15, 75, 91, 242, 211,
17, 211, 236, 47, 73, 11, 37, 103, 250, 35, 117, 59, 210, 49,
157, 10, 50, 96, 30, 102, 253, 169, 32, 165, 176, 77, 70, 36,
48, 201, 125, 38, 27, 99, 91, 116, 217, 135, 231, 179, 40, 23,
175, 196, 138, 107, 180, 161, 180, 191, 242, 67, 206, 128, 242, 27,
247, 199, 160, 210, 210, 79, 98, 254, 154, 102, 114, 19, 212, 185,
210, 109, 5, 31, 72, 43, 0, 254, 33, 141, 7, 240, 0, 18,
222, 44, 128, 162, 209, 129, 107, 108, 82, 69, 30, 111, 252, 80,
234, 141, 82, 46, 203, 113, 186, 41, 19, 21, 107, 64, 151, 187,
124, 158, 242, 159, 143, 221, 238, 89, 192, 207, 174, 47, 17, 235,
108, 226, 97, 169, 142, 203, 211, 5, 4, 60, 220, 154, 245, 200,
48, 2, 217, 17, 241, 212, 145, 121, 177, 166, 186, 175, 236, 249,
198, 55, 180, 141, 105, 236, 17, 101, 225, 148, 229, 62, 151, 148,
150, 204, 101, 160, 114, 203, 144, 154, 226, 8, 62, 43, 208, 40,
98, 22, 49, 238, 234, 119, 209, 106, 34, 178, 152, 21, 24, 238,
247, 115, 26, 108, 51, 244, 89, 32, 7, 89, 66, 175, 2, 163,
30, 184, 31, 106, 98, 40, 110, 95, 39, 145, 160, 188, 150, 73,
91, 230, 61, 56, 9, 76, 152, 140, 15, 185, 236, 107, 216, 34,
137, 48, 96, 225, 135, 113, 101, 79, 50, 142, 103, 250, 49, 124,
23, 206, 186, 16, 153, 142, 94, 202, 100, 243, 151, 244, 20, 148,
2, 183, 109, 111, 77, 111, 80, 138, 9, 214, 160, 217, 16, 108,
72, 14, 79, 163, 156, 113, 130, 114, 55, 194, 28, 52, 218, 6,
139, 72, 160, 158, 105, 63, 85, 234, 38, 192, 89, 35, 44, 227,
154, 240, 23, 186, 140, 246, 118, 247, 253, 31, 35, 75, 130, 57,
165, 146, 78, 214, 41, 204, 49, 83, 144, 3, 251, 108, 140, 104,
174, 34, 79, 79, 143, 61, 73, 6, 193, 217, 50, 24, 158, 87,
168, 82, 119, 157, 254, 121, 192, 119, 131, 107, 26, 192, 73, 135,
53, 132, 134, 59, 190, 252, 3, 89, 33, 102, 181, 25, 237, 67,
130, 207, 248, 240, 166, 114, 244, 41, 129, 65, 222, 24, 115, 72,
78, 246, 15, 27, 211, 193, 6, 93, 171, 22, 196, 92, 27, 67,
235, 149, 251, 39, 48, 169, 13, 179, 101, 171, 253, 229, 198, 247,
175, 253, 87, 52, 76, 128, 227, 17, 199, 99, 251, 144, 252, 228,
86, 119, 83, 11, 81, 137, 224, 121, 213, 246, 237, 115, 14, 33,
72, 186, 8, 226, 53, 97, 126, 88, 214, 61, 175, 224, 214, 238,
246, 171, 32, 203, 83, 125, 27, 146, 206, 116, 154, 252, 17, 72,
96, 5, 159, 121, 70, 123, 201, 78, 19, 146, 174, 144, 116, 60,
121, 190, 220, 254, 161, 4, 103, 155, 126, 239, 244, 243, 182, 8,
27, 205, 130, 98, 90, 26, 133, 172, 53, 31, 17, 99, 120, 202,
135, 107, 197, 242, 61, 208, 65, 236, 181, 184, 73, 185, 85, 90,
167, 9, 228, 58, 240, 67, 89, 133, 236, 34, 118, 106, 50, 190,
101, 240, 6, 141, 141, 19, 243, 10, 210, 232, 163, 141, 41, 151,
119, 219, 74, 3, 146, 154, 77, 219, 170, 206, 89, 144, 228, 226,
171, 61, 216, 0, 157, 178, 202, 230, 128, 166, 120, 45, 61, 165,
142, 208, 11, 21, 164, 63, 10, 229, 132, 82, 36, 197, 177, 252,
142, 81, 207, 143, 81, 65, 110, 221, 153, 198, 145, 162, 62, 165,
106, 79, 133, 241, 17, 183, 115, 194, 137, 53, 77, 0, 167, 57,
202, 75, 206, 118, 11, 166, 195, 13, 170, 242, 111, 66, 123, 48,
240, 139, 118, 194, 45, 199, 7, 249, 127, 75, 51, 246, 192, 242,
45, 183, 84, 1, 207, 205, 29, 175, 222, 156, 197, 18, 232, 200,
61, 97, 156, 138, 125, 16, 180, 91, 149, 139, 36, 226, 197, 129,
132, 159, 22, 49, 49, 104, 141, 124, 82, 80, 179, 55, 107, 25,
149, 165, 14, 144, 61, 208, 75, 2, 203, 5, 203, 219, 111, 215,
55, 53, 222, 59, 139, 253, 9, 200, 65, 71, 171, 177, 242, 30,
83, 135, 50, 190, 99, 198, 32, 164, 243, 140, 145, 174, 49, 232,
251, 152, 233, 202, 190, 31, 51, 160, 242, 176, 47, 119, 124, 236,
2, 87, 26, 255, 224, 39, 202, 6, 202, 25, 216, 180, 118, 60,
181, 89, 233, 208, 0, 69, 0, 187, 66, 36, 9, 66, 236, 158,
251, 61, 18, 136, 197, 124, 13, 212, 159, 51, 169, 125, 102, 181,
205, 88, 195, 190, 221, 236, 85, 167, 32, 42, 90, 27, 202, 107,
192, 200, 68, 162, 40, 47, 79, 82, 48, 248, 57, 132, 78, 65,
91, 30, 11, 158, 234, 102, 194, 155, 148, 154, 253, 210, 80, 228,
17, 148, 148, 128, 40, 57, 169, 124, 176, 20, 62, 213, 198, 93,
94, 7, 225, 195, 112, 112, 242, 122, 254, 151, 145, 41, 100, 228,
168, 164, 18, 5, 84, 131, 151, 51, 173, 37, 226, 226, 252, 202,
14, 140, 155, 13, 23, 7, 106, 37, 180, 37, 85, 244, 76, 7,
117, 44, 57, 48, 95, 249, 126, 32, 168, 232, 189, 26, 162, 204,
230, 117, 89, 235, 239, 85, 42, 118, 208, 95, 178, 137, 199, 48,
25, 110, 70, 5, 168, 245, 231, 61, 134, 177, 71, 247, 176, 17,
196, 159, 231, 200, 41, 105, 43, 62, 231, 25, 102, 156, 19, 134,
172, 202, 207, 199, 163, 219, 100, 170, 117, 160, 113, 40, 172, 86,
177, 227, 15, 159, 233, 149, 153, 246, 101, 111, 32, 96, 71, 150,
132, 143, 68, 12, 8, 27, 34, 195, 72, 186, 223, 248, 118, 82,
42, 35, 145, 100, 226, 164, 206, 163, 137, 154, 234, 66, 169, 112,
173, 170, 70, 27, 159, 188, 249, 245, 221, 216, 198, 50, 152, 232,
249, 223, 250, 86, 178, 236, 110, 189, 10, 111, 10, 30, 247, 192,
185, 149, 12, 162, 209, 122, 145, 156, 37, 133, 137, 197, 246, 55,
105, 48, 204, 158, 67, 22, 102, 3, 95, 241, 58, 4, 170, 86,
185, 113, 244, 33, 199, 215, 20, 54, 248, 45, 121, 75, 149, 192,
8, 160, 54, 71, 28, 176, 42, 134, 191, 147, 20, 117, 42, 142,
107, 65, 179, 153, 250, 78, 17, 60, 105, 206, 72, 214, 204, 169,
118, 196, 41, 48, 191, 125, 79, 193, 250, 212, 113, 41, 148, 245,
1, 71, 130, 26, 68, 48, 14, 76, 225, 74, 231, 140, 76, 34,
60, 31, 112, 19, 144, 65, 216, 245, 167, 181, 46, 175, 126, 243,
111, 158, 132, 29, 79, 127, 16, 194, 45, 192, 101, 61, 127, 70,
132, 162, 222, 92, 139, 187, 57, 166, 72, 242, 146, 254, 89, 102,
57, 7, 148, 153, 241, 104, 249, 181, 46, 208, 249, 143, 149, 209,
210, 188, 41, 109, 78, 184, 169, 177, 67, 36, 169, 29, 56, 121,
112, 226, 234, 119, 138, 55, 113, 246, 6, 109, 160, 62, 99, 114,
17, 231, 20, 132, 211, 211, 21, 8, 62, 120, 106, 104, 212, 136,
150, 164, 111, 120, 147, 162, 49, 94, 168, 145, 40, 66, 173, 164,
143, 54, 206, 180, 244, 200, 98, 122, 111, 206, 166, 92, 246, 108,
21, 202, 56, 67, 119, 76, 205, 54, 61, 209, 230, 47, 45, 31,
83, 75, 7, 137, 154, 169, 235, 143, 219, 160, 34, 104, 150, 161,
160, 204, 103, 250, 174, 83, 68, 233, 8, 19, 29, 162, 88, 172,
253, 126, 61, 199, 78, 43, 220, 46, 246, 171, 78, 233, 224, 20,
112, 143, 197, 90, 25, 164, 156, 37, 11, 43, 94, 188, 44, 78,
32, 182, 33, 132, 56, 56, 215, 56, 127, 53, 184, 190, 5, 136,
19, 149, 79, 223, 104, 212, 58, 165, 129, 124, 140, 233, 109, 66,
64, 117, 55, 128, 97, 106, 0, 26, 10, 51, 127, 150, 152, 111,
166, 168, 222, 54, 159, 61, 138, 100, 56, 85, 15, 128, 79, 4,
200, 151, 183, 149, 210, 147, 97, 140, 36, 217, 232, 198, 95, 73,
9, 174, 106, 205, 241, 196, 187, 223, 211, 250, 199, 238, 122, 22,
130, 111, 253, 156, 40, 137, 92, 96, 223, 235, 242, 45, 114, 207,
211, 125, 236, 55, 189, 136, 208, 66, 199, 205, 92, 65, 175, 168,
156, 123, 44, 75, 75, 29, 56, 108, 75, 226, 16, 240, 24, 37,
75, 155, 254, 195, 182, 42, 239, 38, 255, 227, 17, 138, 161, 82,
63, 191, 198, 117, 250, 133, 21, 169, 186, 212, 148, 55, 8, 199,
131, 245, 89, 169, 131, 12, 239, 99, 211, 134, 211, 108, 91, 245,
73, 184, 33, 156, 236, 44, 189, 183, 135, 214, 104, 145, 229, 94,
21, 34, 237, 102, 220, 175, 167, 135, 180, 57, 84, 2, 49, 124,
237, 238, 242, 39, 39, 160, 120, 128, 145, 148, 45, 27, 211, 148,
163, 126, 234, 175, 35, 44, 59, 117, 248, 47, 69, 108, 164, 96,
246, 198, 165, 82, 15, 123, 61, 63, 106, 23, 129, 189, 87, 205,
63, 95, 134, 126, 236, 197, 156, 204, 6, 203, 77, 170, 190, 71,
27, 239, 134, 221, 57, 145, 202, 60, 149, 237, 84, 7, 198, 25,
243, 34, 34, 122, 219, 188, 216, 219, 107, 241, 222, 85, 169, 106,
45, 220, 241, 67, 121, 94, 69, 90, 198, 64, 122, 104, 84, 255,
25, 7, 151, 254, 155, 138, 174, 238, 18, 147, 127, 111, 7, 92,
170, 45, 225, 23, 12, 120, 208, 184, 174, 121, 22, 0, 51, 15,
47, 135, 44, 213, 83, 215, 75, 236, 148, 76, 114, 9, 113, 221,
188, 114, 125, 96, 212, 60, 190, 99, 236, 100, 245, 132, 81, 121,
30, 55, 142, 55, 209, 226, 173, 108, 48, 53, 163, 206, 138, 148,
0, 152, 99, 215, 152, 206, 149, 238, 222, 199, 39, 157, 50, 59,
33, 157, 125, 140, 210, 178, 216, 93, 58, 60, 20, 17, 114, 185,
234, 133, 127, 167, 126, 25, 109, 199, 135, 92, 236, 86, 93, 86,
50, 11, 119, 219, 155, 130, 229, 219, 97, 173, 68, 27, 27, 159,
85, 210, 13, 95, 230, 27, 194, 201, 106, 211, 90, 99, 101, 50,
219, 141, 120, 219, 42, 99, 121, 11, 184, 44, 104, 86, 142, 232,
212, 15, 242, 83, 37, 76, 160, 238, 113, 9, 33, 0, 31, 27,
49, 245, 142, 44, 93, 173, 66, 218, 63, 63, 96, 130, 77, 70,
247, 130, 170, 203, 32, 49, 124, 255, 183, 81, 178, 106, 83, 6,
17, 58, 189, 110, 95, 189, 65, 66, 136, 248, 185, 75, 73, 210,
134, 91, 45, 196, 155, 240, 142, 218, 172, 180, 51, 92, 185, 6,
148, 245, 35, 150, 56, 236, 210, 9, 193, 212, 185, 48, 170, 102,
46, 125, 157, 245, 63, 33, 103, 210, 94, 84, 4, 204, 246, 116,
2, 80, 223, 145, 200, 92, 84, 42, 7, 13, 61, 120, 69, 40,
236, 39, 132, 208, 239, 51, 111, 197, 50, 142, 56, 196, 164, 37,
22, 130, 7, 119, 63, 152, 165, 182, 195, 117, 208, 119, 118, 102,
177, 64, 114, 68, 229, 233, 246, 27, 179, 146, 225, 146, 78, 4,
231, 225, 205, 2, 31, 236, 218, 154, 162, 98, 95, 48, 114, 255,
235, 55, 130, 73, 75, 211, 96, 226, 56, 39, 153, 246, 77, 35,
177, 31, 55, 151, 58, 199, 232, 157, 106, 228, 170, 144, 187, 17,
106, 181, 252, 190, 253, 87, 78, 90, 65, 152, 164, 85, 99, 184,
133, 48, 180, 165, 164, 225, 72, 198, 180, 224, 225, 178, 177, 26,
50, 29, 249, 15, 61, 192, 254, 130, 13, 212, 30, 155, 235, 62,
88, 52, 102, 141, 6, 174, 123, 228, 244, 107, 6, 206, 77, 88,
85, 36, 173, 87, 218, 12, 2, 177, 137, 108, 204, 178, 98, 109,
197, 15, 20, 148, 69, 87, 96, 160, 107, 176, 6, 138, 101, 4,
83, 23, 44, 39, 214, 207, 175, 9, 149, 36, 243, 78, 62, 244,
104, 16, 190, 153, 103, 241, 199, 59, 33, 189, 180, 53, 96, 98,
37, 128, 235, 204, 86, 26, 140, 144, 90, 225, 240, 237, 135, 60,
229, 88, 60, 217, 199, 4, 70, 18, 232, 184, 162, 7, 178, 160,
176, 47, 63, 89, 18, 40, 48, 114, 233, 209, 11, 133, 81, 165,
195, 227, 136, 51, 22, 201, 16, 209, 171, 169, 16, 1, 135, 37,
118, 60, 73, 151, 117, 183, 191, 174, 21, 127, 180, 165, 201, 208,
129, 204, 141, 57, 239, 150, 244, 159, 178, 173, 168, 92, 241, 214,
109, 14, 164, 136, 141, 25, 2, 45, 65, 94, 207, 228, 54, 251,
5, 100, 60, 147, 217, 97, 187, 117, 248, 77, 100, 238, 74, 104,
205, 68, 95, 141, 57, 145, 108, 32, 22, 85, 204, 199, 179, 46,
96, 143, 116, 77, 96, 34, 227, 5, 201, 202, 125, 235, 171, 93,
135, 18, 76, 34, 112, 30, 131, 162, 147, 10, 17, 75, 174, 250,
118, 53, 139, 164, 62, 104, 221, 182, 79, 142, 42, 20, 126, 104,
162, 205, 34, 74, 241, 57, 10, 160, 240, 224, 199, 163, 231, 6,
206, 104, 129, 164, 2, 136, 247, 35, 211, 198, 203, 116, 130, 212,
177, 3, 131, 17, 239, 154, 56, 40, 32, 98, 86, 22, 151, 121,
229, 40, 51, 46, 3, 51, 132, 183, 127, 155, 228, 77, 157, 121,
133, 213, 173, 87, 23, 155, 108, 193, 55, 214, 62, 95, 221, 178,
169, 182, 197, 114, 176, 117, 82, 170, 234, 250, 142, 159, 39, 250,
155, 160, 141, 246, 217, 252, 161, 42, 110, 144, 26, 33, 203, 63,
186, 47, 164, 187, 195, 20, 173, 254, 80, 243, 68, 164, 20, 28,
153, 142, 215, 95, 67, 230, 210, 130, 56, 172, 155, 120, 105, 141,
246, 210, 2, 4, 19, 35, 216, 71, 174, 49, 234, 25, 142, 166,
102, 229, 12, 45, 13, 178, 209, 205, 48, 40, 191, 58, 198, 216,
133, 207, 127, 243, 16, 192, 8, 96, 43, 96, 49, 166, 87, 238,
235, 71, 196, 151, 68, 22, 244, 187, 189, 60, 107, 181, 25, 178,
159, 84, 21, 11, 233, 133, 217, 219, 61, 129, 253, 186, 174, 111,
42, 55, 143, 119, 155, 122, 45, 242, 163, 132, 84, 5, 112, 56,
164, 139, 128, 119, 57, 147, 8, 54, 78, 150, 200, 193, 83, 99,
88, 133, 196, 234, 123, 95, 157, 160, 215, 28, 181, 252, 183, 62,
217, 197, 187, 2, 181, 246, 183, 206, 178, 40, 91, 196, 110, 156,
28, 129, 42, 170, 126, 244, 117, 169, 57, 96, 163, 45, 74, 80,
28, 29, 203, 105, 131, 17, 210, 49, 61, 139, 26, 40, 179, 253,
71, 194, 8, 107, 130, 201, 99, 77, 22, 156, 179, 19, 131, 54,
192, 103, 108, 255, 89, 244, 115, 153, 101, 88, 63, 124, 34, 19,
69, 248, 242, 161, 78, 103, 55, 31, 181, 53, 199, 44, 66, 70,
171, 232, 167, 251, 46, 231, 177, 244, 6, 111, 88, 121, 133, 164,
83, 78, 232, 78, 71, 164, 248, 134, 196, 39, 53, 66, 198, 167,
239, 65, 17, 142, 239, 223, 67, 16, 15, 174, 217, 80, 2, 130,
238, 145, 202, 194, 105, 14, 121, 185, 57, 51, 145, 208, 226, 74,
46, 210, 171, 238, 10, 151, 181, 10, 163, 168, 52, 211, 234, 90,
35, 75, 148, 76, 63, 68, 132, 37, 31, 255, 82, 175, 77, 228,
237, 217, 117, 166, 175, 127, 223, 101, 189, 139, 70, 60, 64, 110,
27, 86, 139, 183, 172, 17, 117, 140, 117, 67, 87, 133, 109, 254,
83, 145, 214, 253, 148, 242, 53, 50, 252, 194, 223, 175, 77, 241,
28, 63, 247, 27, 101, 28, 21, 151, 245, 49, 155, 33, 26, 155,
160, 190, 98, 34, 191, 199, 96, 98, 47, 205, 183, 252, 86, 168,
150, 63, 254, 8, 134, 195, 17, 68, 10, 249, 90, 109, 237, 219,
168, 60, 252, 190, 133, 218, 220, 69, 25, 223, 3, 236, 74, 229,
79, 218, 186, 199, 234, 17, 215, 145, 198, 228, 129, 239, 107, 4,
229, 188, 212, 241, 204, 45, 201, 72, 17, 175, 136, 180, 122, 94,
40, 239, 41, 91, 97, 253, 61, 244, 16, 29, 4, 248, 201, 175,
1, 122, 0, 143, 62, 112, 132, 213, 46, 49, 98, 228, 94, 77,
179, 46, 245, 160, 65, 179, 53, 0, 86, 139, 154, 79, 249, 177,
6, 78, 184, 139, 143, 139, 240, 134, 109, 66, 1, 3, 180, 251,
19, 3, 211, 36, 32, 79, 181, 249, 205, 25, 4, 168, 238, 50,
75, 128, 97, 121, 94, 199, 92, 200, 241, 75, 136, 155, 109, 121,
250, 15, 163, 173, 82, 26, 41, 86, 189, 61, 79, 137, 162, 129,
12, 178, 217, 213, 0, 244, 81, 216, 64, 99, 174, 72, 44, 215,
110, 88, 235, 152, 38, 64, 141, 88, 253, 95, 159, 151, 30, 73,
48, 134, 145, 116, 77, 51, 246, 120, 221, 36, 241, 182, 159, 209,
72, 29, 45, 120, 4, 98, 121, 19, 45, 231, 184, 252, 119, 181,
222, 61, 2, 151, 138, 123, 119, 90, 6, 202, 85, 240, 239, 156,
211, 83, 169, 127, 39, 111, 226, 90, 88, 91, 79, 197, 119, 26,
29, 205, 176, 209, 254, 133, 195, 189, 208, 172, 218, 101, 198, 240,
243, 84, 2, 103, 141, 229, 183, 137, 37, 128, 73, 32, 223, 198,
165, 78, 253, 72, 83, 64, 232, 214, 251, 237, 204, 67, 181, 195,
232, 104, 61, 1, 166, 79, 231, 227, 78, 178, 203, 67, 131, 141,
194, 162, 141, 234, 238, 32, 23, 161, 112, 90, 181, 151, 228, 180,
189, 144, 124, 177, 132, 40, 76, 149, 159, 118, 215, 110, 211, 204,
72, 87, 12, 75, 112, 138, 198, 84, 56, 208, 171, 58, 222, 110,
249, 191, 139, 31, 164, 206, 191, 235, 27, 117, 171, 46, 254, 157,
212, 61, 216, 153, 179, 60, 224, 242, 26, 94, 229, 165, 235, 53,
57, 28, 29, 1, 240, 145, 181, 15, 255, 26, 186, 32, 222, 75,
250, 71, 221, 208, 72, 4, 245, 137, 182, 137, 38, 9, 22, 137,
210, 87, 27, 164, 57, 141, 75, 249, 20, 182, 66, 177, 187, 143,
169, 142, 189, 226, 114, 231, 129, 160, 174, 16, 83, 14, 247, 164,
51, 48, 86, 47, 143, 107, 241, 211, 123, 188, 56, 103, 133, 160,
0, 186, 59, 173, 121, 241, 159, 251, 227, 77, 239, 14, 85, 253,
89, 108, 71, 58, 116, 41, 139, 141, 146, 48, 156, 218, 249, 57,
142, 194, 241, 70, 170, 151, 39, 169, 240, 208, 29, 155, 186, 167,
235, 48, 68, 83, 83, 57, 103, 128, 183, 14, 35, 219, 52, 80,
107, 5, 68, 214, 10, 28, 127, 172, 240, 107, 153, 154, 73, 8,
23, 45, 232, 78, 113, 102, 145, 70, 140, 111, 48, 5, 125, 173,
137, 67, 19, 63, 49, 249, 149, 4, 140, 98, 161, 41, 221, 65,
173, 56, 101, 177, 70, 111, 51, 89, 130, 210, 197, 95, 73, 26,
200, 223, 178, 14, 85, 134, 87, 206, 204, 168, 157, 182, 14, 36,
146, 48, 139, 68, 158, 181, 84, 61, 109, 160, 249, 13, 56, 156,
232, 159, 188, 161, 157, 108, 201, 123, 224, 181, 30, 223, 186, 248,
55, 218, 233, 25, 212, 14, 103, 83, 78, 243, 20, 123, 252, 246,
203, 181, 65, 194, 130, 128, 50, 208, 45, 60, 177, 86, 163, 165,
118, 97, 247, 218, 50, 211, 206, 116, 238, 138, 99, 61, 103, 84,
184, 189, 10, 115, 191, 18, 14, 240, 255, 102, 172, 134, 52, 111,
157, 8, 161, 76, 161, 133, 155, 253, 20, 216, 116, 149, 140, 79,
27, 238, 66, 174, 153, 60, 132, 34, 86, 224, 223, 243, 42, 55,
62, 216, 7, 246, 106, 206, 123, 240, 96, 220, 165, 200, 36, 219,
222, 133, 199, 185, 122, 139, 245, 12, 191, 100, 61, 186, 60, 126,
200, 177, 115, 102, 219, 218, 50, 233, 226, 95, 23, 208, 186, 233,
45, 154, 104, 165, 51, 195, 50, 141, 138, 92, 54, 213, 243, 135,
125, 17, 135, 38, 88, 109, 73, 31, 139, 34, 74, 122, 154, 236,
242, 100, 127, 24, 227, 159, 29, 28, 198, 246, 197, 1, 211, 146,
203, 185, 36, 37, 56, 182, 53, 234, 109, 0, 39, 49, 68, 252,
71, 200, 198, 40, 94, 196, 143, 180, 43, 164, 91, 78, 160, 255,
110, 134, 191, 184, 234, 100, 63, 0, 21, 129, 77, 65, 83, 96,
200, 8, 49, 83, 8, 190, 226, 158, 98, 161, 158, 79, 134, 197,
70, 1, 42, 11, 169, 105, 77, 237, 237, 161, 117, 242, 160, 113,
73, 114, 88, 179, 85, 78, 26, 78, 170, 250, 16, 189, 110, 135,
38, 72, 79, 175, 89, 80, 219, 215, 62, 230, 84, 217, 183, 240,
124, 57, 127, 159, 100, 71, 208, 171, 195, 141, 165, 126, 208, 1,
198, 137, 208, 180, 218, 81, 2, 12, 22, 184, 151, 67, 37, 180,
90, 8, 202, 186, 154, 64, 15, 15, 135, 46, 31, 181, 146, 244,
54, 55, 197, 52, 83, 18, 33, 233, 109, 9, 223, 183, 166, 134,
43, 127, 134, 98, 159, 55, 38, 111, 117, 24, 128, 199, 113, 167,
113, 64, 160, 247, 79, 106, 71, 240, 76, 63, 155, 31, 60, 41,
230, 142, 107, 174, 106, 31, 72, 60, 208, 217, 75, 54, 33, 180,
211, 82, 115, 143, 13, 7, 198, 31, 125, 243, 157, 124, 47, 98,
246, 50, 179, 144, 12, 2, 51, 183, 144, 115, 210, 40, 225, 113,
99, 252, 244, 150, 175, 93, 56, 244, 97, 249, 149, 110, 251, 128,
152, 222, 186, 86, 86, 147, 124, 166, 74, 106, 230, 227, 247, 235,
119, 106, 198, 182, 14, 100, 233, 218, 115, 71, 201, 89, 21, 162,
58, 106, 140, 254, 190, 79, 36, 101, 102, 245, 165, 20, 194, 63,
102, 14, 141, 196, 57, 169, 111, 241, 72, 239, 126, 142, 145, 253,
166, 222, 94, 143, 169, 250, 104, 119, 51, 9, 255, 132, 197, 33,
159, 220, 253, 122, 235, 66, 224, 120, 201, 209, 90, 113, 85, 162,
221, 219, 39, 45, 77, 48, 95, 152, 225, 40, 3, 90, 109, 49,
212, 44, 15, 82, 158, 42, 91, 127, 144, 237, 54, 70, 44, 104,
2, 91, 90, 40, 24, 228, 122, 82, 15, 194, 211, 169, 107, 231,
33, 18, 94, 79, 103, 70, 233, 140, 73, 187, 152, 190, 149, 216,
220, 64, 220, 112, 170, 115, 16, 114, 108, 63, 10, 1, 158, 157,
3, 127, 51, 154, 225, 49, 144, 201, 50, 139, 162, 106, 56, 253,
81, 32, 137, 7, 236, 232, 50, 65, 40, 132, 31, 32, 125, 63,
232, 229, 180, 118, 17, 136, 181, 66, 255, 213, 98, 246, 104, 51,
4, 19, 27, 87, 110, 252, 247, 64, 83, 98, 131, 76, 115, 51,
83, 26, 31, 205, 55, 4, 91, 90, 60, 133, 142, 39, 70, 73,
179, 119, 84, 100, 50, 169, 166, 157, 148, 215, 121, 220, 166, 235,
21, 237, 89, 222, 199, 177, 211, 242, 9, 208, 127, 109, 218, 224,
146, 114, 137, 51, 128, 95, 166, 196, 105, 112, 135, 99, 227, 229,
255, 153, 20, 80, 163, 60, 16, 8, 92, 210, 20, 207, 186, 187,
175, 193, 125, 31, 221, 145, 0, 243, 222, 202, 54, 170, 160, 24,
242, 255, 241, 217, 44, 178, 124, 147, 117, 0, 168, 33, 167, 80,
101, 183, 205, 218, 249, 21, 151, 171, 251, 7, 120, 252, 223, 98,
255, 66, 196, 89, 41, 51, 37, 41, 28, 183, 4, 202, 135, 117,
84, 199, 176, 9, 176, 203, 239, 7, 219, 136, 226, 156, 198, 19,
64, 243, 60, 39, 162, 26, 208, 239, 6, 3, 176, 22, 129, 244,
40, 85, 253, 39, 92, 72, 65, 157, 69, 175, 205, 84, 43, 22,
240, 242, 67, 86, 195, 58, 145, 136, 245, 40, 46, 190, 243, 231,
206, 88, 134, 31, 136, 172, 57, 142, 250, 67, 60, 2, 136, 253,
97, 187, 121, 50, 139, 189, 77, 113, 16, 126, 35, 247, 157, 1,
134, 128, 127, 209, 239, 20, 204, 236, 50, 24, 28, 71, 18, 83,
51, 48, 125, 2, 124, 229, 220, 97, 217, 133, 4, 241, 242, 63,
123, 158, 201, 246, 232, 186, 237, 65, 9, 247, 66, 196, 15, 240,
215, 22, 236, 233, 245, 9, 183, 218, 9, 1, 56, 242, 11, 184,
117, 97, 248, 193, 219, 143, 245, 254, 154, 216, 183, 63, 126, 10,
142, 252, 231, 211, 109, 198, 131, 248, 249, 125, 196, 74, 10, 178,
12, 93, 73, 109, 248, 25, 69, 161, 187, 41, 7, 102, 235, 195,
83, 181, 154, 164, 78, 251, 192, 82, 230, 229, 7, 175, 41, 39,
204, 38, 161, 120, 93, 40, 66, 104, 248, 22, 46, 45, 203, 240,
19, 111, 111, 49, 127, 226, 118, 246, 161, 210, 85, 145, 188, 91,
200, 4, 11, 5, 224, 129, 234, 190, 181, 3, 9, 0, 95, 188,
122, 1, 3, 169, 95, 142, 78, 60, 123, 36, 239, 231, 135, 22,
156, 138, 63, 0, 12, 39, 126, 250, 157, 108, 188, 131, 81, 226,
5, 190, 166, 230, 95, 92, 39, 138, 91, 23, 82, 23, 72, 240,
109, 86, 228, 175, 26, 81, 117, 230, 135, 68, 162, 203, 110, 44,
188, 24, 21, 153, 118, 29, 194, 181, 12, 209, 146, 202, 33, 49,
80, 60, 100, 74, 13, 126, 209, 132, 43, 125, 242, 184, 132, 111,
147, 59, 21, 67, 234, 222, 17, 232, 176, 147, 238, 115, 197, 226,
248, 24, 51, 148, 97, 229, 38, 248, 43, 122, 45, 158, 158, 212,
87, 123, 136, 48, 153, 170, 104, 203, 43, 111, 45, 64, 158, 249,
37, 247, 139, 187, 118, 42, 185, 147, 181, 226, 129, 70, 166, 46,
223, 252, 236, 164, 221, 10, 250, 74, 201, 112, 111, 198, 37, 95,
104, 197, 107, 248, 214, 233, 243, 253, 26, 228, 26, 217, 255, 42,
250, 104, 13, 4, 235, 217, 243, 36, 212, 184, 16, 44, 108, 189,
253, 43, 113, 249, 161, 55, 173, 225, 88, 229, 248, 107, 134, 165,
190, 59, 46, 6, 32, 15, 24, 37, 120, 83, 67, 122, 238, 34,
235, 79, 144, 35, 84, 251, 58, 88, 141, 112, 147, 42, 130, 206,
64, 22, 58, 129, 172, 74, 194, 161, 89, 141, 195, 202, 137, 152,
14, 115, 244, 236, 132, 211, 0, 188, 58, 163, 209, 119, 103, 189,
150, 188, 202, 136, 251, 205, 180, 115, 7, 41, 225, 227, 26, 22,
27, 91, 122, 160, 205, 129, 29, 240, 220, 131, 157, 123, 122, 50,
158, 30, 21, 74, 11, 186, 190, 103, 218, 27, 54, 57, 179, 228,
207, 9, 51, 12, 204, 232, 60, 150, 147, 84, 36, 183, 1, 25,
57, 177, 156, 1, 158, 226, 128, 33, 172, 3, 253, 114, 25, 102,
125, 144, 238, 102, 106, 191, 105, 3, 135, 229, 200, 1, 215, 223,
23, 231, 173, 27, 98, 25, 204, 107, 50, 90, 252, 223, 116, 186,
216, 173, 121, 201, 151, 162, 73, 57, 131, 197, 173, 240, 102, 236,
113, 125, 129, 198, 124, 71, 104, 249, 89, 5, 105, 53, 224, 215,
238, 141, 78, 6, 176, 233, 133, 58, 0, 159, 231, 17, 159, 104,
127, 239, 55, 41, 51, 173, 176, 118, 62, 108, 40, 12, 246, 234,
218, 227, 218, 56, 142, 148, 172, 247, 86, 52, 253, 94, 60, 64,
131, 204, 158, 107, 184, 170, 107, 155, 139, 239, 11, 152, 172, 216,
107, 6, 171, 108, 51, 34, 168, 8, 45, 227, 149, 115, 15, 168,
117, 249, 236, 51, 163, 202, 125, 145, 14, 231, 23, 21, 109, 244,
136, 241, 212, 22, 62, 36, 157, 164, 209, 117, 183, 199, 114, 187,
83, 244, 160, 150, 144, 208, 8, 155, 115, 92, 25, 141, 138, 105,
179, 56, 207, 169, 11, 16, 97, 220, 40, 195, 125, 248, 155, 66,
112, 139, 6, 63, 85, 112, 234, 58, 143, 46, 160, 176, 225, 27,
51, 222, 96, 141, 177, 208, 174, 167, 218, 39, 19, 2, 56, 40,
117, 230, 112, 11, 222, 230, 36, 209, 105, 177, 125, 186, 219, 168,
34, 29, 178, 223, 65, 155, 221, 110, 186, 94, 160, 71, 201, 28,
85, 200, 172, 161, 86, 155, 66, 139, 219, 7, 140, 192, 230, 63,
224, 99, 198, 5, 0, 145, 161, 195, 199, 197, 133, 103, 137, 167,
173, 27, 143, 60, 216, 24, 254, 183, 31, 40, 223, 97, 116, 22,
191, 36, 77, 81, 102, 52, 25, 85, 6, 118, 83, 107, 188, 28,
139, 25, 31, 84, 223, 115, 122, 40, 244, 159, 160, 201, 149, 34,
39, 85, 17, 103, 196, 175, 176, 160, 88, 219, 188, 43, 136, 94,
33, 186, 242, 243, 77, 173, 0, 70, 234, 2, 252, 129, 133, 201,
23, 1, 214, 178, 247, 102, 28, 252, 185, 176, 243, 253, 3, 117,
13, 132, 201, 101, 112, 68, 157, 205, 141, 126, 129, 154, 119, 76,
47, 98, 252, 49, 72, 142, 83, 172, 53, 223, 20, 187, 12, 98,
108, 220, 83, 19, 67, 165, 56, 64, 254, 248, 37, 123, 70, 50,
11, 204, 214, 204, 75, 5, 201, 50, 135, 187, 224, 123, 68, 129,
202, 22, 16, 117, 52, 235, 171, 1, 19, 176, 11, 239, 30, 192,
188, 79, 165, 232, 8, 40, 162, 78, 95, 196, 4, 235, 251, 74,
112, 169, 81, 251, 118, 95, 202, 217, 17, 107, 40, 110, 25, 133,
0, 81, 79, 119, 74, 54, 75, 167, 229, 14, 222, 155, 115, 101,
206, 26, 49, 74, 0, 165, 128, 90, 125, 8, 103, 131, 214, 80,
111, 248, 39, 247, 73, 235, 166, 120, 221, 33, 64, 65, 99, 255,
239, 197, 4, 180, 8, 86, 144, 135, 246, 8, 145, 123, 151, 188,
30, 217, 67, 67, 239, 64, 130, 146, 59, 242, 193, 221, 133, 183,
249, 137, 184, 45, 19, 25, 181, 255, 196, 29, 63, 117, 139, 46,
67, 103, 48, 184, 4, 24, 27, 158, 224, 191, 88, 198, 157, 182,
143, 195, 40, 145, 157, 121, 85, 199, 23, 40, 176, 171, 204, 236,
65, 142, 67, 142, 169, 37, 156, 33, 8, 80, 127, 49, 17, 213,
242, 162, 1, 3, 215, 120, 71, 241, 171, 13, 15, 160, 166, 66,
252, 220, 244, 219, 13, 246, 14, 90, 1, 8, 66, 209, 223, 190,
9, 200, 95, 55, 245, 187, 15, 250, 228, 102, 250, 50, 137, 82,
122, 104, 199, 97, 210, 148, 170, 208, 23, 119, 133, 81, 20, 109,
83, 149, 7, 213, 81, 204, 150, 85, 228, 158, 89, 55, 197, 225,
149, 254, 29, 141, 94, 225, 151, 23, 44, 97, 67, 248, 43, 135,
44, 13, 185, 27, 135, 249, 253, 77, 56, 166, 250, 86, 14, 207,
116, 110, 234, 150, 49, 244, 245, 119, 82, 156, 77, 126, 28, 3,
217, 195, 174, 91, 41, 144, 253, 113, 199, 125, 30, 81, 64, 146,
167, 49, 120, 220, 208, 133, 33, 142, 125, 194, 32, 177, 20, 161,
229, 31, 186, 201, 91, 169, 17, 159, 156, 165, 174, 125, 69, 178,
196, 182, 51, 235, 11, 44, 54, 76, 33, 107, 228, 237, 148, 182,
87, 34, 158, 77, 58, 230, 66, 121, 191, 114, 38, 139, 192, 120,
140, 62, 160, 9, 7, 14, 113, 210, 173, 78, 186, 163, 249, 231,
56, 205, 42, 215, 236, 70, 175, 104, 24, 88, 221, 219, 133, 232,
34, 227, 132, 136, 204, 18, 141, 111, 121, 104, 39, 212, 105, 163,
90, 18, 60, 54, 221, 177, 102, 26, 111, 171, 157, 54, 78, 25,
136, 148, 83, 175, 20, 157, 238, 96, 148, 136, 163, 107, 40, 42,
219, 254, 60, 82, 81, 80, 172, 187, 217, 181, 216, 69, 74, 236,
97, 116, 228, 16, 144, 80, 75, 200, 33, 31, 44, 92, 23, 211,
112, 81, 47, 235, 226, 101, 159, 79, 2, 190, 228, 224, 124, 32,
166, 117, 20, 166, 182, 144, 170, 235, 222, 243, 110, 173, 152, 255,
60, 56, 24, 205, 72, 114, 87, 42, 33, 99, 68, 17, 190, 146,
79, 167, 75, 235, 110, 158, 101, 18, 154, 101, 126, 131, 250, 237,
177, 5, 194, 25, 162, 29, 98, 252, 84, 74, 17, 209, 43, 123,
136, 203, 100, 151, 109, 197, 224, 237, 115, 150, 38, 26, 128, 236,
122, 213, 135, 26, 171, 46, 44, 152, 213, 174, 157, 82, 73, 252,
122, 46, 87, 210, 215, 8, 197, 21, 34, 89, 247, 125, 187, 180,
0, 86, 38, 78, 253, 185, 49, 204, 179, 192, 27, 130, 7, 204,
93, 125, 146, 235, 80, 1, 146, 112, 20, 7, 247, 204, 39, 127,
121, 5, 3, 96, 94, 137, 90, 198, 197, 237, 234, 78, 52, 95,
229, 166, 225, 94, 83, 100, 53, 148, 134, 229, 228, 148, 233, 47,
126, 51, 145, 157, 2, 72, 70, 110, 183, 0, 236, 27, 190, 186,
221, 231, 215, 82, 70, 11, 239, 158, 19, 175, 59, 42, 246, 95,
92, 155, 80, 77, 153, 180, 110, 157, 4, 10, 21, 56, 73, 113,
5, 236, 214, 36, 90, 189, 229, 88, 184, 75, 197, 135, 221, 198,
254, 151, 59, 47, 48, 222, 91, 226, 144, 23, 66, 176, 250, 111,
80, 233, 38, 244, 248, 235, 243, 165, 226, 85, 131, 228, 9, 154,
42, 214, 209, 208, 155, 204, 161, 151, 9, 251, 51, 3, 28, 66,
83, 2, 245, 141, 46, 85, 69, 234, 70, 152, 245, 82, 100, 6,
218, 244, 12, 84, 216, 10, 28, 194, 61, 54, 143, 183, 160, 126,
108, 177, 61, 225, 153, 181, 204, 117, 132, 249, 161, 170, 108, 222,
247, 205, 191, 160, 190, 123, 214, 85, 227, 85, 21, 148, 166, 70,
202, 170, 38, 123, 204, 164, 245, 72, 24, 36, 220, 134, 188, 181,
61, 91, 128, 1, 20, 2, 0, 0, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 13, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 13, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 13, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 13, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 13, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 13, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
13, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
48, 48, 48, 48, 48, 48, 48, 48, 48, 13, 99, 108, 101, 97,
114, 116, 111, 109, 97, 114, 107, 13, 128, 3,
};
| [
"aashish.chaudhary@kitware.com"
] | aashish.chaudhary@kitware.com |
1e411c4dacafeb090ebbd5afde57581c782104e6 | de6de290e26e052fa38bda0acf81736cbee632c0 | /PJLaberintoPLP/PJLaberintoPLP/CObjeto.h | 33386723bdf33a5d9be56f508877785322159367 | [] | no_license | juanjoselopezp2296/Proyectos_POO_Juegos | 7014afa13221333251fd5b244cb2a4a6365ebe65 | 3d6b60e25de9c5e170164f4fef252a6e666634f7 | refs/heads/main | 2023-01-19T11:43:40.634385 | 2020-11-24T23:54:51 | 2020-11-24T23:54:51 | 312,417,731 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,028 | h | #pragma once
class CObjeto {
protected:
int x, y, dx, dy, ancho, alto, iX, iY, anchoS, altoS;
bool colision;
enum Direccion direccion;
enum Direccion direccionColision;
public:
CObjeto(int x, int y, int dx, int dy, int ancho, int alto, int iX, int iY, int anchoS, int altoS);
~CObjeto();
void Mostrar(System::Drawing::Graphics^ C, System::Drawing::Bitmap^ B);
int Get_x();
int Get_y();
int Get_dx();
int Get_dy();
int Get_ancho();
int Get_alto();
int Get_iX();
int Get_iY();
int Get_anchoS();
int Get_altoS();
bool Get_colision();
void Set_x(int x);
void Set_y(int y);
void Set_dx(int dx);
void Set_dy(int dy);
void Set_ancho(int ancho);
void Set_alto(int alto);
void Set_iX(int iX);
void Set_iY(int iY);
void Set_anchoS(int anchoS);
void Set_altoS(int altoS);
void Set_colision(bool colision);
Direccion Get_direccion();
void Set_direccion(Direccion direccion);
Direccion Get_direccionColision();
void Set_direccionColision(Direccion direccionColision);
}; | [
"48421315+juanjoselopezp2296@users.noreply.github.com"
] | 48421315+juanjoselopezp2296@users.noreply.github.com |
8c014968d6c60babad4ccd3499198a2fd739306f | 9e04d3d47f0a8b80b23d96f0f4f82cd7c3e06408 | /source/strategy_host/ctp_preinsert.h | 49292bfe138bf1c16b2a282220f7f33323377398 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | BrentJiang/qtsf | 648f4c4d4d60718d6f596e86d8a5a5cf4c685443 | 8c1139800052fa3e50863915e76ebcfb6ab5c78c | refs/heads/master | 2020-07-23T20:43:57.436116 | 2019-09-19T10:24:09 | 2019-09-19T10:24:09 | 207,701,192 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,049 | h | #pragma once
#include <cstdint>
#include <unordered_map>
#include <mutex>
#include <memory>
#include "log4z.h"
using namespace zsummer::log4z;
#include "common/common/logger.h"
#include "server/options_impl.h"
namespace Envoy {
namespace StrategyHost {
struct FutureOrder
{
uint32_t order_id;
uint64_t trigger_time;
};
using FutureOrderSharedPtr = std::shared_ptr<FutureOrder>;
class CtpPreInsertTrader : public Logger::Loggable<Logger::Id::config>
{
public:
CtpPreInsertTrader(int argc, const char* const* argv);
void monitorScheduledOrder();
void switchFlagRunning();
FutureOrderSharedPtr getScheduledOrder(uint32_t scheduled_order_id);
void insertOrder(FutureOrderSharedPtr order);
static std::string hotRestartVersion(bool hot_restart_enabled);
private:
Envoy::OptionsImpl options_;
Event::RealTimeSystem real_time_system_;
std::unordered_map<uint32_t, FutureOrderSharedPtr> test_map_;
std::mutex mtx_orderbook_;
bool flag_running_;
};
} // namespace StrategyHost
} // namespace Envoy | [
"sanyi0127@sina.com"
] | sanyi0127@sina.com |
caea400a04343a11d6ba39145e913128515c49db | bd95a1d0c8ecf659f6ab692b7076c4eeefd692ae | /contest/olympiad/USACO/11DEC_G3.cpp | c8d9d17f1a5c5b5fbe7b1725dff85fbbcf7a98e2 | [] | no_license | jjwdi0/PS-Library | d6623f2b7d00f90640ff38abbdb654ec8223eefd | 3ca6bb3f8336cca8b2e5f3243332beebba869d44 | refs/heads/master | 2023-02-09T03:27:34.877953 | 2020-12-27T03:17:32 | 2020-12-27T03:17:32 | 316,480,494 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,409 | cpp | #include <bits/stdc++.h>
#define MAX_N 100005
#define MAX_LN 18
using namespace std;
using pr = pair<int, int>;
using ll = long long;
struct Z { ll v, lz; };
struct segtree {
Z tree[MAX_N*8];
int base;
void init(int x) { for(base=1; base<x; base<<=1); }
void update(int x, ll y, bool arr = 0) {
if(!arr) x += base - 1;
while(x) tree[x].v += y, x >>= 1;
}
int f(int x) {
int res = 1;
while(base > x) x <<= 1, res <<= 1;
return res;
}
void g(int x) {
if(x == 0) return;
g(x / 2);
tree[x*2].lz += tree[x].lz, tree[x*2+1].lz += tree[x].lz;
tree[x].v += tree[x].lz * f(x);
tree[x].lz = 0;
}
ll RMQ(int x, int y) {
ll res = 0LL;
x += base - 1, y += base - 1;
while(x < y) {
if(x & 1) g(x), res += tree[x].v, x++;
if(!(y & 1)) g(y), res += tree[y].v, y--;
x >>= 1, y >>= 1;
}
if(x == y) g(y), res += tree[y].v;
return res;
}
void modify(int x, int y, ll v) {
x += base - 1, y += base - 1;
while(x < y) {
if(x & 1) tree[x].lz += v, update(x / 2, v * f(x), 1), x++;
if(!(y & 1)) tree[y].lz += v, update(y / 2, v * f(y), 1), y--;
x >>= 1, y >>= 1;
}
if(x == y) tree[x].lz += v, update(y / 2, v * f(y), 1);
}
} seg;
int N, Q, sz[MAX_N], lev[MAX_N], st[MAX_N][MAX_LN];
int U[MAX_N], V[MAX_N], W[MAX_N], cost[MAX_N];
int dfn[MAX_N], HLD, head[MAX_N], DFS, G[MAX_N];
vector<pr> v[MAX_N];
void dfs(int x, int p) {
lev[x] = lev[p] + 1;
sz[x] = 1;
st[x][0] = p;
for(auto it : v[x]) if(it.first != p) dfs(it.first, x), cost[it.first] = it.second;
}
void hld(int x, int p) {
sort(v[x].begin(), v[x].end(), [](const pr &X, const pr &Y) { return sz[X.first] > sz[Y.first]; });
int cnt = 0;
for(auto it : v[x]) if(it.first != p) {
int u = it.first;
G[u] = (HLD += !!cnt);
dfn[u] = ++DFS;
if(cnt++) head[HLD] = u;
hld(u, x);
}
}
int LCA(int s, int e) {
if(lev[s] > lev[e]) swap(s, e);
for(int i=0; i<MAX_LN; i++) if((lev[e] - lev[s]) & (1 << i)) e = st[e][i];
if(s == e) return s;
for(int i=MAX_LN-1; ~i; i--) if(st[s][i] != st[e][i]) s = st[s][i], e = st[e][i];
return st[s][0];
}
void edit(int x, int y) {
if(x == y) return;
while(G[x] != G[y]) {
int h = head[G[x]];
seg.modify(dfn[h], dfn[x], 1LL);
x = st[h][0];
}
seg.modify(dfn[y] + 1, dfn[x], 1LL);
}
ll query(int x, int y) {
if(x == y) return 0LL;
ll res = 0LL;
while(G[x] != G[y]) {
int h = head[G[x]];
res += seg.RMQ(dfn[h], dfn[x]);
x = st[h][0];
}
res += seg.RMQ(dfn[y] + 1, dfn[x]);
return res;
}
int main() {
scanf("%d %d", &N, &Q);
seg.init(N);
for(int i=1; i<N; i++) {
scanf("%d %d", U+i, V+i);
v[U[i]].push_back(pr(V[i], W[i]));
v[V[i]].push_back(pr(U[i], W[i]));
}
dfs(1, 0);
for(int i=1; i<MAX_LN; i++) for(int j=1; j<=N; j++) st[j][i] = st[st[j][i-1]][i-1];
dfn[1] = head[1] = G[1] = HLD = DFS = 1;
hld(1, 0);
while(Q--) {
int x, y;
char q;
scanf(" %c %d %d", &q, &x, &y);
int lca = LCA(x, y);
if(q == 'P') edit(x, lca), edit(y, lca);
else printf("%lld\n", query(x, lca) + query(y, lca));
}
}
| [
"jjwdi0@naver.com"
] | jjwdi0@naver.com |
f128ca7ee4eab1df4582f772c0a49da1cd37b6bf | ce6a17ec7dd2defbda7ede8954c7f3152427e091 | /LargeFile.h | b29f442d65f0a475936fadf5dcb711d4b256dc35 | [] | no_license | BlueBrain/TuvokBasics | 8052b80139375fc519853e308a822e67a8a5dec8 | 2bce925dc99412050ead9ae7289b38d354001820 | refs/heads/master | 2020-12-24T17:35:30.062419 | 2014-09-25T13:31:08 | 2014-09-25T13:31:08 | 11,734,414 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,410 | h | /*
For more information, please see: http://software.sci.utah.edu
The MIT License
Copyright (c) 2011 Scientific Computing and Imaging Institute,
University of Utah.
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 BASICS_LARGEFILE_H
#define BASICS_LARGEFILE_H
#ifndef _LARGEFILE64_SOURCE
# define _LARGEFILE64_SOURCE 1
#endif
#include <cstdint>
#include <iostream>
#include <memory>
#include <string>
#include "nonstd.h"
/** Generic class for accessing large quantities of binary data. */
class LargeFile {
public:
/// @argument header_size is maintained as a "base" offset. Seeking to
/// byte 0 actually seeks to 'header_size'.
/// @argument length some implementations are better if you can guarantee
/// up front how much data you'll access.
LargeFile(const std::string fn,
std::ios_base::openmode mode = std::ios_base::in,
uint64_t header_size=0,
uint64_t length=0);
/// @argument header_size is maintained as a "base" offset. Seeking to
/// byte 0 actually seeks to 'header_size'.
/// @argument length some implementations are better if you can guarantee
/// up front how much data you'll access.
LargeFile(const std::wstring fn,
std::ios_base::openmode mode = std::ios_base::in,
uint64_t header_size=0,
uint64_t length=0);
virtual ~LargeFile() {}
/// The file is automatically opened upon construction, but you can use
/// this to reopen in a different mode, for example.
/// LargeFiles are always 'raw': std::ios::binary is implied.
virtual void open(std::ios_base::openmode mode = std::ios_base::in) = 0;
/// Uses the current byte offset to read data from the file.
virtual std::shared_ptr<const void> rd(size_t len);
/// reads a block of data, returns a pointer to it. User must cast it to
/// the type that makes sense for them.
/// The file's current byte offset is undefined after this operation.
virtual std::shared_ptr<const void> rd(uint64_t offset,
size_t len) = 0;
/// returns the number of bytes read during the last read.
virtual uint64_t gcount() const;
/// writes a block of data.
/// The file's current byte offset is undefined after this operation.
virtual void wr(const std::shared_ptr<const void>& data, uint64_t offset,
size_t len) = 0;
/// writes data at the current byte offset
virtual void wr(const std::shared_ptr<const void>& data,
size_t len);
/// read/write calls of a single element. Only usable with implicit
/// offsets.
///@{
// a 'delete' functor that just does nothing.
template<typename T> void read(T* v, size_t N=1) {
std::shared_ptr<const void> m = this->rd(this->byte_offset,
sizeof(T)*N);
const T* mem = static_cast<const T*>(m.get());
std::copy(mem, mem+N, v);
this->byte_offset += sizeof(T)*N;
}
template<typename T> void write(const T& v) {
this->wr(std::shared_ptr<const void>(&v, nonstd::null_deleter()),
this->byte_offset, sizeof(T));
this->byte_offset += sizeof(T);
}
template<typename T> void write(const T* v, size_t N=1) {
this->wr(std::shared_ptr<const void>(v, nonstd::null_deleter()),
sizeof(T)*N);
// don't increase byte_offset -- this version of wr() does it for us!
}
///@}
/// notifies the object that we're going to need the following data soon.
/// Many implementations will prefetch this data when it knows this.
virtual void enqueue(uint64_t offset, size_t len) = 0;
std::string filename() const { return this->m_filename; }
virtual uint64_t filesize() const = 0;
virtual void seek(uint64_t);
virtual uint64_t offset() const;
virtual bool is_open() const = 0;
virtual void close() = 0;
virtual void truncate(uint64_t length=0);
static void truncate(const char* path, uint64_t length);
protected:
std::string m_filename;
uint64_t header_size;
uint64_t byte_offset;
uint64_t bytes_read; // number of bytes read during last read
private:
LargeFile(const LargeFile&);
LargeFile& operator=(const LargeFile&);
};
#endif /* BASICS_LARGEFILE_H */
| [
"tfogal@5b8196f7-c1c0-4be6-8b13-4feed349168d"
] | tfogal@5b8196f7-c1c0-4be6-8b13-4feed349168d |
ec43134dcf8eaa6ec27d2967cc46a04bce6fce6e | 9a3e81788b83f2a91ddc1cd7d22bf47afbcfc642 | /CharAR/Temp/il2cppOutput/il2cppOutput/mscorlib_System_Collections_Generic_KeyValuePair_21189512043.h | 9f6a28a13263e7fc526af14a442ff5584fae3d08 | [] | no_license | EasonTianyiZhang/CatchMeIfYouCan | 519cffd319201f947aeb535cd6f52ad244170a4e | fd2603bb06a5857b6ab20aade73c25590a38a6ae | refs/heads/master | 2021-01-18T19:48:26.536899 | 2016-09-26T23:34:20 | 2016-09-26T23:34:20 | 69,297,181 | 1 | 3 | null | 2016-09-26T23:32:20 | 2016-09-26T22:13:16 | null | UTF-8 | C++ | false | false | 1,576 | h | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
// Vuforia.PropAbstractBehaviour
struct PropAbstractBehaviour_t1293468098;
#include "mscorlib_System_ValueType1744280289.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Collections.Generic.KeyValuePair`2<System.Int32,Vuforia.PropAbstractBehaviour>
struct KeyValuePair_2_t1189512043
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
PropAbstractBehaviour_t1293468098 * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t1189512043, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t1189512043, ___value_1)); }
inline PropAbstractBehaviour_t1293468098 * get_value_1() const { return ___value_1; }
inline PropAbstractBehaviour_t1293468098 ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(PropAbstractBehaviour_t1293468098 * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier(&___value_1, value);
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"gxy26904@gmail.com"
] | gxy26904@gmail.com |
76750542b98a284d5af57757da9c28edc87e4efd | a33aac97878b2cb15677be26e308cbc46e2862d2 | /program_data/PKU_raw/80/907.c | c3eed7dcc9459670d9b582fa57ca17a82bda330e | [] | no_license | GabeOchieng/ggnn.tensorflow | f5d7d0bca52258336fc12c9de6ae38223f28f786 | 7c62c0e8427bea6c8bec2cebf157b6f1ea70a213 | refs/heads/master | 2022-05-30T11:17:42.278048 | 2020-05-02T11:33:31 | 2020-05-02T11:33:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,276 | c | int main()
{
int year[2],month[2],day[2],i,s=0,j;
scanf("%d %d %d",&year[0],&month[0],&day[0]);
scanf("%d %d %d",&year[1],&month[1],&day[1]);
if(year[1]-year[0]!=0)
{for(i=year[0];i<=year[1];i++)
{
if(i==year[0])
{
for(j=month[0];j<=12;j++)
{
if(j==1||j==3||j==5||j==7||j==8||j==10||j==12)
{
s=s+31;
}
else if(j==2)
{
if((i%4==0&i%100!=0)||i%400==0)
s=s+29;
else
s=s+28;
}
else
{
s=s+30;
}
}
}
if(i>year[0]&&i<year[1])
{
if((i%4==0&i%100!=0)||i%400==0)
s=s+366;
else
s=s+365;
}
if(i==year[1])
{
for(j=1;j<month[1];j++)
{
if(j==1||j==3||j==5||j==7||j==8||j==10||j==12)
{
s=s+31;
}
else if(j==2)
{
if((i%4==0&i%100!=0)||i%400==0)
s=s+29;
else
s=s+28;
}
else
{
s=s+30;
}
}
}
}
}
else
{
for(j=month[0];j<month[1];j++)
{
if(j==1||j==3||j==5||j==7||j==8||j==10||j==12)
{
s=s+31;
}
else if(j==2)
{
if((year[0]%4==0&i%100!=0)||year[0]%400==0)
s=s+29;
else
s=s+28;
}
else
{
s=s+30;
}
}
}
s=s-day[0]+day[1];
printf("%d",s);
return 0;
} | [
"bdqnghi@gmail.com"
] | bdqnghi@gmail.com |
5895f11e7488efff7557919f89a774371bf68ec3 | 844a9129433604be87a4dea5438176bb9eeadef9 | /Codeforces/1095-B-ArrayStabilization.cpp | e274b486b8211403823e0b1728169ab6b24f179b | [] | no_license | AIT-RAMI/Competitive-Programming | 135d9ed88113c949f2436e1e6f2eab1bc6282f81 | b1206c5175904c03f36ee62e00099d5613aa3644 | refs/heads/master | 2022-12-30T19:19:49.945784 | 2020-10-20T11:07:49 | 2020-10-20T11:07:49 | 176,545,114 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 836 | cpp | #include <bits/stdc++.h>
#include <algorithm>
#include <string.h>
#include <math.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const ll mod = 1000000007;
#define pf(n) cout << n << endl
#define pfs(n) cout << n
#define ps() cout <<" "
#define sf(n) cin >> n
#define in(i,n) for (int i = 0; i < n; i++)
#define ni(i,n) for (int i = n - 1; i >= 0; i--)
#define vi vector<int>
#define vp vector<pair<int, int>>
#define graph vector< vector<int> >
#define vs vector<string>
const int MAXN = 100005;
/** '' "Lionel VB" ^ **/
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
ll N;
sf(N);
ll arr[N];
for(int i = 0; i < N; i++){
sf(arr[i]);
}
sort(arr, arr + N);
pf(min(arr[N-1]-arr[1], arr[N-2] - arr[0]));
return 0;
} | [
"mohamedaitrami@gmail.com"
] | mohamedaitrami@gmail.com |
c1c8a68270ecc34f917106fff685129cd0eae353 | 505b4525174f8d3ea73b4d3b2c7c011cd63d1216 | /Algorithms/programmers_17679.cpp | 204eb4be12a10f124f9c44da4c991662b0e146f0 | [] | no_license | JangHyeonJun/AlgorithmStudy | 4c0532972e614f8498d941336e3e3ed6864bff27 | 5e5508d084d48b8074af39d98a1f4073c0ea0876 | refs/heads/master | 2023-08-28T21:24:31.715861 | 2023-08-06T11:17:27 | 2023-08-06T11:17:27 | 154,111,534 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,753 | cpp | //#include <string>
//#include <vector>
//
//using namespace std;
//
//typedef pair<int, int> II;
//
//void move_block(int m, int n, vector<string>& board)
//{
// for (int i=0; i<n; i++)
// {
// int row = m - 1;
// while (row >= 0)
// {
// if (board[row][i] == '_')
// {
// for (int j = row - 1; j >= 0; j--)
// board[j + 1][i] = board[j][i];
// board[0][i] = '*';
// }
// else
// row--;
// }
// }
//}
//
//int destroy_block(const vector<II>& pos, vector<string>& board)
//{
// int destroy_count = 0;
// for (int i = 0; i < pos.size(); i++)
// {
// int row = pos[i].first;
// int col = pos[i].second;
//
// for(int j=0; j<2; j++)
// for (int k = 0; k < 2; k++)
// if (board[row - j][col + k] != '_')
// {
// board[row - j][col + k] = '_';
// destroy_count++;
// }
// }
//
// return destroy_count;
//}
//
//vector<II> find_4by4_Block(int m, int n, vector<string>& board)
//{
// vector<II> pos;
// for (int i = m - 1; i > 0; i--)
// {
// for (int j = 0; j < n - 1; j++)
// {
// char c = board[i][j];
// if (c != '*' && board[i][j + 1] == c
// && board[i - 1][j] == c && board[i - 1][j + 1] == c)
// {
// pos.push_back(make_pair(i, j));
// }
// }
// }
// return pos;
//}
//
//int solution(int m, int n, vector<string> board) {
// int answer = 0;
// int curr_destroy_num = 0;
// do
// {
// vector<II> pos = find_4by4_Block(m, n, board);
// answer += curr_destroy_num = destroy_block(pos, board);
// move_block(m, n, board);
// } while (curr_destroy_num > 0);
// return answer;
//}
//
//int main()
//{
// vector<string> board = { "CCBDE", "AAADE", "AAABF", "CCBBF" };
// vector<string> board2 = { "TTTANT", "RRFACC", "RRRFCC",
// "TRRAA", "TTMMMF", "TMMTTJ" };
// solution(6, 6, board2);
//} | [
"totok682@naver.com"
] | totok682@naver.com |
625a2b7bfc4d4d5c8ef3ddd596bd86bcccf5308b | 94a748b9ec43c531dcce671cbb23801c8260c08d | /testprograms/FoxProgression.cpp | bbd8e168323235b528527245067daaf89f83e885 | [] | no_license | Shubham28/TopCoder | 091948352bcfe2088cdce9a1d82ddec2cf38cfe9 | 25b6d34c391b8b79094bd0d971d86c2af943f4d3 | refs/heads/master | 2021-01-19T09:44:00.576213 | 2013-05-23T12:54:30 | 2013-05-23T12:54:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,282 | cpp | #include <vector>
#include <map>
#include <queue>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <cmath>
#include <cstdlib>
#include <set>
#include <numeric>
#define FOR(A,B,C) for(int A=B;A<C;A++)
#define EFOR(A,B,C) for(int A=B;A<=C;A++)
#define RFOR(A,B,C) for(int A=B;A>=C;A--)
#define PB(A,B) A.push_back(B);
#define SORT(A) sort( A.begin(),A.end() )
#define ALL(A) A.begin(),A.end()
#define MEM(A,B) memset(A,B,sizeof(A))
#define VI vector<int>
#define VS vector<string>
#define VD vector<double>
#define VB vector<bool>
#define SZ(A) int(A.size())
#define LL long long
using namespace std;
class FoxProgression {
public:
int theCount(vector <int>);
};
int FoxProgression::theCount(vector <int> seq) {
int N=SZ(seq);
if(N==1) return -1;
int dif=seq[1]-seq[0];
bool ap=1;
FOR(pr,1,N)
if(seq[pr]-seq[pr-1]!=dif)
ap=0;
int nAP=seq[N-1]+dif;
bool gp=1;
if(seq[1]%seq[0]!=0)
gp=0;
int ratio=seq[1]/seq[0];
FOR(pr,1,N)
if(seq[pr]/(double)seq[pr-1]!=(double)ratio)
gp=0;
int nGP=seq[N-1]*ratio;
if(ap && gp)
return (nAP==nGP)?1:2;
if(ap || gp)
return 1;
return 0;
}
// BEGIN KAWIGIEDIT TESTING
// Generated by KawigiEdit 2.1.8 (beta) modified by pivanof
#include <iostream>
#include <string>
#include <vector>
using namespace std;
bool KawigiEdit_RunTest(int testNum, vector <int> p0, bool hasAnswer, int p1) {
cout << "Test " << testNum << ": [" << "{";
for (int i = 0; int(p0.size()) > i; ++i) {
if (i > 0) {
cout << ",";
}
cout << p0[i];
}
cout << "}";
cout << "]" << endl;
FoxProgression *obj;
int answer;
obj = new FoxProgression();
clock_t startTime = clock();
answer = obj->theCount(p0);
clock_t endTime = clock();
delete obj;
bool res;
res = true;
cout << "Time: " << double(endTime - startTime) / CLOCKS_PER_SEC << " seconds" << endl;
if (hasAnswer) {
cout << "Desired answer:" << endl;
cout << "\t" << p1 << endl;
}
cout << "Your answer:" << endl;
cout << "\t" << answer << endl;
if (hasAnswer) {
res = answer == p1;
}
if (!res) {
cout << "DOESN'T MATCH!!!!" << endl;
} else if (double(endTime - startTime) / CLOCKS_PER_SEC >= 2) {
cout << "FAIL the timeout" << endl;
res = false;
} else if (hasAnswer) {
cout << "Match :-)" << endl;
} else {
cout << "OK, but is it right?" << endl;
}
cout << "" << endl;
return res;
}
int main() {
bool all_right;
all_right = true;
vector <int> p0;
int p1;
{
// ----- test 0 -----
int t0[] = {1,2,4,8};
p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
p1 = 1;
all_right = KawigiEdit_RunTest(0, p0, true, p1) && all_right;
// ------------------
}
{
// ----- test 1 -----
int t0[] = {5,3,1};
p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
p1 = 1;
all_right = KawigiEdit_RunTest(1, p0, true, p1) && all_right;
// ------------------
}
{
// ----- test 2 -----
int t0[] = {1,1};
p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
p1 = 1;
all_right = KawigiEdit_RunTest(2, p0, true, p1) && all_right;
// ------------------
}
{
// ----- test 3 -----
int t0[] = {8,4};
p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
p1 = 1;
all_right = KawigiEdit_RunTest(3, p0, true, p1) && all_right;
// ------------------
}
{
// ----- test 4 -----
int t0[] = {1};
p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
p1 = -1;
all_right = KawigiEdit_RunTest(4, p0, true, p1) && all_right;
// ------------------
}
{
// ----- test 5 -----
int t0[] = {4,8};
p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
p1 = 2;
all_right = KawigiEdit_RunTest(5, p0, true, p1) && all_right;
// ------------------
}
{
// ----- test 6 -----
int t0[] = {1,3,4};
p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
p1 = 0;
all_right = KawigiEdit_RunTest(6, p0, true, p1) && all_right;
// ------------------
}
{
// ----- test 7 -----
int t0[] = {2,4,8,17};
p0.assign(t0, t0 + sizeof(t0) / sizeof(t0[0]));
p1 = 0;
all_right = KawigiEdit_RunTest(7, p0, true, p1) && all_right;
// ------------------
}
if (all_right) {
cout << "You're a stud (at least on the example cases)!" << endl;
} else {
cout << "Some of the test cases had errors." << endl;
}
return 0;
}
// END KAWIGIEDIT TESTING
// Author: Shubham Gupta
//Powered by KawigiEdit 2.1.8 (beta) modified by pivanof!
| [
"shubham.gup@directi.com"
] | shubham.gup@directi.com |
72f6e9397c4adf0e5756c99bb9f1e48a75a73db1 | 16cddcd8db3d1eed6e2f26b9b440173e90c18842 | /utilityFunctions.h | 3ad6b5983d3097cc31f3a33b3ea1fb0cc8a033cb | [] | no_license | KKMahogany/Asteroids | 83e4fdab615f949047cdd4cdc2d4e8ce6538177b | 2f16a9cdb15497a4731263067c7509dbf0e9a06c | refs/heads/master | 2016-09-06T17:50:08.813644 | 2015-05-06T01:15:15 | 2015-05-06T01:15:15 | 35,132,244 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,455 | h | //
// utilityFunctions.h
// Asteroids
//
// Created by Kevin Tran on 31/05/14.
// Copyright (c) 2014 Kevin Tran. All rights reserved.
//
#ifndef __Asteroids_utilityFunctions_h
#define __Asteroids_utilityFunctions_h
#include "constants.h"
#include "weapon.h"
inline double getRandomDir (int fineness = STANDARD_ANGLE_FINENESS) {
assert(fineness > 0);
return (2.0f*PI)*(static_cast<double>(rand()%1000)/static_cast<double>(fineness));
}
inline double getExplosionParticleLifeSpan (int size) {
return EXPLOSION_PARTICLE_LIFESPAN + (size-1)*0.5f;
}
inline double getExplosionParticleSpeed (int size) {
return EXPLOSION_PARTICLE_SPEED + (size-1)*20;
}
inline Weapon getWeapon (weaponType weapon) {
std::vector<Bullet> bulletList;
std::vector<double> offsetList;
double fireRate;
switch (weapon) {
case SPREAD_SHOT:
fireRate = FIRE_RATE*3;
for(int i = 0; i < 3; i++) {
bulletList.push_back(Bullet(0,
0,
PROJECTILE_RADIUS,
PROJECTILE_SPEED,
PROJECTILE_SPEED,
PROJECTILE_COLOR));
}
offsetList.push_back(-PI/8.0f);
offsetList.push_back(0.0f);
offsetList.push_back(PI/8.0f);
break;
case CHAIN_GUN:
fireRate = FIRE_RATE;
bulletList.push_back(Bullet(0,
0,
PROJECTILE_RADIUS,
PROJECTILE_SPEED,
PROJECTILE_SPEED,
PROJECTILE_COLOR));
offsetList.push_back(0);
break;
case MINE_LAYER:
fireRate = FIRE_RATE*2;
bulletList.push_back(Bullet(0,
0,
PROJECTILE_RADIUS*4,
0,
0,
PROJECTILE_COLOR));
offsetList.push_back(0);
break;
case SPLINTER_GUN:
for(int i = 0; i < 12; i++) {
bulletList.push_back(Bullet(0,
0,
PROJECTILE_RADIUS,
PROJECTILE_SPEED,
PROJECTILE_SPEED,
PROJECTILE_COLOR));
offsetList.push_back(static_cast<double>(i)*(2.0f*PI/12.0f));
}
fireRate = FIRE_RATE*8;
break;
case CANNON:
for(int i = 0; i < 5; i++) {
bulletList.push_back(Bullet(0,
0,
PROJECTILE_RADIUS*6,
PROJECTILE_SPEED*0.5f,
PROJECTILE_SPEED*0.5f,
PROJECTILE_COLOR));
offsetList.push_back(0.0f);
}
fireRate = FIRE_RATE*7;
break;
}
return Weapon(bulletList, offsetList, fireRate);
}
#endif
| [
"kevinohappyface@gmail.com"
] | kevinohappyface@gmail.com |
bf6cb514dfc51acbcf564859ca9f04f8b9b0f8f6 | 778619ffffeb527ab7e43d628a942998414b22bd | /lw/io/stream/buffer.cpp | 09eae1e3967b677f308e24d51a432c9b4e928e62 | [
"MIT"
] | permissive | LifeWanted/liblw | eabcbc18aa808f55e644e22310ef28474b098afd | 6b96e3dd67b72243d39ad83b7754d0b7dbb2b18a | refs/heads/master | 2022-09-15T11:20:17.362484 | 2022-02-26T19:34:27 | 2022-02-26T19:34:27 | 31,483,187 | 39 | 8 | MIT | 2021-08-21T02:36:07 | 2015-03-01T01:32:58 | C++ | UTF-8 | C++ | false | false | 1,855 | cpp | #include "lw/io/stream/buffer.h"
#include <algorithm>
#include <cstring>
#include <streambuf>
#include <string>
namespace lw::io::stream {
StringBuffer::StringBuffer() {
setg(data(), data(), data());
setp(data(), data() + capacity());
}
StringBuffer::StringBuffer(const std::string& str): _buffer{str} {
setg(data(), data(), data());
setp(data(), data() + capacity());
}
StringBuffer::StringBuffer(StringBuffer&& other):
_buffer{std::move(other._buffer)}
{
setg(other.eback(), other.gptr(), other.egptr());
setp(other.pptr(), other.epptr());
}
StringBuffer& StringBuffer::operator=(StringBuffer&& other) {
_buffer = std::move(other._buffer);
setg(other.eback(), other.gptr(), other.egptr());
setp(other.pptr(), other.epptr());
return *this;
}
void StringBuffer::reserve(std::size_t new_capacity) {
const char_type* old_start = data();
_buffer.reserve(new_capacity);
setg(
data(), // eback
data() + (gptr() - old_start), // gptr
data() + size() - 1 // egptr
);
setp(
data() + size(), // pbase, pptr
data() + capacity() // epptr
);
}
std::streamsize StringBuffer::xsgetn(char_type* out, std::streamsize count) {
std::streamsize copied = std::min(count, _get_size());
std::memcpy(out, _buffer.data(), copied);
setg(
data(), // eback
gptr() + copied, // gptr
data() + size() - 1 // egptr
);
return copied;
}
std::streamsize StringBuffer::xsputn(
const char_type* in,
std::streamsize count
) {
if (count + size() > capacity()) {
reserve((count + size()) * 2);
}
_buffer.append(in, count);
setg(
data(), // eback
gptr(), // gptr
data() + size() - 1 // egptr
);
setp(
data() + size(), // pbase, pptr
data() + capacity() // epptr
);
return count;
}
}
| [
"natalie@lifewanted.com"
] | natalie@lifewanted.com |
8b7c95ec744b9a5c4fc2876ed52761477aa9ffbf | 9f1d95c9e401270a36a1d785d8c4cb5d267bc1fc | /hideconsole/hideconsole.cpp | db91dd054be3d40e46aba615499d30216966a189 | [] | no_license | srw/hide-console | 4c9ff53c6ae40a110054472be60e4a8982551dfe | 14f442a997ca099b930d291a7f54cc00125c03cb | refs/heads/master | 2021-01-10T21:33:16.912718 | 2012-01-03T19:28:27 | 2012-01-03T19:28:27 | 3,096,576 | 3 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 909 | cpp | // hideconsole.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include "windows.h"
#include <string>
#include <iostream>
#include <stdio.h>
namespace std
{
#ifdef _UNICODE
typedef wstring tstring;
#define tout std::wcout
#else
typedef string tstring;
#define tout std::cout
#endif
}
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
if(argc == 1) {
//wprintf(_T("Usage: %s <cmd> [<parameter1>..<parametern>]"));
tout << "Usage: " << argv[0] << " <cmd> [<parameter1>..<parametern>]" << endl;
return 0;
}
tstring file = argv[1];
tstring parameters;
for(int i=2; i < argc; i++) {
if( i != 2)
parameters.append(_T(" "));
parameters.append(argv[i]);
}
ShellExecute(NULL, _T("open"), file.c_str(), parameters.c_str(), NULL, SW_HIDE);
tout << "Running cmd = " << file << endl;
tout << "Arguments = " << parameters << endl;
return 0;
}
| [
"sebastian.wain@nektra.com"
] | sebastian.wain@nektra.com |
18cba141d94ce26896ec42c51dc802c37b08b90a | 44147b92cfc409164288fda1a5d36a2715838fa7 | /XSmilAgent/SGNode.cpp | bbec72c784e22e1a992e2494ce97424ce308a8d2 | [] | no_license | bestdpf/xface-new | 43d6c85fdf5fc4e44629dd24ef5232142c2f28b7 | 6870fea0cf49c7e185fbee31cff1b04e49b33dd6 | refs/heads/master | 2021-01-22T04:36:43.050943 | 2014-05-25T06:44:31 | 2014-05-25T06:44:31 | 20,047,812 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 961 | cpp | /* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (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.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is XSmilAgent
*
* The Initial Developer of the Original Code is
* ITC-irst, TCC Division (http://tcc.fbk.eu) Trento / ITALY.
* Portions created by the Initial Developer are Copyright (C) 2004 - 2008
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* - Koray Balci (koraybalci@gmail.com)
* ***** END LICENSE BLOCK ***** */
#include "SGNode.h"
| [
"duan@gst169076.ip.sz.tsinghua.edu.cn"
] | duan@gst169076.ip.sz.tsinghua.edu.cn |
18bc8ce96ebfbcf0e6791260063d23447107c52e | 082fa6b3970bc27d7e349dcc56e209f33a997442 | /code/common/LibHNLobby/HNLobby/v88/GameLandCompositeV88.cpp | c9b96ce50e2bfec122eabaa70a1b1cbf6e6e4731 | [] | no_license | Crasader/C-_Project | e0627276e9305b661c82706f635cf0bdfa009897 | 106d2c8fd9561730a59d36af12f11677e54f8772 | refs/heads/master | 2021-10-27T05:48:05.937651 | 2019-04-16T07:30:35 | 2019-04-16T07:30:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,911 | cpp | #include "GameLandCompositeV88.h"
#include "PlatformResV88.h"
#include "HNLobby//GameExitLayer.h"
#include "HNLobby/PlatformDefine.h"
#include "HNLobby/PlatformConfig.h"
#include "HNLobby/GamePrompt.h"
#include "VersionInfo/VersionInfo.h"
#include "Sound/HNAudioEngine.h"
#include "base/WeChatAndroid.h"
#if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
#include "base/WechatMgr.h"
#endif
static const char* LOGIN_NODE_CSB = "csb/v88/loginUI/loginNode_v88.csb";
GameLandCopositeV88::GameLandCopositeV88()
//:
//onLoginCallBack(nullptr)
//, onRegistCallBack(nullptr)
//, onFindPwCallBack(nullptr)
{
memset(&_login_node, 0x0, sizeof(_login_node));
}
GameLandCopositeV88::~GameLandCopositeV88() {
}
void GameLandCopositeV88::onExitTransitionDidStart() {
HNLayer::onExitTransitionDidStart();
// HNAudioEngine::getInstance()->stopBackgroundMusic();
}
void GameLandCopositeV88::onEnter() {
HNLayer::onEnter();
// if (VERSION_EIGHTY_EIGHT) {
// if (HNAudioEngine::getInstance()->hasBackgroundMusic()) {
// HNAudioEngine::getInstance()->stopBackgroundMusic();
// }
// HNAudioEngine::getInstance()->playBackgroundMusic(LAND_BACKGROUND_MUSIC_V88, true);
// }
// else {
// HNAudioEngine::getInstance()->playBackgroundMusic(LAND_BACKGROUND_MUSIC_V88, true);
// }
}
bool GameLandCopositeV88::init() {
if (!HNLayer::init()) {
return false;
}
Size winSize = Director::getInstance()->getWinSize();
// 登录界面ui
_login_node.node = CSLoader::createNode(LOGIN_NODE_CSB);
// _login_node.node->setPositionY(-50);
addChild(_login_node.node);
auto userDefault = UserDefault::getInstance();
std::string username = userDefault->getStringForKey(USERNAME_TEXT);
std::string password = userDefault->getStringForKey(PASSWORD_TEXT);
bool save = userDefault->getBoolForKey(SAVE_TEXT);
//账号输入
auto accountText = (TextField*)_login_node.node->getChildByName("TextField_account");
accountText->setPlaceHolderColor(FONT_COLOR_ORANGE_V88);
accountText->setVisible(false);
_login_node.accountEdit = HNEditBox::createEditBox(accountText, this);
_login_node.accountEdit->setString(username);
// 保存密码复选框
_login_node.keepPwCheckBox = (CheckBox*)_login_node.node->getChildByName("CheckBox_keepPassword");
_login_node.keepPwCheckBox->setSelected(save);
_login_node.keepPwCheckBox->addEventListener(CheckBox::ccCheckBoxCallback(CC_CALLBACK_2(GameLandCopositeV88::checkBoxCallback, this)));
//密码输入
auto passwordText = (TextField*)_login_node.node->getChildByName("TextField_password");
passwordText->setPlaceHolderColor(FONT_COLOR_ORANGE_V88);
passwordText->setVisible(false);
_login_node.passwordEdit = HNEditBox::createEditBox(passwordText, this);
_login_node.passwordEdit->setInputFlag(cocos2d::ui::EditBox::InputFlag::PASSWORD);
if (_login_node.keepPwCheckBox->isSelected()) {
_login_node.passwordEdit->setString(password);
}
//登录按钮
auto Button_login = (Button*)_login_node.node->getChildByName("Button_login");
if (Button_login) {
Button_login->setVisible(false);
}
// 注册帐号按钮
auto Button_Register = (Button*)_login_node.node->getChildByName("Button_register");
if (Button_Register) {
Button_Register->setVisible(false);
}
// 找回密碼
_login_node.findPwBtn = (ImageView*)_login_node.node->getChildByName("Image_missPassword");
_login_node.findPwBtn->addTouchEventListener(CC_CALLBACK_2(GameLandCopositeV88::findPwEventCallback, this));
if (Tools::isiOSReview()) {
_login_node.findPwBtn->setVisible(false);
}
// 关闭按钮
_login_node.exitBtn = (Button*)_login_node.node->getChildByName("Button_back");
_login_node.exitBtn->addTouchEventListener(CC_CALLBACK_2(GameLandCopositeV88::closeEventCallback, this));
_login_node.exitBtn->setPosition(Vec2(10, WIN_SIZE.height - 10) - WIN_SIZE / 2);
_login_node.loginBtn = AUIButton::create("v88/button/yellow4/da.png", "v88/button/yellow4/da.png");
_login_node.loginBtn->setName("Button_login");
_login_node.loginBtn->setTitle("v88/button/yellow4/2.png");
_login_node.loginBtn->setTitleOffset(Vec2(0, 4));
_login_node.loginBtn->setPosition(Button_login->getPosition());
_login_node.loginBtn->addTouchEventListener(CC_CALLBACK_2(GameLandCopositeV88::landEventCallback, this));
_login_node.node->addChild(_login_node.loginBtn);
_login_node.registerBtn = AUIButton::create("v88/button/blue2/6.png", "v88/button/blue2/6.png");
_login_node.registerBtn->setName("Button_register");
_login_node.registerBtn->setTitle("v88/button/blue2/7.png");
_login_node.registerBtn->setTitleOffset(Vec2(0, 4));
_login_node.registerBtn->setPosition(Button_Register->getPosition());
_login_node.registerBtn->addTouchEventListener(CC_CALLBACK_2(GameLandCopositeV88::registEventCallback, this));
_login_node.node->addChild(_login_node.registerBtn);
auto bg = dynamic_cast<Sprite*>(_login_node.node->getChildByName("bg"));
Size size = Size(469, 141);
if (bg) {
size = bg->getContentSize();
}
auto logo = dynamic_cast<Sprite*>(_login_node.node->getChildByName("Sprite_2"));
if (logo) {
logo->setAnchorPoint(Vec2::ANCHOR_MIDDLE);
logo->setPositionY(WIN_SIZE.height / 2 - 10 - (WIN_SIZE.height / 2 - 10 - size.height / 2) / 2);
logo->setVisible(false);
Tools::addAnimationFrame("v88/animation/entry/logo/entry_logo.csb", _login_node.node, "entry_logo", Vec2(0, logo->getPositionY()), logo->getScale());
}
if (_login_node.loginBtn) {
_login_node.loginBtn->setPositionY((_login_node.findPwBtn->getPositionY() + (-WIN_SIZE.height / 2 + 50)) / 2);
}
if (_login_node.registerBtn) {
_login_node.registerBtn->setPositionY((_login_node.findPwBtn->getPositionY() + (-WIN_SIZE.height / 2 + 50)) / 2);
}
UserDefault::getInstance()->setIntegerForKey(ENTER_GAME_LIST_POS, 0);
return true;
}
void GameLandCopositeV88::landEventCallback(Ref* pSender, Widget::TouchEventType type) {
auto btn = (Button*)pSender;
switch (type) {
case cocos2d::ui::Widget::TouchEventType::BEGAN:
btn->setColor(Color3B(155, 155, 155));
break;
case cocos2d::ui::Widget::TouchEventType::ENDED:
btn->setColor(Color3B(255, 255, 255));
HNAudioEngine::getInstance()->playEffect(GAME_SOUND_BUTTON);
do {
// 获取输入框账号
std::string userName = _login_node.accountEdit->getString();
if (userName.empty()) {
GamePromptLayer::create()->showPrompt(GetText("Account_NOT_EMPTY"));
break;
}
// 获取输入框密码
std::string passWord = _login_node.passwordEdit->getString();
if (passWord.empty()) {
GamePromptLayer::create()->showPrompt(GetText("PASSWORLD_NOT_EMPTY"));
break;
}
std::string savePassWord = UserDefault::getInstance()->getStringForKey(PASSWORD_TEXT);
if (nullptr != onLoginCallBack) {
if (passWord.compare(savePassWord) == 0) {
onLoginCallBack(userName, passWord);
} else {
passWord = MD5_CTX::MD5String(passWord);
onLoginCallBack(userName, passWord);
}
}
} while (0);
break;
case cocos2d::ui::Widget::TouchEventType::CANCELED:
btn->setColor(Color3B(255, 255, 255));
break;
default:
break;
}
}
void GameLandCopositeV88::weiXInLoginCallBack(Ref* pSender, Widget::TouchEventType type) {
CCLOG("========================= Weixin");
}
void GameLandCopositeV88::closeEventCallback(Ref* pSender, Widget::TouchEventType type) {
// Button* selectedBtn = (Button*)pSender;
switch (type) {
case cocos2d::ui::Widget::TouchEventType::BEGAN:
case cocos2d::ui::Widget::TouchEventType::CANCELED:
case cocos2d::ui::Widget::TouchEventType::MOVED:
break;
case cocos2d::ui::Widget::TouchEventType::ENDED: {
HNAudioEngine::getInstance()->playEffect(GAME_SOUND_CLOSE);
onBackCallBack();
// SpriteFrameCache::getInstance()->removeUnusedSpriteFrames();
// AnimationCache::getInstance()->destroyInstance();
// // CocosDenshion::SimpleAudioEngine::getInstance()->end();
// //AudioEngine::end();
// Director::getInstance()->end();
//
// #if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)
// exit(0);
// #elif (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
// exit(0);
// #elif (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
// exit(0);
// #endif
}
break;
}
}
void GameLandCopositeV88::checkBoxCallback(Ref* pSender, CheckBox::EventType type) {
auto userDefault = UserDefault::getInstance();
switch (type) {
case cocos2d::ui::CheckBox::EventType::SELECTED:
userDefault->setBoolForKey(SAVE_TEXT, true);
break;
case cocos2d::ui::CheckBox::EventType::UNSELECTED:
userDefault->setBoolForKey(SAVE_TEXT, false);
_login_node.passwordEdit->setText("");
break;
default:
break;
}
userDefault->flush();
}
// 注册按钮回调函数
void GameLandCopositeV88::registEventCallback(Ref* pSender, Widget::TouchEventType type) {
if (Widget::TouchEventType::ENDED != type) return;
auto btn = (Button*)pSender;
HNAudioEngine::getInstance()->playEffect(GAME_SOUND_CLOSE);
onRegistCallBack();
}
// 忘記密碼回調
void GameLandCopositeV88::findPwEventCallback(Ref* pSender, Widget::TouchEventType type) {
if (Widget::TouchEventType::ENDED != type) return;
auto btn = (Button*)pSender;
HNAudioEngine::getInstance()->playEffect(GAME_SOUND_CLOSE);
onFindPwCallBack();
}
| [
"732328380@qq.com"
] | 732328380@qq.com |
629de9629cb6ecbae135da635521712e85119725 | 63b780d4f90e6c7c051d516bf380f596809161a1 | /FreeEarthSDK/src/FeTriton/RotorWash.cpp | dc1fd7d71f55ed5b16cd5a75defacaf4f84786da | [] | no_license | hewuhun/OSG | 44f4a0665b4a20756303be21e71f0e026e384486 | cfea9a84711ed29c0ca0d0bfec633ec41d8b8cec | refs/heads/master | 2022-09-05T00:44:54.244525 | 2020-05-26T14:44:03 | 2020-05-26T14:44:03 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,528 | cpp | // Copyright (c) 2013-2014 Sundog Software LLC. All rights reserved worldwide.
#include <FeTriton/RotorWash.h>
#include <FeTriton/Ocean.h>
#include <FeTriton/WakeManager.h>
#include <FeTriton/Configuration.h>
#include <FeTriton/Decal.h>
#include <FeTriton/DecalManager.h>
using namespace Triton;
RotorWash::RotorWash(Ocean *pOcean, double pRotorDiameter, bool pSprayEffects, bool pUseDecals,double pFadeInTime)
: ocean(pOcean), sprayEffects(pSprayEffects), lastWaveEmitTime(0), lastSprayEmitTime(0),
firstEmit(true), wakeNumber(0), lastWakeNumber(-1), rotorDiameter(pRotorDiameter),
useDecal(pUseDecals), phaseOffset(0), registered(false), lastTime(0),waveFadeInTime(pFadeInTime)
{
waveGenerationPeriod = 2.0;
Configuration::GetDoubleValue("wash-wave-generation-period", waveGenerationPeriod);
sprayGenerationPeriod = 1.0;
Configuration::GetDoubleValue("wash-spray-generation-period", sprayGenerationPeriod);
double washSize = 3.0;
Configuration::GetDoubleValue("wash-size", washSize);
windScale = 2.0;
Configuration::GetDoubleValue("wash-wind-scale", windScale);
rotorDecalSpeedLimit = 10.0;
Configuration::GetDoubleValue("wash-decal-speed-limit", rotorDecalSpeedLimit);
if (pOcean) rotorDecalSpeedLimit /= pOcean->GetEnvironment()->GetWorldUnits();
phaseRandomness = 0.5;
Configuration::GetDoubleValue("wash-phase-randomness", phaseRandomness);
washDiameter = pRotorDiameter * washSize;
maxVelocity = 10.0;
Configuration::GetDoubleValue("wash-max-velocity", maxVelocity);
if (pOcean) maxVelocity /= pOcean->GetEnvironment()->GetWorldUnits();
particleSize = 10.0;
Configuration::GetDoubleValue("wash-spray-particle-size", particleSize);
if (pOcean) particleSize /= pOcean->GetEnvironment()->GetWorldUnits();
transparency = 0.2f;
Configuration::GetFloatValue("wash-spray-transparency", transparency);
decayRate = 1.0 / 0.9;
Configuration::GetDoubleValue("wash-wave-decay", decayRate);
decalPeriod = 3.0f;
Configuration::GetFloatValue("wash-decal-period", decalPeriod);
decalMinScale = 1.0f;
Configuration::GetFloatValue("wash-decal-min-scale", decalMinScale);
decalMaxScale = 5.0f;
Configuration::GetFloatValue("wash-decal-max-scale", decalMaxScale);
decalIntensity = 2.0;
Configuration::GetDoubleValue("wash-decal-intensity", decalIntensity);
for (int i = 0; i < NUM_DECALS; i++) {
decals[i] = 0;
decalStartTimes[i] = 0;
}
for (int j = 0; j < SMOOTH_BUFFER_SIZE; j++) {
velocitySmoothBuffer[j] = 0;
}
bufferEntry = 0;
currentDecal = 0;
}
RotorWash::~RotorWash()
{
if (ocean && registered) {
for (int i = 0; i < NUM_DECALS; i++) {
if (decals[i]) {
ocean->RemoveDecal((DecalHandle)decals[i]);
}
}
ocean->UnregisterRotorWash(this);
}
}
void RotorWash::UpdateDecals(double time, const Vector3& position, double dampening)
{
if (!useDecal) return;
double modelVelocity = 0, smoothedVelocity = 0;
if (lastTime > 0 && time > lastTime) {
modelVelocity = (position - lastPosition).Length() / (time - lastTime);
velocitySmoothBuffer[bufferEntry] = modelVelocity;
bufferEntry++;
if (bufferEntry >= SMOOTH_BUFFER_SIZE) {
bufferEntry = 0;
}
}
double totalVel = 0;
for (int i = 0; i < SMOOTH_BUFFER_SIZE; i++) {
totalVel += velocitySmoothBuffer[i];
}
smoothedVelocity = totalVel / (double)SMOOTH_BUFFER_SIZE;
lastPosition = position;
lastTime = time;
double velocityDampening = (rotorDecalSpeedLimit - smoothedVelocity) / rotorDecalSpeedLimit;
if (velocityDampening > 1.0) velocityDampening = 1.0;
if (velocityDampening < 0) velocityDampening = 0;
dampening *= velocityDampening;
dampening *= decalIntensity;
if (dampening > 1.0) dampening = 1.0;
if (dampening < 0) dampening = 0;
double dt = time - decalStartTimes[currentDecal];
if (dt > decalPeriod / (float)NUM_DECALS) {
currentDecal++;
if (currentDecal >= NUM_DECALS) currentDecal = 0;
decalStartTimes[currentDecal] = time;
if (!decals[currentDecal] && ocean) {
decals[currentDecal] = (Decal *)(ocean->AddDecal(ocean->GetWakeManager()->GetRotorWashTexture(),
(float)rotorDiameter, position));
if (decals[currentDecal]) {
decals[currentDecal]->SetAdditive(true);
}
} else {
decals[currentDecal]->SetPosition(position);
}
}
for (int i = 0; i < NUM_DECALS; i++) {
Decal *decal = decals[i];
if (decal) {
float a = (float)(time - decalStartTimes[i]) / decalPeriod;
if (a > 1.0f) a = 1.0f;
float alpha = 1.7f * sinf(TRITON_PIF * a) * (1.0f - a);
decal->SetAlpha(alpha * (float)(velocity / maxVelocity) * (float)dampening);
float scale = decalMinScale + a * (decalMaxScale - decalMinScale);
decal->SetScale(scale, scale);
}
}
}
void RotorWash::Update(const Vector3& pPosition, const Vector3& direction, double pVelocity, double pTime)
{
if (!registered) {
if (ocean) {
ocean->RegisterRotorWash(this);
registered = true;
}
}
Vector3 dir = direction;
dir.Normalize();
if (ocean && ocean->GetIntersection(pPosition, dir, position)) {
double distance = (pPosition - position).Length();
double distanceDampening = exp(-distance / rotorDiameter) * windScale;
velocity = pVelocity * distanceDampening;
if (velocity > maxVelocity) {
velocity = maxVelocity;
}
UpdateDecals(pTime, position, distanceDampening);
WakeManager *wakeManager = ocean->GetWakeManager();
if (wakeManager) {
double period = waveGenerationPeriod + phaseOffset;
if ((pTime - lastWaveEmitTime) > period) {
lastWaveEmitTime = pTime;
Vector3 delta;
if (!firstEmit) {
delta = lastEmitPosition - position;
} else {
firstEmit = false;
}
lastLastEmitPosition = lastEmitPosition;
lastEmitSourcePosition = pPosition;
lastEmitPosition = position;
lastWakeNumber = wakeNumber;
wakeManager->AddCircularWave(velocity, position, pTime,waveFadeInTime,Vector3(0, 0, 0), rotorDiameter, decayRate, NULL);
if (ocean && ocean->GetEnvironment()) {
phaseOffset = ocean->GetEnvironment()->GetRandomNumberGenerator()->GetRandomDouble(0.0, waveGenerationPeriod * phaseRandomness);
}
}
if (sprayEffects) {
period = sprayGenerationPeriod;
if ((pTime - lastSprayEmitTime) > period) {
lastSprayEmitTime = pTime;
const Environment *env = ocean->GetEnvironment();
Vector3 up = env->GetUpVector();
Vector3 xAxis = up.Cross(dir);
if (xAxis == Vector3(0, 0, 0)) {
Vector3 right = env->GetRightVector();
xAxis = right.Cross(dir);
}
xAxis.Normalize();
Vector3 yAxis = xAxis.Cross(dir);
double t = 2.0 * TRITON_PI * env->GetRandomNumberGenerator()->GetRandomDouble(0.0, 1.0);
double r = env->GetRandomNumberGenerator()->GetRandomDouble(0.5, 1.0);
r *= washDiameter;
double x = r * cos(t);
double y = r * sin(t);
Vector3 originPoint = pPosition + xAxis * x + yAxis * y;
Vector3 sprayIntersection;
if (ocean->GetIntersection(originPoint, dir, sprayIntersection)) {
// Reflect off the water surface to get the spray direction
Vector3 L = pPosition - sprayIntersection;
L.Normalize();
Vector3 R = (up * (2.0 * (up.Dot(L)))) - L;
wakeManager->AddDirectionalSpray(velocity, sprayIntersection, R, pTime, particleSize, transparency);
}
}
}
}
}
} | [
"Wang_123456"
] | Wang_123456 |
578000979c2d2b02baf3f99573959660b12b25e6 | 8bbc95651bb1475d24268ffd665c90f9ac2ff84a | /VRCLoader/Loader/CLRHost.cpp | 922ba05460ccbd8eddf41ccf1c122469f671bc85 | [] | no_license | icefr2g/BlazeEngine-IL2CPP | b44e12b69dc269b2eee9199e86043145d4f2d799 | edc163a68a2510f69d2c1428fd19518bb8bc3709 | refs/heads/master | 2023-07-31T14:55:40.695592 | 2021-09-22T08:32:40 | 2021-09-22T08:32:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,812 | cpp | #include "CLRHost.h"
bool CLRHost::clrRunning = false;
ICLRMetaHost* CLRHost::clrInstance = NULL;
ICLRRuntimeInfo* CLRHost::runtimeInfo = NULL;
ICLRRuntimeHost* CLRHost::runtimeHost = NULL;
ICLRControl* CLRHost::clrControl = NULL;
INetDomain* CLRHost::netDomain = NULL;
bool CLRHost::HostCLR()
{
#if (DEBUG)
ConsoleUtils::Log("Setting up CLR host...");
ConsoleUtils::Log("Getting CLR meta host...");
#endif
if (CLRCreateInstance(CLSID_CLRMetaHost, IID_ICLRMetaHost, (LPVOID*)& clrInstance) != S_OK)
{
#if (DEBUG)
ConsoleUtils::Log("Failed to create meta host instance!");
#endif
return false;
}
#if (DEBUG)
ConsoleUtils::Log("Getting CLR runtime information...");
#endif
if (clrInstance->GetRuntime(L"v4.0.30319", IID_ICLRRuntimeInfo, (LPVOID*)& runtimeInfo) != S_OK)
{
#if (DEBUG)
ConsoleUtils::Log("Failed to get runtime information!");
#endif
return false;
}
#if (DEBUG)
ConsoleUtils::Log("Getting CLR runtime host...");
#endif
if (runtimeInfo->GetInterface(CLSID_CLRRuntimeHost, IID_ICLRRuntimeHost, (LPVOID*)& runtimeHost) != S_OK)
{
#if (DEBUG)
ConsoleUtils::Log("Failed to get runtime host interface!");
#endif
return false;
}
#if (DEBUG)
ConsoleUtils::Log("Creating custom CLR IHostControl...");
#endif
NetHostControl* hostControl = new NetHostControl();
if (runtimeHost->SetHostControl((IHostControl*)hostControl) != S_OK)
{
#if (DEBUG)
ConsoleUtils::Log("Failed to create custom CLR IHostControl!");
#endif
delete hostControl;
return false;
}
#if (DEBUG)
ConsoleUtils::Log("Grabbing CLR controller...");
#endif
if (runtimeHost->GetCLRControl(&clrControl) != S_OK)
{
#if (DEBUG)
ConsoleUtils::Log("Failed to grab CLR controller!");
#endif
return false;
}
#if (DEBUG)
ConsoleUtils::Log("Setting custom AppDomain manager...");
#endif
if (clrControl->SetAppDomainManagerType(L"VRCLoader", L"VRCLoader.Domain.DomainManager") != S_OK)
{
#if (DEBUG)
ConsoleUtils::Log("Failed to set custom AppDomain manager!");
#endif
return false;
}
#if (DEBUG)
ConsoleUtils::Log("Starting CLR host...");
#endif
if (runtimeHost->Start() != S_OK) {
#if (DEBUG)
ConsoleUtils::Log("Failed to start CLR host!");
#endif
return false;
}
#if (DEBUG)
ConsoleUtils::Log("Saving CLR interface reference...");
#endif
netDomain = hostControl->GetINetDomain();
#if (DEBUG)
ConsoleUtils::Log("CLR host up and running! We have .NET :)");
#endif
clrRunning = true;
return true;
}
void CLRHost::ReleaseCLR()
{
if (!clrRunning)
return;
runtimeHost->Stop();
runtimeHost->Release();
runtimeInfo->Release();
clrInstance->Release();
}
bool CLRHost::Initialize()
{
if (!clrRunning)
return false;
return (netDomain->Initialize() == S_OK);
}
bool CLRHost::OnApplicationStart()
{
if (!clrRunning)
return false;
return (netDomain->OnApplicationStart() == S_OK);
} | [
"vovanba1999@mail.ru"
] | vovanba1999@mail.ru |
fbd393af1b82757518a0a97194755326ccbb96fb | 4503b4ec29e9a30d26c433bac376f2bddaefd9e5 | /QtitanRibbon4.9.0/VC14/Win32/src/ribbondsgn/QtnMainWindowDsgnTaskMenu.cpp | ae45435b51419f7af4a0010c7f31737752af6772 | [] | no_license | SwunZH/ecocommlibs | 0a872e0bbecbb843a0584fb787cf0c5e8a2a270b | 4cff09ff1e479f5f519f207262a61ee85f543b3a | refs/heads/master | 2021-01-25T12:02:39.067444 | 2018-02-23T07:04:43 | 2018-02-23T07:04:43 | 123,447,012 | 1 | 0 | null | 2018-03-01T14:37:53 | 2018-03-01T14:37:53 | null | UTF-8 | C++ | false | false | 3,989 | cpp | /****************************************************************************
**
** Qtitan Library by Developer Machines (Microsoft-Ribbon implementation for Qt.C++)
**
** Copyright (c) 2009-2015 Developer Machines (http://www.devmachines.com)
** ALL RIGHTS RESERVED
**
** The entire contents of this file is protected by copyright law and
** international treaties. Unauthorized reproduction, reverse-engineering
** and distribution of all or any portion of the code contained in this
** file is strictly prohibited and may result in severe civil and
** criminal penalties and will be prosecuted to the maximum extent
** possible under the law.
**
** RESTRICTIONS
**
** THE SOURCE CODE CONTAINED WITHIN THIS FILE AND ALL RELATED
** FILES OR ANY PORTION OF ITS CONTENTS SHALL AT NO TIME BE
** COPIED, TRANSFERRED, SOLD, DISTRIBUTED, OR OTHERWISE MADE
** AVAILABLE TO OTHER INDIVIDUALS WITHOUT WRITTEN CONSENT
** AND PERMISSION FROM DEVELOPER MACHINES
**
** CONSULT THE END USER LICENSE AGREEMENT FOR INFORMATION ON
** ADDITIONAL RESTRICTIONS.
**
****************************************************************************/
#include "QtnMainWindowDsgnTaskMenu.h"
#include <QApplication>
#include <QUndoCommand>
#include <QAction>
#include <QtPlugin>
#include <QtDesigner/QDesignerFormEditorInterface>
#include <QtDesigner/QExtensionManager>
#include "QtnCommandDsgn.h"
#include "QtnRibbonMainWindow.h"
#include "QtnRibbonBar.h"
QTITAN_USE_NAMESPACE
template<class T>
static T* findWidgetBar(const QWidget *widget)
{
const QList<QObject*> children = widget->children();
foreach (QObject *obj, widget->children())
{
if (T* mb = qobject_cast<T*>(obj))
return mb;
}
return Q_NULL;
}
/* MainWindowDsgnTaskMenu */
MainWindowDsgnTaskMenu::MainWindowDsgnTaskMenu(QWidget* widget, QObject* parent)
: QObject(parent)
{
m_widget = widget;
Q_ASSERT(qobject_cast<QDesignerFormWindowInterface*>(m_widget) == 0);
m_addRibbonBar = new QAction(MainWindowDsgnTaskMenu::tr("Create Ribbon Bar"), this);
QObject::connect(m_addRibbonBar, SIGNAL(triggered()), this, SLOT(slotCreateRibbonBar()));
}
MainWindowDsgnTaskMenu::~MainWindowDsgnTaskMenu()
{
}
QWidget* MainWindowDsgnTaskMenu::widget() const
{
return m_widget;
}
void MainWindowDsgnTaskMenu::slotCreateRibbonBar()
{
QDesignerFormWindowInterface* fw = formWindow();
Q_ASSERT(fw != Q_NULL);
QMainWindow *mw = qobject_cast<QMainWindow*>(fw->mainContainer());
if (!mw)
{
// ### warning message
return;
}
CreateRibbonBarCommand* cmd = new CreateRibbonBarCommand(fw);
cmd->init(mw);
cmd->redo();
fw->commandHistory()->push(cmd);
}
QDesignerFormWindowInterface* MainWindowDsgnTaskMenu::formWindow() const
{
QDesignerFormWindowInterface* result = QDesignerFormWindowInterface::findFormWindow(widget());
Q_ASSERT(result != 0);
return result;
}
QList<QAction*> MainWindowDsgnTaskMenu::taskActions() const
{
QList<QAction *> list;
const bool isMainContainer = formWindow()->mainContainer() == widget();
if (const QMainWindow* mw = qobject_cast<const QMainWindow*>(formWindow()->mainContainer()))
{
if (isMainContainer || mw->centralWidget() == widget()) {
if (!findWidgetBar<RibbonBar>(mw) && !findWidgetBar<QMenuBar>(mw))
list.append(m_addRibbonBar);
}
}
return list;
}
/* MainWindowMenuExFactory */
MainWindowMenuExFactory::MainWindowMenuExFactory(QExtensionManager* parent)
: QExtensionFactory(parent)
{
}
MainWindowMenuExFactory::~MainWindowMenuExFactory()
{
}
QObject* MainWindowMenuExFactory::createExtension(QObject* object, const QString& iid, QObject* parent) const
{
RibbonMainWindow* widget = qobject_cast<RibbonMainWindow*>(object);
if (widget && (iid == Q_TYPEID(QDesignerTaskMenuExtension)))
return new MainWindowDsgnTaskMenu(widget, parent);
else
return 0;
}
| [
"me@kimjunu.com"
] | me@kimjunu.com |
173dd67e7482311573616e7cf4d37b755f84d6d5 | c1794e3e09414199f5cc5a1d92f1b50572a2b0ec | /cpp11/trie_tree.cc | 7182e31cd6cee9f8acd75d3fbf01b37733c83c7f | [] | no_license | duanbing/tools | 195c6a2308293ccda096f60820e224aed246d354 | 9ad5e0f49a834c8eccc8c695facf338fa8b2811d | refs/heads/master | 2021-04-29T13:21:01.775650 | 2021-01-27T03:25:59 | 2021-01-27T03:25:59 | 121,749,594 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,278 | cc | /***************************************************************************
*
* Copyright (c) 2017 Baidu.com, Inc. All Rights Reserved
* @author duanbing(duanbing@baidu.com)
*
**************************************************************************/
/**
* @filename trie_tree.cc
* @desc
* @create time 2018-03-08 01:06:39
**/
#include<cstdio>
#include<iostream>
#include<vector>
using namespace std;
struct trie_node {
int mark;
int next[255];
trie_node(int m=0):mark(m){
memset(next,0,sizeof(next));
}
};
void build(vector<trie_node>& root,string word) {
if(word.length()<=0) return;
if(root.size() == 0) {
root.push_back(trie_node());
}
int idx = 0;
for(int i=0;i<word.length();i++) {
trie_node cur = root[idx];
if(cur.next[word[i]] == 0) {
root[idx].next[word[i]] = root.size();
root.push_back(trie_node(1));
}
idx = root[idx].next[word[i]];
}
root[idx].mark = 1;
}
int find(vector<trie_node>& root,string word) {
int idx = 0;
for(int i=0;i<word.length();i++) {
trie_node cur = root[idx];
if(cur.next[word[i]] == 0) {
cout << word[i] << endl;
return 0;
}
idx = cur.next[word[i]];
}
return root[idx].mark;
}
int main() {
vector<trie_node>root;
vector<string> vs = {"bbaabaabaaaaabaababaaaaababb","aabbaaabaaabaabaaaaaabbaaaba","babaababbbbbbbaabaababaabaaa","bbbaaabaabbaaababababbbbbaaa","babbabbbbaabbabaaaaaabbbaaab","bbbababbbbbbbababbabbbbbabaa","babababbababaabbbbabbbbabbba","abbbbbbaabaaabaaababaabbabba","aabaabababbbbbbababbbababbaa","aabbbbabbaababaaaabababbaaba","ababaababaaabbabbaabbaabbaba","abaabbbaaaaababbbaaaaabbbaab","aabbabaabaabbabababaaabbbaab","baaabaaaabbabaaabaabababaaaa","aaabbabaaaababbabbaabbaabbaa","aaabaaaaabaabbabaabbbbaabaaa","abbaabbaaaabbaababababbaabbb","baabaababbbbaaaabaaabbababbb","aabaababbaababbaaabaabababab","abbaaabbaabaabaabbbbaabbbbbb","aaababaabbaaabbbaaabbabbabab","bbababbbabbbbabbbbabbbbbabaa","abbbaabbbaaababbbababbababba","bbbbbbbabbbababbabaabababaab","aaaababaabbbbabaaaaabaaaaabb","bbaaabbbbabbaaabbaabbabbaaba","aabaabbbbaabaabbabaabababaaa","abbababbbaababaabbababababbb","aabbbabbaaaababbbbabbababbbb","babbbaabababbbbbbbbbaabbabaa"};
for(auto ts : vs)
build(root,ts);
cout << find(root,"bbbbbbbabbbababbabaabababaab") << endl;
return 0;
}
| [
"duanbing@baidu.com"
] | duanbing@baidu.com |
2bd62aa3a5e870822dd47eb3d31d6fff31a2b772 | 550e96fb6a69ee7d35bd1c1e4d6601505db42b38 | /APPLICATIONS/SHALLOW_WATER/SW_SK_new/Sources/libschemes/order2.cpp | 22787ef2a398d4d0ef994eced39502020a52c95e | [] | no_license | jbigot/csm | b81e460063b042a800d52c7db0a3dbf137d307e7 | 9ab0f08d0eb3c230c5bc0dfb59d872fe0d3ecbb3 | refs/heads/master | 2023-03-18T16:04:06.518853 | 2017-03-07T13:16:22 | 2017-03-07T13:16:22 | 350,790,392 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,132 | cpp | #include "misc.hpp"
#include "order2.hpp"
#include "order2_parallel.hpp"
order2::order2(parameters * &par):scheme(par) {
// variable avec cellule fictive
hsa.init(head,1.0);
usa.init(head,1.0);
vsa.init(head,1.0);
// variable sans cellule fictive
qsa1.init(head,0.);
qsa2.init(head,0.);
// variable a l'interface en x
z1l.init(head2,0.);
z1r.init(head2,0.);
// variable a l'interface en y
z2l.init(head3,0.);
z2r.init(head3,0.);
rec = rec_muscl::getSingleton(par->get_lim());
}
order2::~order2() {
hsa.erase();
usa.erase();
vsa.erase();
qsa1.erase();
qsa2.erase();
z1l.erase();
z1r.erase();
z2l.erase();
z2r.erase();
if (rec != NULL) {
delete rec;
rec = NULL;
}
}
void order2:: Heun_hq(TAB & he, TAB0 & qe1, TAB0 & qe2, TAB & hes, TAB0 & qes1, TAB0 & qes2) {
vTAB0 inputs;
vTAB outputs;
outputs.push_back(he);
inputs.push_back(qe1);
inputs.push_back(qe2);
outputs.push_back(hes);
inputs.push_back(qes1);
inputs.push_back(qes2);
ApplyList<SCALAR,0,SCALAR,2,false>::apply(Heun_hq_f,inputs,outputs);
}
void order2::calcul() {
//time iteration's beginning
Chronometer chrono;
chrono.start();
//while (T > tps) {
while(tps<T){
// save the data in huv_movie.dat
//if (n % nsave == 0) {
//out->write(h,u,v,z,tps);
//}// end if
//boundary conditions
boundary(h,u,v);
vTAB inputs;
vTAB0 outputs;
inputs.push_back(h);
inputs.push_back(u);
inputs.push_back(v);
inputs.push_back(z);
outputs.push_back(h1l);
outputs.push_back(h1r);
outputs.push_back(u1l);
outputs.push_back(u1r);
outputs.push_back(v1l);
outputs.push_back(v1r);
outputs.push_back(z1l);
outputs.push_back(z1r);
ApplyList<SCALAR,2,SCALAR,0,false>::apply(order2_huv1_f,inputs,outputs);
outputs.clear();
outputs.push_back(h2l);
outputs.push_back(h2r);
outputs.push_back(u2l);
outputs.push_back(u2r);
outputs.push_back(v2l);
outputs.push_back(v2r);
outputs.push_back(z2l);
outputs.push_back(z2r);
ApplyList<SCALAR,2,SCALAR,0,false>::apply(order2_huv2_f,inputs,outputs);
inputs.clear();
outputs.clear();
//------------delz1,delz2,delzc1,delzc2------------//
//delz1
ApplyBinary<SCALAR,0,SCALAR,SCALAR,0,false>::apply(order2_delz_f,z1l,z1r,delz1);
//delzc1
ApplyBinary<SCALAR,0,SCALAR,SCALAR,0,false>::apply(order2_delzc1_f,z1l,z1r,delzc1);
//delz2
ApplyBinary<SCALAR,0,SCALAR,SCALAR,0,false>::apply(order2_delz_f,z2l,z2r,delz2);
//delz1
ApplyBinary<SCALAR,0,SCALAR,SCALAR,0,false>::apply(order2_delzc2_f,z2l,z2r,delzc2);
//-------------------------------------------------//
bloc1(flux_left,flux_right,flux_bottom,flux_top);
bloc2(h,u,v,q1,q2,hs,qs1,qs2,us,vs); //with check
//check_ve_ca(hs,us,vs,qs1,qs2);
//----------------------------------------------//
//boundary conditions
boundary(hs,us,vs);
inputs.push_back(hs);
inputs.push_back(us);
inputs.push_back(vs);
inputs.push_back(z);
outputs.push_back(h1l);
outputs.push_back(h1r);
outputs.push_back(u1l);
outputs.push_back(u1r);
outputs.push_back(v1l);
outputs.push_back(v1r);
outputs.push_back(z1l);
outputs.push_back(z1r);
ApplyList<SCALAR,2,SCALAR,0,false>::apply(order2_huv1_f,inputs,outputs);
outputs.clear();
outputs.push_back(h2l);
outputs.push_back(h2r);
outputs.push_back(u2l);
outputs.push_back(u2r);
outputs.push_back(v2l);
outputs.push_back(v2r);
outputs.push_back(z2l);
outputs.push_back(z2r);
ApplyList<SCALAR,2,SCALAR,0,false>::apply(order2_huv2_f,inputs,outputs);
inputs.clear();
outputs.clear();
//------------delz1,delz2,delzc1,delzc2------------//
//delz1
ApplyBinary<SCALAR,0,SCALAR,SCALAR,0,false>::apply(order2_delz_f,z1l,z1r,delz1);
//delzc1
ApplyBinary<SCALAR,0,SCALAR,SCALAR,0,false>::apply(order2_delzc1_f,z1l,z1r,delzc1);
//delz2
ApplyBinary<SCALAR,0,SCALAR,SCALAR,0,false>::apply(order2_delz_f,z2l,z2r,delz2);
//delzc1
ApplyBinary<SCALAR,0,SCALAR,SCALAR,0,false>::apply(order2_delzc2_f,z2l,z2r,delzc2);
//-------------------------------------------------//
bloc1(flux_left,flux_right,flux_bottom,flux_top);
bloc22(hs,us,vs,qs1,qs2,hsa,qsa1,qsa2,h,q1,q2); //with Heun
//----------------------------------------------//
//Heun_hq(h,q1,q2,hsa,qsa1,qsa2);
//check_ve_ca(h,u,v,q1,q2);
tps += 1;//dt;
n++;
//out->write(h,u,v,z,tps);
} //end for n : loop in time
//out->write(h,u,v,z,tps);
chrono.stop();
std::stringstream st;
st<<" Time TOTAL CALCULATION : "<<chrono.dureeCalcule()<<" ";
Mpi_::printScreen(st.str());
}
| [
"helene.coullon@inria.fr"
] | helene.coullon@inria.fr |
34232a8adab485ae57d5d8352f1ae5b689e37b0a | 6769d7a0bed224ddcd4ccc2758a634ea1b7a8f18 | /Project/build-qtFinal-Desktop-Debug/moc_bullet.cpp | d90f967476d20261d74d417861e80696512d6afa | [
"CC0-1.0"
] | permissive | mahdialikhasi/Advanced-Programming | 97bd44497dc81596711708085eff9bc5da9a808c | 0ece123e6442e5e844f657e5ea2ca9de00d5c734 | refs/heads/master | 2022-11-28T13:22:48.298311 | 2020-08-12T06:16:55 | 2020-08-12T06:16:55 | 205,987,385 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,335 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'bullet.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.5.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../qtFinal/bullet.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'bullet.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.5.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_Bullet_t {
QByteArrayData data[3];
char stringdata0[13];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_Bullet_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_Bullet_t qt_meta_stringdata_Bullet = {
{
QT_MOC_LITERAL(0, 0, 6), // "Bullet"
QT_MOC_LITERAL(1, 7, 4), // "move"
QT_MOC_LITERAL(2, 12, 0) // ""
},
"Bullet\0move\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_Bullet[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
1, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
0, // signalCount
// slots: name, argc, parameters, tag, flags
1, 0, 19, 2, 0x0a /* Public */,
// slots: parameters
QMetaType::Void,
0 // eod
};
void Bullet::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
Bullet *_t = static_cast<Bullet *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->move(); break;
default: ;
}
}
Q_UNUSED(_a);
}
const QMetaObject Bullet::staticMetaObject = {
{ &QObject::staticMetaObject, qt_meta_stringdata_Bullet.data,
qt_meta_data_Bullet, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};
const QMetaObject *Bullet::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *Bullet::qt_metacast(const char *_clname)
{
if (!_clname) return Q_NULLPTR;
if (!strcmp(_clname, qt_meta_stringdata_Bullet.stringdata0))
return static_cast<void*>(const_cast< Bullet*>(this));
if (!strcmp(_clname, "QGraphicsRectItem"))
return static_cast< QGraphicsRectItem*>(const_cast< Bullet*>(this));
return QObject::qt_metacast(_clname);
}
int Bullet::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 1)
qt_static_metacall(this, _c, _id, _a);
_id -= 1;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 1)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 1;
}
return _id;
}
QT_END_MOC_NAMESPACE
| [
"mahdialikhasi1389@gmail.com"
] | mahdialikhasi1389@gmail.com |
e5663dfbe6ad93722988ad141dacb66ea58218ac | c7b270492e0348214dd9d65fa651280506d09bd8 | /Pre-Orca/hectorquad/src/publishPose.cpp | 5cefc82d0f3884c8eea837c79d3b4091fdc68cb6 | [] | no_license | erenerisken/drone_motion | 10f54eca3df9fdb2a4a56f9a3e0fc1194cc4987e | 727dcc5759963e5f84873557606b719cabdc5f1c | refs/heads/master | 2021-07-25T05:13:03.691489 | 2020-07-08T06:03:02 | 2020-07-08T06:03:02 | 196,026,836 | 6 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,243 | cpp | #include <ros/ros.h>
#include <geometry_msgs/Quaternion.h>
#include <gazebo_msgs/ModelStates.h>
#include <vector>
#define QUAD_COUNT 4
ros::NodeHandle *nhPtr;
class UAV
{
public:
std::string name_;
ros::Publisher pub_;
UAV(std::string name) : name_(name)
{
ROS_INFO_STREAM(name + " has been added.");
pub_ = nhPtr->advertise<geometry_msgs::Quaternion>(name + "/quadPose", 1);
}
UAV() {}
void publish(const geometry_msgs::Quaternion &msg)
{
pub_.publish(msg);
}
};
std::vector<UAV> quads;
void getPoses(const gazebo_msgs::ModelStates &msg)
{
std::vector<int> indexes;
const int modelCount = msg.name.size();
for (size_t i = 0; i < modelCount; i++)
{
if (msg.name[i].substr(0,3) == "uav")
{
indexes.push_back(i);
//ROS_INFO_STREAM("A quad " << msg.name[i].substr(0,3) << " is found in "<<i);
}
}
for (auto i = indexes.begin(); i < indexes.end(); i++)
{
for (size_t j = 0; j < QUAD_COUNT; j++)
{
if(msg.name[*i] == quads[j].name_)
{
geometry_msgs::Quaternion pose;
pose.x = msg.pose[*i].position.x;
pose.y = msg.pose[*i].position.y;
pose.z = msg.pose[*i].position.z;
pose.w = msg.pose[*i].orientation.z;
quads[j].publish(pose);
}
}
}
}
int main(int argc, char* argv[])
{
ros::init(argc, argv, "publishPose");
ros::NodeHandle nh;
nhPtr = &nh;
ros::Subscriber sub = nh.subscribe("gazebo/model_states", 1, &getPoses);
for (size_t i = 1; i <= QUAD_COUNT; i++)
{
quads.push_back(UAV("uav" + std::to_string(i)));
}
ros::spin();
} | [
"erenerisken@gmail.com"
] | erenerisken@gmail.com |
f94012cbc6ec6e830dec5213b12e7d0705f3733a | c0893165fbb874bb3b5149f3511e12b7aa2f2b23 | /Petya and Strings.cpp | 11e956baa3404e3b62391a3dc6615ce05e7c93b8 | [] | no_license | run-zen/My-codes | 57463e5e32f887ed8fc88d57f82e418a60e78e89 | 807fc9d9b1a48f847c8c5aa6a7ac7cc006430d2f | refs/heads/master | 2023-01-12T21:24:40.304339 | 2020-11-18T04:02:12 | 2020-11-18T04:02:12 | 290,465,588 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 658 | cpp | #include <iostream>
#include <string>
using std::string;
using namespace std;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);cout.tie(0);
string first_string,second_string;
cin >> first_string >> second_string;
int result = 0;
int i = 0;
char a,b;
while (first_string[i] != '\0')
{
a = first_string[i];
b = second_string[i];
a = tolower(a);
b = tolower(b);
if (a > b)
{
result = 1;
break;
}
else if (a < b)
{
result = -1;
break;
}
i++;
}
cout << result << endl;
} | [
"55329832+run-zen@users.noreply.github.com"
] | 55329832+run-zen@users.noreply.github.com |
2ad4b1f2a716e7d9584335b635491597b0bcc38b | aff95ec4050bb261604d8fcacc2249ef20203760 | /OpenGLNeHeBackup/lesson36/Lesson36/Lesson36.cpp | 0b535634c48ce522c15d1c1338b6b94ce14ed2e2 | [] | no_license | TwTravel/OpenGLRefCode | b82ee644259e27817a6451d8cbed494eec0fa265 | daa11168a098108a21ae9df9aa71b34b20fc09f0 | refs/heads/master | 2020-04-01T16:35:12.391700 | 2018-10-17T07:24:22 | 2018-10-17T07:24:22 | 153,388,135 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 15,598 | cpp | /**************************************
* *
* Jeff Molofee's Basecode Example *
* nehe.gamedev.net *
* 2001 *
* *
* All Code / Tutorial Commenting *
* by Jeff Molofee ( NeHe ) *
* *
**************************************/
#include <windows.h> // Header File For Windows
#include <gl\gl.h> // Header File For The OpenGL32 Library
#include <gl\glu.h> // Header File For The GLu32 Library
#include <gl\glaux.h> // Header File For The GLaux Library
#include "NeHeGL.h" // Header File For NeHeGL
#include <math.h> // We'll Need Some Math
#pragma comment( lib, "opengl32.lib" ) // Search For OpenGL32.lib While Linking
#pragma comment( lib, "glu32.lib" ) // Search For GLu32.lib While Linking
#pragma comment( lib, "glaux.lib" ) // Search For GLaux.lib While Linking
#ifndef CDS_FULLSCREEN // CDS_FULLSCREEN Is Not Defined By Some
#define CDS_FULLSCREEN 4 // Compilers. By Defining It This Way,
#endif // We Can Avoid Errors
GL_Window* g_window;
Keys* g_keys;
// User Defined Variables
float angle; // Used To Rotate The Helix
float vertexes[4][3]; // Holds Float Info For 4 Sets Of Vertices
float normal[3]; // An Array To Store The Normal Data
GLuint BlurTexture; // An Unsigned Int To Store The Texture Number
GLuint EmptyTexture() // Create An Empty Texture
{
GLuint txtnumber; // Texture ID
unsigned int* data; // Stored Data
// Create Storage Space For Texture Data (128x128x4)
data = (unsigned int*)new GLuint[((128 * 128)* 4 * sizeof(unsigned int))];
ZeroMemory(data,((128 * 128)* 4 * sizeof(unsigned int))); // Clear Storage Memory
glGenTextures(1, &txtnumber); // Create 1 Texture
glBindTexture(GL_TEXTURE_2D, txtnumber); // Bind The Texture
glTexImage2D(GL_TEXTURE_2D, 0, 4, 128, 128, 0,
GL_RGBA, GL_UNSIGNED_BYTE, data); // Build Texture Using Information In data
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
delete [] data; // Release data
return txtnumber; // Return The Texture ID
}
void ReduceToUnit(float vector[3]) // Reduces A Normal Vector (3 Coordinates)
{ // To A Unit Normal Vector With A Length Of One.
float length; // Holds Unit Length
// Calculates The Length Of The Vector
length = (float)sqrt((vector[0]*vector[0]) + (vector[1]*vector[1]) + (vector[2]*vector[2]));
if(length == 0.0f) // Prevents Divide By 0 Error By Providing
length = 1.0f; // An Acceptable Value For Vectors To Close To 0.
vector[0] /= length; // Dividing Each Element By
vector[1] /= length; // The Length Results In A
vector[2] /= length; // Unit Normal Vector.
}
void calcNormal(float v[3][3], float out[3]) // Calculates Normal For A Quad Using 3 Points
{
float v1[3],v2[3]; // Vector 1 (x,y,z) & Vector 2 (x,y,z)
static const int x = 0; // Define X Coord
static const int y = 1; // Define Y Coord
static const int z = 2; // Define Z Coord
// Finds The Vector Between 2 Points By Subtracting
// The x,y,z Coordinates From One Point To Another.
// Calculate The Vector From Point 1 To Point 0
v1[x] = v[0][x] - v[1][x]; // Vector 1.x=Vertex[0].x-Vertex[1].x
v1[y] = v[0][y] - v[1][y]; // Vector 1.y=Vertex[0].y-Vertex[1].y
v1[z] = v[0][z] - v[1][z]; // Vector 1.z=Vertex[0].y-Vertex[1].z
// Calculate The Vector From Point 2 To Point 1
v2[x] = v[1][x] - v[2][x]; // Vector 2.x=Vertex[0].x-Vertex[1].x
v2[y] = v[1][y] - v[2][y]; // Vector 2.y=Vertex[0].y-Vertex[1].y
v2[z] = v[1][z] - v[2][z]; // Vector 2.z=Vertex[0].z-Vertex[1].z
// Compute The Cross Product To Give Us A Surface Normal
out[x] = v1[y]*v2[z] - v1[z]*v2[y]; // Cross Product For Y - Z
out[y] = v1[z]*v2[x] - v1[x]*v2[z]; // Cross Product For X - Z
out[z] = v1[x]*v2[y] - v1[y]*v2[x]; // Cross Product For X - Y
ReduceToUnit(out); // Normalize The Vectors
}
void ProcessHelix() // Draws A Helix
{
GLfloat x; // Helix x Coordinate
GLfloat y; // Helix y Coordinate
GLfloat z; // Helix z Coordinate
GLfloat phi; // Angle
GLfloat theta; // Angle
GLfloat v,u; // Angles
GLfloat r; // Radius Of Twist
int twists = 5; // 5 Twists
GLfloat glfMaterialColor[]={0.4f,0.2f,0.8f,1.0f}; // Set The Material Color
GLfloat specular[]={1.0f,1.0f,1.0f,1.0f}; // Sets Up Specular Lighting
glLoadIdentity(); // Reset The Modelview Matrix
gluLookAt(0, 5, 50, 0, 0, 0, 0, 1, 0); // Eye Position (0,5,50) Center Of Scene (0,0,0), Up On Y Axis
glPushMatrix(); // Push The Modelview Matrix
glTranslatef(0,0,-50); // Translate 50 Units Into The Screen
glRotatef(angle/2.0f,1,0,0); // Rotate By angle/2 On The X-Axis
glRotatef(angle/3.0f,0,1,0); // Rotate By angle/3 On The Y-Axis
glMaterialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,glfMaterialColor);
glMaterialfv(GL_FRONT_AND_BACK,GL_SPECULAR,specular);
r=1.5f; // Radius
glBegin(GL_QUADS); // Begin Drawing Quads
for(phi=0; phi <= 360; phi+=20.0) // 360 Degrees In Steps Of 20
{
for(theta=0; theta<=360*twists; theta+=20.0) // 360 Degrees * Number Of Twists In Steps Of 20
{
v=(phi/180.0f*3.142f); // Calculate Angle Of First Point ( 0 )
u=(theta/180.0f*3.142f); // Calculate Angle Of First Point ( 0 )
x=float(cos(u)*(2.0f+cos(v) ))*r; // Calculate x Position (1st Point)
y=float(sin(u)*(2.0f+cos(v) ))*r; // Calculate y Position (1st Point)
z=float((( u-(2.0f*3.142f)) + sin(v) ) * r); // Calculate z Position (1st Point)
vertexes[0][0]=x; // Set x Value Of First Vertex
vertexes[0][1]=y; // Set y Value Of First Vertex
vertexes[0][2]=z; // Set z Value Of First Vertex
v=(phi/180.0f*3.142f); // Calculate Angle Of Second Point ( 0 )
u=((theta+20)/180.0f*3.142f); // Calculate Angle Of Second Point ( 20 )
x=float(cos(u)*(2.0f+cos(v) ))*r; // Calculate x Position (2nd Point)
y=float(sin(u)*(2.0f+cos(v) ))*r; // Calculate y Position (2nd Point)
z=float((( u-(2.0f*3.142f)) + sin(v) ) * r); // Calculate z Position (2nd Point)
vertexes[1][0]=x; // Set x Value Of Second Vertex
vertexes[1][1]=y; // Set y Value Of Second Vertex
vertexes[1][2]=z; // Set z Value Of Second Vertex
v=((phi+20)/180.0f*3.142f); // Calculate Angle Of Third Point ( 20 )
u=((theta+20)/180.0f*3.142f); // Calculate Angle Of Third Point ( 20 )
x=float(cos(u)*(2.0f+cos(v) ))*r; // Calculate x Position (3rd Point)
y=float(sin(u)*(2.0f+cos(v) ))*r; // Calculate y Position (3rd Point)
z=float((( u-(2.0f*3.142f)) + sin(v) ) * r); // Calculate z Position (3rd Point)
vertexes[2][0]=x; // Set x Value Of Third Vertex
vertexes[2][1]=y; // Set y Value Of Third Vertex
vertexes[2][2]=z; // Set z Value Of Third Vertex
v=((phi+20)/180.0f*3.142f); // Calculate Angle Of Fourth Point ( 20 )
u=((theta)/180.0f*3.142f); // Calculate Angle Of Fourth Point ( 0 )
x=float(cos(u)*(2.0f+cos(v) ))*r; // Calculate x Position (4th Point)
y=float(sin(u)*(2.0f+cos(v) ))*r; // Calculate y Position (4th Point)
z=float((( u-(2.0f*3.142f)) + sin(v) ) * r); // Calculate z Position (4th Point)
vertexes[3][0]=x; // Set x Value Of Fourth Vertex
vertexes[3][1]=y; // Set y Value Of Fourth Vertex
vertexes[3][2]=z; // Set z Value Of Fourth Vertex
calcNormal(vertexes,normal); // Calculate The Quad Normal
glNormal3f(normal[0],normal[1],normal[2]); // Set The Normal
// Render The Quad
glVertex3f(vertexes[0][0],vertexes[0][1],vertexes[0][2]);
glVertex3f(vertexes[1][0],vertexes[1][1],vertexes[1][2]);
glVertex3f(vertexes[2][0],vertexes[2][1],vertexes[2][2]);
glVertex3f(vertexes[3][0],vertexes[3][1],vertexes[3][2]);
}
}
glEnd(); // Done Rendering Quads
glPopMatrix(); // Pop The Matrix
}
void ViewOrtho() // Set Up An Ortho View
{
glMatrixMode(GL_PROJECTION); // Select Projection
glPushMatrix(); // Push The Matrix
glLoadIdentity(); // Reset The Matrix
glOrtho( 0, 640 , 480 , 0, -1, 1 ); // Select Ortho Mode (640x480)
glMatrixMode(GL_MODELVIEW); // Select Modelview Matrix
glPushMatrix(); // Push The Matrix
glLoadIdentity(); // Reset The Matrix
}
void ViewPerspective() // Set Up A Perspective View
{
glMatrixMode( GL_PROJECTION ); // Select Projection
glPopMatrix(); // Pop The Matrix
glMatrixMode( GL_MODELVIEW ); // Select Modelview
glPopMatrix(); // Pop The Matrix
}
void RenderToTexture() // Renders To A Texture
{
glViewport(0,0,128,128); // Set Our Viewport (Match Texture Size)
ProcessHelix(); // Render The Helix
glBindTexture(GL_TEXTURE_2D,BlurTexture); // Bind To The Blur Texture
// Copy Our ViewPort To The Blur Texture (From 0,0 To 128,128... No Border)
glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 0, 0, 128, 128, 0);
glClearColor(0.0f, 0.0f, 0.5f, 0.5); // Set The Clear Color To Medium Blue
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And Depth Buffer
glViewport(0 , 0,640 ,480); // Set Viewport (0,0 to 640x480)
}
void DrawBlur(int times, float inc) // Draw The Blurred Image
{
float spost = 0.0f; // Starting Texture Coordinate Offset
float alphainc = 0.9f / times; // Fade Speed For Alpha Blending
float alpha = 0.2f; // Starting Alpha Value
// Disable AutoTexture Coordinates
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_2D); // Enable 2D Texture Mapping
glDisable(GL_DEPTH_TEST); // Disable Depth Testing
glBlendFunc(GL_SRC_ALPHA,GL_ONE); // Set Blending Mode
glEnable(GL_BLEND); // Enable Blending
glBindTexture(GL_TEXTURE_2D,BlurTexture); // Bind To The Blur Texture
ViewOrtho(); // Switch To An Ortho View
alphainc = alpha / times; // alphainc=0.2f / Times To Render Blur
glBegin(GL_QUADS); // Begin Drawing Quads
for (int num = 0;num < times;num++) // Number Of Times To Render Blur
{
glColor4f(1.0f, 1.0f, 1.0f, alpha); // Set The Alpha Value (Starts At 0.2)
glTexCoord2f(0+spost,1-spost); // Texture Coordinate ( 0, 1 )
glVertex2f(0,0); // First Vertex ( 0, 0 )
glTexCoord2f(0+spost,0+spost); // Texture Coordinate ( 0, 0 )
glVertex2f(0,480); // Second Vertex ( 0, 480 )
glTexCoord2f(1-spost,0+spost); // Texture Coordinate ( 1, 0 )
glVertex2f(640,480); // Third Vertex ( 640, 480 )
glTexCoord2f(1-spost,1-spost); // Texture Coordinate ( 1, 1 )
glVertex2f(640,0); // Fourth Vertex ( 640, 0 )
spost += inc; // Gradually Increase spost (Zooming Closer To Texture Center)
alpha = alpha - alphainc; // Gradually Decrease alpha (Gradually Fading Image Out)
}
glEnd(); // Done Drawing Quads
ViewPerspective(); // Switch To A Perspective View
glEnable(GL_DEPTH_TEST); // Enable Depth Testing
glDisable(GL_TEXTURE_2D); // Disable 2D Texture Mapping
glDisable(GL_BLEND); // Disable Blending
glBindTexture(GL_TEXTURE_2D,0); // Unbind The Blur Texture
}
BOOL Initialize (GL_Window* window, Keys* keys) // Any GL Init Code & User Initialiazation Goes Here
{
g_window = window;
g_keys = keys;
// Start Of User Initialization
angle = 0.0f; // Set Starting Angle To Zero
BlurTexture = EmptyTexture(); // Create Our Empty Texture
glViewport(0 , 0,window->init.width ,window->init.height); // Set Up A Viewport
glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix
gluPerspective(50, (float)window->init.width/(float)window->init.height, 5, 2000); // Set Our Perspective
glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
glLoadIdentity(); // Reset The Modelview Matrix
glEnable(GL_DEPTH_TEST); // Enable Depth Testing
GLfloat global_ambient[4]={0.2f, 0.2f, 0.2f, 1.0f}; // Set Ambient Lighting To Fairly Dark Light (No Color)
GLfloat light0pos[4]= {0.0f, 5.0f, 10.0f, 1.0f}; // Set The Light Position
GLfloat light0ambient[4]= {0.2f, 0.2f, 0.2f, 1.0f}; // More Ambient Light
GLfloat light0diffuse[4]= {0.3f, 0.3f, 0.3f, 1.0f}; // Set The Diffuse Light A Bit Brighter
GLfloat light0specular[4]={0.8f, 0.8f, 0.8f, 1.0f}; // Fairly Bright Specular Lighting
GLfloat lmodel_ambient[]= {0.2f,0.2f,0.2f,1.0f}; // And More Ambient Light
glLightModelfv(GL_LIGHT_MODEL_AMBIENT,lmodel_ambient); // Set The Ambient Light Model
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient); // Set The Global Ambient Light Model
glLightfv(GL_LIGHT0, GL_POSITION, light0pos); // Set The Lights Position
glLightfv(GL_LIGHT0, GL_AMBIENT, light0ambient); // Set The Ambient Light
glLightfv(GL_LIGHT0, GL_DIFFUSE, light0diffuse); // Set The Diffuse Light
glLightfv(GL_LIGHT0, GL_SPECULAR, light0specular); // Set Up Specular Lighting
glEnable(GL_LIGHTING); // Enable Lighting
glEnable(GL_LIGHT0); // Enable Light0
glShadeModel(GL_SMOOTH); // Select Smooth Shading
glMateriali(GL_FRONT, GL_SHININESS, 128);
glClearColor(0.0f, 0.0f, 0.0f, 0.5); // Set The Clear Color To Black
return TRUE; // Return TRUE (Initialization Successful)
}
void Deinitialize (void) // Any User DeInitialization Goes Here
{
glDeleteTextures(1,&BlurTexture); // Delete The Blur Texture
}
void Update (DWORD milliseconds) // Perform Motion Updates Here
{
if (g_keys->keyDown [VK_ESCAPE] == TRUE) // Is ESC Being Pressed?
{
TerminateApplication (g_window); // Terminate The Program
}
if (g_keys->keyDown [VK_F1] == TRUE) // Is F1 Being Pressed?
{
ToggleFullscreen (g_window); // Toggle Fullscreen Mode
}
angle += (float)(milliseconds) / 5.0f; // Update angle Based On The Clock
}
void Draw (void) // Draw The Scene
{
glClearColor(0.0f, 0.0f, 0.0f, 0.5); // Set The Clear Color To Black
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth Buffer
glLoadIdentity(); // Reset The View
RenderToTexture(); // Render To A Texture
ProcessHelix(); // Draw Our Helix
DrawBlur(25,0.02f); // Draw The Blur Effect
glFlush (); // Flush The GL Rendering Pipeline
}
| [
"twtravel@126.com"
] | twtravel@126.com |
61f516d6a2bdf5dda62d7be3845423ecfa9a9fe7 | 95fa248aee3d8c821606b4f116f42cdd0e6d3367 | /z_update/PetriView/netform.cpp | 6225f98a110be2b392deaac323fdff2b9a453ea8 | [
"Apache-2.0"
] | permissive | hackerlank/training_project | dbc1bee8e7f6dcb255aed5cb544913258f07b888 | 41e9c65bf6deae53b127f7173c6bc5030435c845 | refs/heads/master | 2020-06-12T19:39:44.766569 | 2016-07-03T18:00:57 | 2016-07-03T18:00:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,697 | cpp | #include "netform.h"
#include "ui_netform.h"
#include "visual/placeview.h"
NetForm::NetForm(QWidget *parent) :
QGraphicsView(parent),
ui(new Ui::NetForm)
{
ui->setupUi(this);
updateIds();
this->createPlace(0,0);
QGraphicsScene *scene = new QGraphicsScene(this);
scene->setItemIndexMethod(QGraphicsScene::NoIndex);
scene->setSceneRect(-200, -200, 400, 400);
setScene(scene);
setCacheMode(CacheBackground);
setViewportUpdateMode(BoundingRectViewportUpdate);
setRenderHint(QPainter::Antialiasing);
setTransformationAnchor(AnchorUnderMouse);
//scale(qreal(0.8), qreal(0.8));
setMinimumSize(400, 400);
setWindowTitle(tr("Elastic Nodes"));
PlaceView* pv = new PlaceView(this);
scene->addItem(pv);
}
NetForm::~NetForm()
{
delete ui;
}
void NetForm::createPlace(int x, int y)
{
int id = getNextPlace();
std::string placeName = "p_"+std::to_string(id);
spnp::Place *p = new spnp::Place(id, placeName, 0,
new spnp::Label(id, placeName, x, y),
x, y);
this->netData.add(p);
}
void NetForm::createTransition(int x, int y)
{
int id = getNextTransition();
std::string transitionName = "t_"+std::to_string(id);
spnp::Transition *t = new spnp::Transition(id, transitionName,"1", x, y);
this->netData.add(t);
}
void NetForm::createArc(int idP, int idT, bool fromPtoT)
{
int id = getNextArc();
std::string arcName = "a_"+std::to_string(id);
spnp::Arc *a = new spnp::Arc(id, arcName, idP, idT, fromPtoT);
this->netData.add(a);
}
void NetForm::removePlace(int id)
{
this->netData.removePlace(id);
}
void NetForm::removeArc(int id)
{
this->netData.removeArc(id);
}
void NetForm::removeTransition(int id)
{
this->netData.removeTransition(id);
}
void NetForm::itemMoved()
{
//atualizar posição dos arcos
}
void NetForm::zoomIn()
{
scaleView(qreal(1.2));
}
void NetForm::zoomOut()
{
scaleView(1 / qreal(1.2));
}
void NetForm::keyPressEvent(QKeyEvent *event)
{
switch (event->key())
{
case Qt::Key_Plus:
zoomIn();
break;
case Qt::Key_Minus:
zoomOut();
break;
default:
QGraphicsView::keyPressEvent(event);
}
}
void NetForm::wheelEvent(QWheelEvent *event)
{
scaleView(pow((double)2, -event->delta() / 240.0));
}
void NetForm::scaleView(qreal scaleFactor)
{
qreal factor = transform().scale(scaleFactor, scaleFactor).mapRect(QRectF(0, 0, 1, 1)).width();
if (factor < 0.07 || factor > 100)
return;
scale(scaleFactor, scaleFactor);
}
void NetForm::updateIds()
{
std::vector<spnp::Place*> *places = this->netData.getPlaces();
int size = places->size();
int maxId = 0;
for(int i=0; i<size; ++i)
{
spnp::Place *p = places->at(i);
maxId = maxId > p->id ? maxId : p->id;
}
this->idPlace = maxId+1;
std::vector<spnp::Transition*> *transitions = this->netData.getTransitions();
size = transitions->size();
maxId = 0;
for(int i=0; i<size; ++i)
{
spnp::Transition* t = transitions->at(i);
maxId = maxId > t->id ? maxId : t->id;
}
this->idTransition = maxId+1;
std::vector<spnp::Arc*> *arcs = this->netData.getArcs();
size = arcs->size();
maxId = 0;
for(int i=0; i<size; ++i)
{
spnp::Arc* arc = arcs->at(i);
maxId = maxId > arc->id ? maxId : arc->id;
}
this->idArc = maxId+1;
}
int NetForm::getNextPlace()
{
return this->idPlace++;
}
int NetForm::getNextTransition()
{
return this->idTransition++;
}
int NetForm::getNextArc()
{
return this->idArc++;
}
| [
"el.iagows@gmail.com"
] | el.iagows@gmail.com |
598370c148fbd67678257e66a15755ce85479bab | d6596b106403fe2233fc1e20ac07e6805c7d4fd2 | /deps/v8/test/cctest/compiler/test-machine-operator-reducer.cc | 9a41bc5e449a7650c2ba39a5e79d60501f20d552 | [
"Zlib",
"ISC",
"MIT",
"LicenseRef-scancode-openssl",
"BSD-3-Clause",
"Apache-2.0",
"Artistic-2.0",
"NTP",
"LicenseRef-scancode-unknown-license-reference",
"bzip2-1.0.6"
] | permissive | zachlatta/node | 36b0bf6c4dc2f629ad2652c4438dc2b162ce00af | 50d36542880e3f54237c26aa8fc540770bb1072b | refs/heads/master | 2021-01-18T16:51:16.223419 | 2014-12-08T09:02:52 | 2014-12-08T09:03:52 | 27,706,253 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 23,076 | cc | // Copyright 2014 the V8 project 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 "test/cctest/cctest.h"
#include "src/base/utils/random-number-generator.h"
#include "src/compiler/graph-inl.h"
#include "src/compiler/js-graph.h"
#include "src/compiler/machine-operator-reducer.h"
#include "src/compiler/typer.h"
#include "test/cctest/compiler/value-helper.h"
using namespace v8::internal;
using namespace v8::internal::compiler;
template <typename T>
const Operator* NewConstantOperator(CommonOperatorBuilder* common,
volatile T value);
template <>
const Operator* NewConstantOperator<int32_t>(CommonOperatorBuilder* common,
volatile int32_t value) {
return common->Int32Constant(value);
}
template <>
const Operator* NewConstantOperator<double>(CommonOperatorBuilder* common,
volatile double value) {
return common->Float64Constant(value);
}
template <typename T>
T ValueOfOperator(const Operator* op);
template <>
int32_t ValueOfOperator<int32_t>(const Operator* op) {
CHECK_EQ(IrOpcode::kInt32Constant, op->opcode());
return OpParameter<int32_t>(op);
}
template <>
double ValueOfOperator<double>(const Operator* op) {
CHECK_EQ(IrOpcode::kFloat64Constant, op->opcode());
return OpParameter<double>(op);
}
class ReducerTester : public HandleAndZoneScope {
public:
explicit ReducerTester(int num_parameters = 0)
: isolate(main_isolate()),
binop(NULL),
unop(NULL),
common(main_zone()),
graph(main_zone()),
javascript(main_zone()),
typer(main_zone()),
jsgraph(&graph, &common, &javascript, &typer, &machine),
maxuint32(Constant<int32_t>(kMaxUInt32)) {
Node* s = graph.NewNode(common.Start(num_parameters));
graph.SetStart(s);
}
Isolate* isolate;
const Operator* binop;
const Operator* unop;
MachineOperatorBuilder machine;
CommonOperatorBuilder common;
Graph graph;
JSOperatorBuilder javascript;
Typer typer;
JSGraph jsgraph;
Node* maxuint32;
template <typename T>
Node* Constant(volatile T value) {
return graph.NewNode(NewConstantOperator<T>(&common, value));
}
template <typename T>
const T ValueOf(const Operator* op) {
return ValueOfOperator<T>(op);
}
// Check that the reduction of this binop applied to constants {a} and {b}
// yields the {expect} value.
template <typename T>
void CheckFoldBinop(volatile T expect, volatile T a, volatile T b) {
CheckFoldBinop<T>(expect, Constant<T>(a), Constant<T>(b));
}
// Check that the reduction of this binop applied to {a} and {b} yields
// the {expect} value.
template <typename T>
void CheckFoldBinop(volatile T expect, Node* a, Node* b) {
CHECK_NE(NULL, binop);
Node* n = graph.NewNode(binop, a, b);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(reduction.Changed());
CHECK_NE(n, reduction.replacement());
CHECK_EQ(expect, ValueOf<T>(reduction.replacement()->op()));
}
// Check that the reduction of this binop applied to {a} and {b} yields
// the {expect} node.
void CheckBinop(Node* expect, Node* a, Node* b) {
CHECK_NE(NULL, binop);
Node* n = graph.NewNode(binop, a, b);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(reduction.Changed());
CHECK_EQ(expect, reduction.replacement());
}
// Check that the reduction of this binop applied to {left} and {right} yields
// this binop applied to {left_expect} and {right_expect}.
void CheckFoldBinop(Node* left_expect, Node* right_expect, Node* left,
Node* right) {
CHECK_NE(NULL, binop);
Node* n = graph.NewNode(binop, left, right);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(reduction.Changed());
CHECK_EQ(binop, reduction.replacement()->op());
CHECK_EQ(left_expect, reduction.replacement()->InputAt(0));
CHECK_EQ(right_expect, reduction.replacement()->InputAt(1));
}
// Check that the reduction of this binop applied to {left} and {right} yields
// the {op_expect} applied to {left_expect} and {right_expect}.
template <typename T>
void CheckFoldBinop(volatile T left_expect, const Operator* op_expect,
Node* right_expect, Node* left, Node* right) {
CHECK_NE(NULL, binop);
Node* n = graph.NewNode(binop, left, right);
MachineOperatorReducer reducer(&jsgraph);
Reduction r = reducer.Reduce(n);
CHECK(r.Changed());
CHECK_EQ(op_expect->opcode(), r.replacement()->op()->opcode());
CHECK_EQ(left_expect, ValueOf<T>(r.replacement()->InputAt(0)->op()));
CHECK_EQ(right_expect, r.replacement()->InputAt(1));
}
// Check that the reduction of this binop applied to {left} and {right} yields
// the {op_expect} applied to {left_expect} and {right_expect}.
template <typename T>
void CheckFoldBinop(Node* left_expect, const Operator* op_expect,
volatile T right_expect, Node* left, Node* right) {
CHECK_NE(NULL, binop);
Node* n = graph.NewNode(binop, left, right);
MachineOperatorReducer reducer(&jsgraph);
Reduction r = reducer.Reduce(n);
CHECK(r.Changed());
CHECK_EQ(op_expect->opcode(), r.replacement()->op()->opcode());
CHECK_EQ(left_expect, r.replacement()->InputAt(0));
CHECK_EQ(right_expect, ValueOf<T>(r.replacement()->InputAt(1)->op()));
}
// Check that if the given constant appears on the left, the reducer will
// swap it to be on the right.
template <typename T>
void CheckPutConstantOnRight(volatile T constant) {
// TODO(titzer): CHECK(binop->HasProperty(Operator::kCommutative));
Node* p = Parameter();
Node* k = Constant<T>(constant);
{
Node* n = graph.NewNode(binop, k, p);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(!reduction.Changed() || reduction.replacement() == n);
CHECK_EQ(p, n->InputAt(0));
CHECK_EQ(k, n->InputAt(1));
}
{
Node* n = graph.NewNode(binop, p, k);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(!reduction.Changed());
CHECK_EQ(p, n->InputAt(0));
CHECK_EQ(k, n->InputAt(1));
}
}
// Check that if the given constant appears on the left, the reducer will
// *NOT* swap it to be on the right.
template <typename T>
void CheckDontPutConstantOnRight(volatile T constant) {
CHECK(!binop->HasProperty(Operator::kCommutative));
Node* p = Parameter();
Node* k = Constant<T>(constant);
Node* n = graph.NewNode(binop, k, p);
MachineOperatorReducer reducer(&jsgraph);
Reduction reduction = reducer.Reduce(n);
CHECK(!reduction.Changed());
CHECK_EQ(k, n->InputAt(0));
CHECK_EQ(p, n->InputAt(1));
}
Node* Parameter(int32_t index = 0) {
return graph.NewNode(common.Parameter(index), graph.start());
}
};
TEST(ReduceWord32And) {
ReducerTester R;
R.binop = R.machine.Word32And();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
int32_t x = *pl, y = *pr;
R.CheckFoldBinop<int32_t>(x & y, x, y);
}
}
R.CheckPutConstantOnRight(33);
R.CheckPutConstantOnRight(44000);
Node* x = R.Parameter();
Node* zero = R.Constant<int32_t>(0);
Node* minus_1 = R.Constant<int32_t>(-1);
R.CheckBinop(zero, x, zero); // x & 0 => 0
R.CheckBinop(zero, zero, x); // 0 & x => 0
R.CheckBinop(x, x, minus_1); // x & -1 => 0
R.CheckBinop(x, minus_1, x); // -1 & x => 0
R.CheckBinop(x, x, x); // x & x => x
}
TEST(ReduceWord32Or) {
ReducerTester R;
R.binop = R.machine.Word32Or();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
int32_t x = *pl, y = *pr;
R.CheckFoldBinop<int32_t>(x | y, x, y);
}
}
R.CheckPutConstantOnRight(36);
R.CheckPutConstantOnRight(44001);
Node* x = R.Parameter();
Node* zero = R.Constant<int32_t>(0);
Node* minus_1 = R.Constant<int32_t>(-1);
R.CheckBinop(x, x, zero); // x & 0 => x
R.CheckBinop(x, zero, x); // 0 & x => x
R.CheckBinop(minus_1, x, minus_1); // x & -1 => -1
R.CheckBinop(minus_1, minus_1, x); // -1 & x => -1
R.CheckBinop(x, x, x); // x & x => x
}
TEST(ReduceWord32Xor) {
ReducerTester R;
R.binop = R.machine.Word32Xor();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
int32_t x = *pl, y = *pr;
R.CheckFoldBinop<int32_t>(x ^ y, x, y);
}
}
R.CheckPutConstantOnRight(39);
R.CheckPutConstantOnRight(4403);
Node* x = R.Parameter();
Node* zero = R.Constant<int32_t>(0);
R.CheckBinop(x, x, zero); // x ^ 0 => x
R.CheckBinop(x, zero, x); // 0 ^ x => x
R.CheckFoldBinop<int32_t>(0, x, x); // x ^ x => 0
}
TEST(ReduceWord32Shl) {
ReducerTester R;
R.binop = R.machine.Word32Shl();
// TODO(titzer): out of range shifts
FOR_INT32_INPUTS(i) {
for (int y = 0; y < 32; y++) {
int32_t x = *i;
R.CheckFoldBinop<int32_t>(x << y, x, y);
}
}
R.CheckDontPutConstantOnRight(44);
Node* x = R.Parameter();
Node* zero = R.Constant<int32_t>(0);
R.CheckBinop(x, x, zero); // x << 0 => x
}
TEST(ReduceWord32Shr) {
ReducerTester R;
R.binop = R.machine.Word32Shr();
// TODO(titzer): test out of range shifts
FOR_UINT32_INPUTS(i) {
for (uint32_t y = 0; y < 32; y++) {
uint32_t x = *i;
R.CheckFoldBinop<int32_t>(x >> y, x, y);
}
}
R.CheckDontPutConstantOnRight(44);
Node* x = R.Parameter();
Node* zero = R.Constant<int32_t>(0);
R.CheckBinop(x, x, zero); // x >>> 0 => x
}
TEST(ReduceWord32Sar) {
ReducerTester R;
R.binop = R.machine.Word32Sar();
// TODO(titzer): test out of range shifts
FOR_INT32_INPUTS(i) {
for (int32_t y = 0; y < 32; y++) {
int32_t x = *i;
R.CheckFoldBinop<int32_t>(x >> y, x, y);
}
}
R.CheckDontPutConstantOnRight(44);
Node* x = R.Parameter();
Node* zero = R.Constant<int32_t>(0);
R.CheckBinop(x, x, zero); // x >> 0 => x
}
TEST(ReduceWord32Equal) {
ReducerTester R;
R.binop = R.machine.Word32Equal();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
int32_t x = *pl, y = *pr;
R.CheckFoldBinop<int32_t>(x == y ? 1 : 0, x, y);
}
}
R.CheckPutConstantOnRight(48);
R.CheckPutConstantOnRight(-48);
Node* x = R.Parameter(0);
Node* y = R.Parameter(1);
Node* zero = R.Constant<int32_t>(0);
Node* sub = R.graph.NewNode(R.machine.Int32Sub(), x, y);
R.CheckFoldBinop<int32_t>(1, x, x); // x == x => 1
R.CheckFoldBinop(x, y, sub, zero); // x - y == 0 => x == y
R.CheckFoldBinop(x, y, zero, sub); // 0 == x - y => x == y
}
TEST(ReduceInt32Add) {
ReducerTester R;
R.binop = R.machine.Int32Add();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
int32_t x = *pl, y = *pr;
R.CheckFoldBinop<int32_t>(x + y, x, y); // TODO(titzer): signed overflow
}
}
R.CheckPutConstantOnRight(41);
R.CheckPutConstantOnRight(4407);
Node* x = R.Parameter();
Node* zero = R.Constant<int32_t>(0);
R.CheckBinop(x, x, zero); // x + 0 => x
R.CheckBinop(x, zero, x); // 0 + x => x
}
TEST(ReduceInt32Sub) {
ReducerTester R;
R.binop = R.machine.Int32Sub();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
int32_t x = *pl, y = *pr;
R.CheckFoldBinop<int32_t>(x - y, x, y);
}
}
R.CheckDontPutConstantOnRight(412);
Node* x = R.Parameter();
Node* zero = R.Constant<int32_t>(0);
R.CheckBinop(x, x, zero); // x - 0 => x
}
TEST(ReduceInt32Mul) {
ReducerTester R;
R.binop = R.machine.Int32Mul();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
int32_t x = *pl, y = *pr;
R.CheckFoldBinop<int32_t>(x * y, x, y); // TODO(titzer): signed overflow
}
}
R.CheckPutConstantOnRight(4111);
R.CheckPutConstantOnRight(-4407);
Node* x = R.Parameter();
Node* zero = R.Constant<int32_t>(0);
Node* one = R.Constant<int32_t>(1);
Node* minus_one = R.Constant<int32_t>(-1);
R.CheckBinop(zero, x, zero); // x * 0 => 0
R.CheckBinop(zero, zero, x); // 0 * x => 0
R.CheckBinop(x, x, one); // x * 1 => x
R.CheckBinop(x, one, x); // 1 * x => x
R.CheckFoldBinop<int32_t>(0, R.machine.Int32Sub(), x, minus_one,
x); // -1 * x => 0 - x
R.CheckFoldBinop<int32_t>(0, R.machine.Int32Sub(), x, x,
minus_one); // x * -1 => 0 - x
for (int32_t n = 1; n < 31; ++n) {
Node* multiplier = R.Constant<int32_t>(1 << n);
R.CheckFoldBinop<int32_t>(x, R.machine.Word32Shl(), n, x,
multiplier); // x * 2^n => x << n
R.CheckFoldBinop<int32_t>(x, R.machine.Word32Shl(), n, multiplier,
x); // 2^n * x => x << n
}
}
TEST(ReduceInt32Div) {
ReducerTester R;
R.binop = R.machine.Int32Div();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
int32_t x = *pl, y = *pr;
if (y == 0) continue; // TODO(titzer): test / 0
int32_t r = y == -1 ? -x : x / y; // INT_MIN / -1 may explode in C
R.CheckFoldBinop<int32_t>(r, x, y);
}
}
R.CheckDontPutConstantOnRight(41111);
R.CheckDontPutConstantOnRight(-44071);
Node* x = R.Parameter();
Node* one = R.Constant<int32_t>(1);
Node* minus_one = R.Constant<int32_t>(-1);
R.CheckBinop(x, x, one); // x / 1 => x
// TODO(titzer): // 0 / x => 0 if x != 0
// TODO(titzer): // x / 2^n => x >> n and round
R.CheckFoldBinop<int32_t>(0, R.machine.Int32Sub(), x, x,
minus_one); // x / -1 => 0 - x
}
TEST(ReduceInt32UDiv) {
ReducerTester R;
R.binop = R.machine.Int32UDiv();
FOR_UINT32_INPUTS(pl) {
FOR_UINT32_INPUTS(pr) {
uint32_t x = *pl, y = *pr;
if (y == 0) continue; // TODO(titzer): test / 0
R.CheckFoldBinop<int32_t>(x / y, x, y);
}
}
R.CheckDontPutConstantOnRight(41311);
R.CheckDontPutConstantOnRight(-44371);
Node* x = R.Parameter();
Node* one = R.Constant<int32_t>(1);
R.CheckBinop(x, x, one); // x / 1 => x
// TODO(titzer): // 0 / x => 0 if x != 0
for (uint32_t n = 1; n < 32; ++n) {
Node* divisor = R.Constant<int32_t>(1u << n);
R.CheckFoldBinop<int32_t>(x, R.machine.Word32Shr(), n, x,
divisor); // x / 2^n => x >> n
}
}
TEST(ReduceInt32Mod) {
ReducerTester R;
R.binop = R.machine.Int32Mod();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
int32_t x = *pl, y = *pr;
if (y == 0) continue; // TODO(titzer): test % 0
int32_t r = y == -1 ? 0 : x % y; // INT_MIN % -1 may explode in C
R.CheckFoldBinop<int32_t>(r, x, y);
}
}
R.CheckDontPutConstantOnRight(413);
R.CheckDontPutConstantOnRight(-4401);
Node* x = R.Parameter();
Node* one = R.Constant<int32_t>(1);
R.CheckFoldBinop<int32_t>(0, x, one); // x % 1 => 0
// TODO(titzer): // x % 2^n => x & 2^n-1 and round
}
TEST(ReduceInt32UMod) {
ReducerTester R;
R.binop = R.machine.Int32UMod();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
uint32_t x = *pl, y = *pr;
if (y == 0) continue; // TODO(titzer): test x % 0
R.CheckFoldBinop<int32_t>(x % y, x, y);
}
}
R.CheckDontPutConstantOnRight(417);
R.CheckDontPutConstantOnRight(-4371);
Node* x = R.Parameter();
Node* one = R.Constant<int32_t>(1);
R.CheckFoldBinop<int32_t>(0, x, one); // x % 1 => 0
for (uint32_t n = 1; n < 32; ++n) {
Node* divisor = R.Constant<int32_t>(1u << n);
R.CheckFoldBinop<int32_t>(x, R.machine.Word32And(), (1u << n) - 1, x,
divisor); // x % 2^n => x & 2^n-1
}
}
TEST(ReduceInt32LessThan) {
ReducerTester R;
R.binop = R.machine.Int32LessThan();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
int32_t x = *pl, y = *pr;
R.CheckFoldBinop<int32_t>(x < y ? 1 : 0, x, y);
}
}
R.CheckDontPutConstantOnRight(41399);
R.CheckDontPutConstantOnRight(-440197);
Node* x = R.Parameter(0);
Node* y = R.Parameter(1);
Node* zero = R.Constant<int32_t>(0);
Node* sub = R.graph.NewNode(R.machine.Int32Sub(), x, y);
R.CheckFoldBinop<int32_t>(0, x, x); // x < x => 0
R.CheckFoldBinop(x, y, sub, zero); // x - y < 0 => x < y
R.CheckFoldBinop(y, x, zero, sub); // 0 < x - y => y < x
}
TEST(ReduceInt32LessThanOrEqual) {
ReducerTester R;
R.binop = R.machine.Int32LessThanOrEqual();
FOR_INT32_INPUTS(pl) {
FOR_INT32_INPUTS(pr) {
int32_t x = *pl, y = *pr;
R.CheckFoldBinop<int32_t>(x <= y ? 1 : 0, x, y);
}
}
FOR_INT32_INPUTS(i) { R.CheckDontPutConstantOnRight<int32_t>(*i); }
Node* x = R.Parameter(0);
Node* y = R.Parameter(1);
Node* zero = R.Constant<int32_t>(0);
Node* sub = R.graph.NewNode(R.machine.Int32Sub(), x, y);
R.CheckFoldBinop<int32_t>(1, x, x); // x <= x => 1
R.CheckFoldBinop(x, y, sub, zero); // x - y <= 0 => x <= y
R.CheckFoldBinop(y, x, zero, sub); // 0 <= x - y => y <= x
}
TEST(ReduceUint32LessThan) {
ReducerTester R;
R.binop = R.machine.Uint32LessThan();
FOR_UINT32_INPUTS(pl) {
FOR_UINT32_INPUTS(pr) {
uint32_t x = *pl, y = *pr;
R.CheckFoldBinop<int32_t>(x < y ? 1 : 0, x, y);
}
}
R.CheckDontPutConstantOnRight(41399);
R.CheckDontPutConstantOnRight(-440197);
Node* x = R.Parameter();
Node* max = R.maxuint32;
Node* zero = R.Constant<int32_t>(0);
R.CheckFoldBinop<int32_t>(0, max, x); // M < x => 0
R.CheckFoldBinop<int32_t>(0, x, zero); // x < 0 => 0
R.CheckFoldBinop<int32_t>(0, x, x); // x < x => 0
}
TEST(ReduceUint32LessThanOrEqual) {
ReducerTester R;
R.binop = R.machine.Uint32LessThanOrEqual();
FOR_UINT32_INPUTS(pl) {
FOR_UINT32_INPUTS(pr) {
uint32_t x = *pl, y = *pr;
R.CheckFoldBinop<int32_t>(x <= y ? 1 : 0, x, y);
}
}
R.CheckDontPutConstantOnRight(41399);
R.CheckDontPutConstantOnRight(-440197);
Node* x = R.Parameter();
Node* max = R.maxuint32;
Node* zero = R.Constant<int32_t>(0);
R.CheckFoldBinop<int32_t>(1, x, max); // x <= M => 1
R.CheckFoldBinop<int32_t>(1, zero, x); // 0 <= x => 1
R.CheckFoldBinop<int32_t>(1, x, x); // x <= x => 1
}
TEST(ReduceLoadStore) {
ReducerTester R;
Node* base = R.Constant<int32_t>(11);
Node* index = R.Constant<int32_t>(4);
Node* load = R.graph.NewNode(R.machine.Load(kMachInt32), base, index);
{
MachineOperatorReducer reducer(&R.jsgraph);
Reduction reduction = reducer.Reduce(load);
CHECK(!reduction.Changed()); // loads should not be reduced.
}
{
Node* store = R.graph.NewNode(
R.machine.Store(StoreRepresentation(kMachInt32, kNoWriteBarrier)), base,
index, load);
MachineOperatorReducer reducer(&R.jsgraph);
Reduction reduction = reducer.Reduce(store);
CHECK(!reduction.Changed()); // stores should not be reduced.
}
}
static void CheckNans(ReducerTester* R) {
Node* x = R->Parameter();
std::vector<double> nans = ValueHelper::nan_vector();
for (std::vector<double>::const_iterator pl = nans.begin(); pl != nans.end();
++pl) {
for (std::vector<double>::const_iterator pr = nans.begin();
pr != nans.end(); ++pr) {
Node* nan1 = R->Constant<double>(*pl);
Node* nan2 = R->Constant<double>(*pr);
R->CheckBinop(nan1, x, nan1); // x op NaN => NaN
R->CheckBinop(nan1, nan1, x); // NaN op x => NaN
R->CheckBinop(nan1, nan2, nan1); // NaN op NaN => NaN
}
}
}
TEST(ReduceFloat64Add) {
ReducerTester R;
R.binop = R.machine.Float64Add();
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
double x = *pl, y = *pr;
R.CheckFoldBinop<double>(x + y, x, y);
}
}
FOR_FLOAT64_INPUTS(i) {
Double tmp(*i);
if (!tmp.IsSpecial() || tmp.IsInfinite()) {
// Don't check NaNs as they are reduced more.
R.CheckPutConstantOnRight(*i);
}
}
CheckNans(&R);
}
TEST(ReduceFloat64Sub) {
ReducerTester R;
R.binop = R.machine.Float64Sub();
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
double x = *pl, y = *pr;
R.CheckFoldBinop<double>(x - y, x, y);
}
}
Node* zero = R.Constant<double>(0.0);
Node* x = R.Parameter();
R.CheckBinop(x, x, zero); // x - 0.0 => x
CheckNans(&R);
}
TEST(ReduceFloat64Mul) {
ReducerTester R;
R.binop = R.machine.Float64Mul();
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
double x = *pl, y = *pr;
R.CheckFoldBinop<double>(x * y, x, y);
}
}
double inf = V8_INFINITY;
R.CheckPutConstantOnRight(-inf);
R.CheckPutConstantOnRight(-0.1);
R.CheckPutConstantOnRight(0.1);
R.CheckPutConstantOnRight(inf);
Node* x = R.Parameter();
Node* one = R.Constant<double>(1.0);
R.CheckBinop(x, x, one); // x * 1.0 => x
R.CheckBinop(x, one, x); // 1.0 * x => x
CheckNans(&R);
}
TEST(ReduceFloat64Div) {
ReducerTester R;
R.binop = R.machine.Float64Div();
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
double x = *pl, y = *pr;
R.CheckFoldBinop<double>(x / y, x, y);
}
}
Node* x = R.Parameter();
Node* one = R.Constant<double>(1.0);
R.CheckBinop(x, x, one); // x / 1.0 => x
CheckNans(&R);
}
TEST(ReduceFloat64Mod) {
ReducerTester R;
R.binop = R.machine.Float64Mod();
FOR_FLOAT64_INPUTS(pl) {
FOR_FLOAT64_INPUTS(pr) {
double x = *pl, y = *pr;
R.CheckFoldBinop<double>(modulo(x, y), x, y);
}
}
Node* x = R.Parameter();
Node* zero = R.Constant<double>(0.0);
R.CheckFoldBinop<double>(v8::base::OS::nan_value(), x, zero);
CheckNans(&R);
}
// TODO(titzer): test MachineOperatorReducer for Word64And
// TODO(titzer): test MachineOperatorReducer for Word64Or
// TODO(titzer): test MachineOperatorReducer for Word64Xor
// TODO(titzer): test MachineOperatorReducer for Word64Shl
// TODO(titzer): test MachineOperatorReducer for Word64Shr
// TODO(titzer): test MachineOperatorReducer for Word64Sar
// TODO(titzer): test MachineOperatorReducer for Word64Equal
// TODO(titzer): test MachineOperatorReducer for Word64Not
// TODO(titzer): test MachineOperatorReducer for Int64Add
// TODO(titzer): test MachineOperatorReducer for Int64Sub
// TODO(titzer): test MachineOperatorReducer for Int64Mul
// TODO(titzer): test MachineOperatorReducer for Int64UMul
// TODO(titzer): test MachineOperatorReducer for Int64Div
// TODO(titzer): test MachineOperatorReducer for Int64UDiv
// TODO(titzer): test MachineOperatorReducer for Int64Mod
// TODO(titzer): test MachineOperatorReducer for Int64UMod
// TODO(titzer): test MachineOperatorReducer for Int64Neg
// TODO(titzer): test MachineOperatorReducer for ChangeInt32ToFloat64
// TODO(titzer): test MachineOperatorReducer for ChangeFloat64ToInt32
// TODO(titzer): test MachineOperatorReducer for Float64Compare
| [
"fedor@indutny.com"
] | fedor@indutny.com |
1342327b956da28ded288e50f1ac1694086c1a18 | c49ab45978054a8832463ea8e9aa1d23777a083a | /src/matrixutils.cpp | 50c5be152c268bb81b8c6bbd06e3095a7865b5c6 | [
"BSD-3-Clause"
] | permissive | quotekio/quotek-sdk | ae8fc6da496fd0452792f151e646eaf8e7b47aae | 87eeb2e4763879609042afb09aeafbb40c8c7975 | refs/heads/master | 2020-03-08T20:45:50.995266 | 2018-04-06T12:05:17 | 2018-04-06T12:05:17 | 40,011,457 | 7 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 483 | cpp | #include "matrixutils.hpp"
namespace quotek {
namespace core {
namespace utils {
void removeColumn(Eigen::MatrixXd& matrix, unsigned int colToRemove) {
unsigned int numRows = matrix.rows();
unsigned int numCols = matrix.cols()-1;
if( colToRemove < numCols )
matrix.block(0,colToRemove,numRows,numCols-colToRemove) = matrix.block(0,colToRemove+1,numRows,numCols-colToRemove);
matrix.conservativeResize(numRows,numCols);
}
}
}
} | [
"quotekio@gmail.com"
] | quotekio@gmail.com |
524017ae047a10c07edfd3af659ba4618b5df9b8 | 13ec1d019e1a87dbc7e31ac87cce7b7c43747e4e | /ccgeditor.cpp | 952dcdf9b886163edd85a9164321aa00bb79b2dc | [] | no_license | asdlei99/CCGEditor | dd8194ad5bb5b78941688bad3e030182b47d3971 | 1bf21024e6d7eaaed7699c2c77a6906791f71c59 | refs/heads/master | 2020-08-18T05:38:39.888543 | 2014-12-14T14:07:14 | 2014-12-14T14:07:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,248 | cpp | #include "ccgeditor.h"
#include "filebrowser.h"
#include "Classes/AppDelegate.h"
#include "Classes/QtPort/CCQGLView.h"
#include <QTimer>
#include <QDockWidget>
CCGEditor::CCGEditor(QWidget *parent)
: QMainWindow(parent),
_appDelegate(NULL),
_sceneWidget(NULL)
{
ui.setupUi(this);
setProjectWidget(new FileBrowser(this));
}
CCGEditor::~CCGEditor()
{
}
void CCGEditor::closeEvent(QCloseEvent *)
{
cocos2d::Director::getInstance()->end();
qApp->quit();
}
void CCGEditor::setSceneWidget(QWidget *widget)
{
_sceneWidget = widget;
if (_sceneWidget)
{
ui.SceneWidget->setWidget(_sceneWidget);
setCentralWidget(ui.SceneWidget);
}
}
void CCGEditor::setHierarchyWidget(QWidget *widget)
{
_hierarchyWidget = widget;
if (_hierarchyWidget)
{
ui.HierarchyWidget->setWidget(_hierarchyWidget);
}
}
void CCGEditor::setProjectWidget(QWidget *widget)
{
_projectWidget = widget;
if (_projectWidget)
{
_projectWidget->setWindowFlags(Qt::Widget);
ui.ProjectWidget->setWidget(_projectWidget);
}
}
void CCGEditor::setInspectorWidget(QWidget *widget)
{
_inspectorWidget = widget;
if (_inspectorWidget)
{
ui.InspectorWidget->setWidget(_inspectorWidget);
}
}
void CCGEditor::on_actionOpen_Project_triggered()
{
int i = 10;
}
| [
"gameboy12615@qq.com"
] | gameboy12615@qq.com |
5bac51e3e50d148f68fae6d6a2d33e4df684a4b6 | e9e6b3c667d61d112d27f80f12ac85bde8594d63 | /AnalgoKu6/DFS.cpp | a544fe4a41b669d49b63638c671b9b998fa37879 | [] | no_license | budiy12/AnalgoKu | 58373c01bf1e39d0a021d36c43538f242b968039 | 5b302b504408814fc9714952925e4006f39a6ac6 | refs/heads/master | 2021-03-26T15:24:18.298420 | 2020-04-14T02:52:47 | 2020-04-14T02:52:47 | 247,717,454 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,550 | cpp | #include <iostream>
#include <list>
using namespace std;
struct Graph {
int vertex;
list<int>* edge;
};
Graph G;
void makeGraph(Graph& G, int vertex)
{
G.vertex = vertex;
G.edge = new list<int>[vertex];
}
void addEdge(Graph& G, int i, int j)
{
G.edge[i].push_back(j);
}
void traversal(Graph G)
{
for (int i=0; i<G.vertex; ++i)
{
cout<<"\n vertex "<<i<<"\n head";
for (auto x : G.edge[i])
cout<<" -> "<<x;
cout<<endl;
}
}
void DFSUtil(int v, bool visited[])
{
visited[v] = true;
cout<<v<<" ";
for (list<int>::iterator i = G.edge[v].begin(); i != G.edge[v].end(); ++i)
if(!visited[*i])
DFSUtil(*i, visited);
}
void DFS(Graph G, int s)
{
bool *visited = new bool[G.vertex];
for (int i=0; i<G.vertex; i++)
visited[i] = false;
for (int i=0; i<G.vertex; i++)
if (visited[i] == false)
DFSUtil(i, visited);
}
int main()
{
makeGraph(G, 8);
addEdge(G, 0, 1);
addEdge(G, 0, 2);
addEdge(G, 1, 0);
addEdge(G, 1, 2);
addEdge(G, 1, 3);
addEdge(G, 1, 4);
addEdge(G, 2, 0);
addEdge(G, 2, 1);
addEdge(G, 2, 4);
addEdge(G, 2, 6);
addEdge(G, 2, 7);
addEdge(G, 3, 1);
addEdge(G, 3, 4);
addEdge(G, 4, 1);
addEdge(G, 4, 2);
addEdge(G, 4, 3);
addEdge(G, 4, 5);
addEdge(G, 5, 4);
addEdge(G, 6, 2);
addEdge(G, 6, 7);
addEdge(G, 7, 2);
addEdge(G, 7, 6);
cout<<"DFS starting from vertex 0\n";
DFS(G,0);
} | [
"waydub27@localhost.localdomain"
] | waydub27@localhost.localdomain |
ace9b2cf55fe9dfc12adaa8c5ea9cdefb09b28e5 | 9eaa193424d11688b36807aa2954f1c3cf1258e2 | /build/find-object/src/moc_ParametersToolBox.cpp | ac7004874e06fe937c526fc79f6ee0ed036afe56 | [] | no_license | robArmCN/kinectv2_ur5 | 4da76dc053143b7f42f1ae76d890b593024a1864 | 9748e7fffb0e9f27f8e2d66413f5a87c6719b907 | refs/heads/master | 2023-07-17T11:05:33.031118 | 2021-09-02T07:45:36 | 2021-09-02T07:45:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,653 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'ParametersToolBox.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.5.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../src/find-object/src/ParametersToolBox.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'ParametersToolBox.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.5.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_find_object__ParametersToolBox_t {
QByteArrayData data[8];
char stringdata0[108];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_find_object__ParametersToolBox_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_find_object__ParametersToolBox_t qt_meta_stringdata_find_object__ParametersToolBox = {
{
QT_MOC_LITERAL(0, 0, 30), // "find_object::ParametersToolBox"
QT_MOC_LITERAL(1, 31, 17), // "parametersChanged"
QT_MOC_LITERAL(2, 49, 0), // ""
QT_MOC_LITERAL(3, 50, 4), // "name"
QT_MOC_LITERAL(4, 55, 15), // "changeParameter"
QT_MOC_LITERAL(5, 71, 5), // "value"
QT_MOC_LITERAL(6, 77, 16), // "resetCurrentPage"
QT_MOC_LITERAL(7, 94, 13) // "resetAllPages"
},
"find_object::ParametersToolBox\0"
"parametersChanged\0\0name\0changeParameter\0"
"value\0resetCurrentPage\0resetAllPages"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_find_object__ParametersToolBox[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
7, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
1, // signalCount
// signals: name, argc, parameters, tag, flags
1, 1, 49, 2, 0x06 /* Public */,
// slots: name, argc, parameters, tag, flags
4, 0, 52, 2, 0x08 /* Private */,
4, 1, 53, 2, 0x08 /* Private */,
4, 1, 56, 2, 0x08 /* Private */,
4, 1, 59, 2, 0x08 /* Private */,
6, 0, 62, 2, 0x08 /* Private */,
7, 0, 63, 2, 0x08 /* Private */,
// signals: parameters
QMetaType::Void, QMetaType::QStringList, 3,
// slots: parameters
QMetaType::Void,
QMetaType::Void, QMetaType::QString, 5,
QMetaType::Void, QMetaType::Bool, 5,
QMetaType::Void, QMetaType::Int, 5,
QMetaType::Void,
QMetaType::Void,
0 // eod
};
void find_object::ParametersToolBox::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
ParametersToolBox *_t = static_cast<ParametersToolBox *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->parametersChanged((*reinterpret_cast< const QStringList(*)>(_a[1]))); break;
case 1: _t->changeParameter(); break;
case 2: _t->changeParameter((*reinterpret_cast< const QString(*)>(_a[1]))); break;
case 3: _t->changeParameter((*reinterpret_cast< bool(*)>(_a[1]))); break;
case 4: _t->changeParameter((*reinterpret_cast< int(*)>(_a[1]))); break;
case 5: _t->resetCurrentPage(); break;
case 6: _t->resetAllPages(); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
void **func = reinterpret_cast<void **>(_a[1]);
{
typedef void (ParametersToolBox::*_t)(const QStringList & );
if (*reinterpret_cast<_t *>(func) == static_cast<_t>(&ParametersToolBox::parametersChanged)) {
*result = 0;
}
}
}
}
const QMetaObject find_object::ParametersToolBox::staticMetaObject = {
{ &QToolBox::staticMetaObject, qt_meta_stringdata_find_object__ParametersToolBox.data,
qt_meta_data_find_object__ParametersToolBox, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};
const QMetaObject *find_object::ParametersToolBox::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *find_object::ParametersToolBox::qt_metacast(const char *_clname)
{
if (!_clname) return Q_NULLPTR;
if (!strcmp(_clname, qt_meta_stringdata_find_object__ParametersToolBox.stringdata0))
return static_cast<void*>(const_cast< ParametersToolBox*>(this));
return QToolBox::qt_metacast(_clname);
}
int find_object::ParametersToolBox::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QToolBox::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 7)
qt_static_metacall(this, _c, _id, _a);
_id -= 7;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 7)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 7;
}
return _id;
}
// SIGNAL 0
void find_object::ParametersToolBox::parametersChanged(const QStringList & _t1)
{
void *_a[] = { Q_NULLPTR, const_cast<void*>(reinterpret_cast<const void*>(&_t1)) };
QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
QT_END_MOC_NAMESPACE
| [
"462461328@qq.com"
] | 462461328@qq.com |
1bb94dca8a28a5c9442c5e276573c79912d3bd32 | 407dcc14e9f59a3cc5bf30a20b4156d866972455 | /soapy_source.cc | b427b8ea3fdeb03f93dd81bd32f2aa731d9d7340 | [
"BSD-2-Clause"
] | permissive | flightaware/dump978 | 8776b45fce054afa3ec72843125a714597815c22 | 53738a849751ab8d8dbbe39a1cf1d9daed134f7a | refs/heads/master | 2022-12-21T19:38:27.893960 | 2022-12-14T02:08:33 | 2022-12-14T02:08:33 | 171,495,285 | 37 | 18 | BSD-2-Clause | 2022-06-30T02:17:31 | 2019-02-19T15:09:42 | C++ | UTF-8 | C++ | false | false | 12,201 | cc | // Copyright (c) 2019, FlightAware LLC.
// All rights reserved.
// Licensed under the 2-clause BSD license; see the LICENSE file
#include "soapy_source.h"
#include "exception.h"
#include <iomanip>
#include <iostream>
#include <SoapySDR/Errors.hpp>
#include <SoapySDR/Formats.hpp>
#include <SoapySDR/Logger.hpp>
#include <SoapySDR/Version.hpp>
using namespace flightaware::uat;
std::atomic_bool SoapySampleSource::log_handler_registered_(false);
static void SoapyLogger(const SoapySDRLogLevel logLevel, const char *message) {
// clang-format off
static std::map<SoapySDRLogLevel, std::string> levels = {
{SOAPY_SDR_FATAL, "FATAL"},
{SOAPY_SDR_CRITICAL, "CRITICAL"},
{SOAPY_SDR_ERROR, "ERROR"},
{SOAPY_SDR_WARNING, "WARNING"},
{SOAPY_SDR_NOTICE, "NOTICE"},
{SOAPY_SDR_INFO, "INFO"},
{SOAPY_SDR_DEBUG, "DEBUG"},
{SOAPY_SDR_TRACE, "TRACE"},
{SOAPY_SDR_SSI, "SSI"}
};
// clang-format on
if (logLevel == SOAPY_SDR_SSI) {
// we don't care about this, and it's not masked by log level
return;
}
std::string level;
auto i = levels.find(logLevel);
if (i == levels.end())
level = "UNKNOWN";
else
level = i->second;
std::cerr << "SoapySDR: " << level << ": " << message << std::endl;
}
static std::string FormatToSoapy(SampleFormat format) {
// clang-format off
static const std::map<SampleFormat,std::string> lookup = {
{ SampleFormat::CU8, SOAPY_SDR_CU8 },
{ SampleFormat::CS8_, SOAPY_SDR_CS8 },
{ SampleFormat::CS16H, SOAPY_SDR_CS16 },
{ SampleFormat::CF32H, SOAPY_SDR_CF32 }
};
// clang-format on
auto i = lookup.find(format);
if (i != lookup.end()) {
return i->second;
} else {
return "";
}
}
static SampleFormat SoapyToFormat(std::string format) {
// clang-format off
static const std::map<std::string,SampleFormat> lookup = {
{ SOAPY_SDR_CU8, SampleFormat::CU8 },
{ SOAPY_SDR_CS8, SampleFormat::CS8_ },
{ SOAPY_SDR_CS16, SampleFormat::CS16H },
{ SOAPY_SDR_CF32, SampleFormat::CF32H }
};
// clang-format on
auto i = lookup.find(format);
if (i != lookup.end()) {
return i->second;
} else {
return SampleFormat::UNKNOWN;
}
}
#if defined(SOAPY_SDR_API_VERSION) && (SOAPY_SDR_API_VERSION >= 0x00060000)
static SoapySDR::Kwargs KwargsFromString(const std::string &markup) { return SoapySDR::KwargsFromString(markup); }
#else
// Compatibility shim
static std::string trim(std::string::const_iterator i1, std::string::const_iterator i2) {
auto begin = i1;
while (begin < i2 && std::isspace(*begin))
++begin;
auto end = i2;
while (begin < end && std::isspace(end[-1]))
--end;
return std::string(begin, end);
}
static SoapySDR::Kwargs KwargsFromString(const std::string &markup) {
SoapySDR::Kwargs kwargs;
auto scan = markup.begin();
while (scan < markup.end()) {
auto key_start = scan;
while (scan < markup.end() && *scan != '=' && *scan != ',') {
++scan;
}
std::string key = trim(key_start, scan);
if (scan == markup.end() || *scan == ',') {
++scan;
kwargs[key] = "";
} else {
++scan;
auto value_start = scan;
while (scan < markup.end() && *scan != ',') {
++scan;
}
std::string value = trim(value_start, scan);
++scan;
if (!key.empty()) {
kwargs[key] = value;
}
}
}
return kwargs;
}
#endif
class SoapySDRCategory : public boost::system::error_category {
public:
const char *name() const noexcept override { return "soapysdr"; }
std::string message(int ev) const override { return SoapySDR::errToStr(ev); }
};
static SoapySDRCategory soapysdr_category;
SoapySampleSource::SoapySampleSource(boost::asio::io_service &service, const std::string &device_name, const boost::program_options::variables_map &options) : timer_(service), device_name_(device_name), options_(options) {
if (!log_handler_registered_.exchange(true)) {
SoapySDR::registerLogHandler(SoapyLogger);
SoapySDR::setLogLevel(SOAPY_SDR_NOTICE);
}
}
SoapySampleSource::~SoapySampleSource() { Stop(); }
void SoapySampleSource::Init() {
try {
void (*unmake)(SoapySDR::Device *) = &SoapySDR::Device::unmake; // select the right overload
device_ = {SoapySDR::Device::make(device_name_), unmake};
} catch (const std::runtime_error &err) {
throw config_error(std::string("No matching SoapySDR device found (cause: ") + err.what() + ")");
}
if (!device_) {
throw config_error("No matching SoapySDR device found");
}
// hacky mchackerson
device_->setSampleRate(SOAPY_SDR_RX, 0, 2083333.0);
device_->setFrequency(SOAPY_SDR_RX, 0, 978000000);
device_->setBandwidth(SOAPY_SDR_RX, 0, 3.0e6);
if (options_.count("sdr-auto-gain")) {
if (!device_->hasGainMode(SOAPY_SDR_RX, 0)) {
throw config_error("Device does not support automatic gain mode");
}
std::cerr << "SoapySDR: using automatic gain" << std::endl;
device_->setGainMode(SOAPY_SDR_RX, 0, true);
} else if (options_.count("sdr-gain")) {
auto gain = options_["sdr-gain"].as<double>();
std::cerr << "SoapySDR: using manual gain " << std::fixed << std::setprecision(1) << gain << " dB" << std::endl;
device_->setGainMode(SOAPY_SDR_RX, 0, false);
device_->setGain(SOAPY_SDR_RX, 0, gain);
} else {
auto range = device_->getGainRange(SOAPY_SDR_RX, 0);
std::cerr << "SoapySDR: using maximum manual gain " << std::fixed << std::setprecision(1) << range.maximum() << " dB" << std::endl;
device_->setGainMode(SOAPY_SDR_RX, 0, false);
device_->setGain(SOAPY_SDR_RX, 0, range.maximum());
}
if (options_.count("sdr-ppm")) {
auto ppm = options_["sdr-ppm"].as<double>();
if (ppm != 0) {
#ifdef SOAPY_SDR_API_HAS_FREQUENCY_CORRECTION_API
if (device_->hasFrequencyCorrection(SOAPY_SDR_RX, 0) && ppm != 0) {
std::cerr << "SoapySDR: using frequency correction " << std::fixed << std::setprecision(1) << ppm << " ppm" << std::endl;
device_->setFrequencyCorrection(SOAPY_SDR_RX, 0, ppm);
} else {
std::cerr << "SoapySDR: device does not support frequency correction, --sdr-ppm option ignored" << std::endl;
}
#else
std::cerr << "SoapySDR: library version does not support frequency correction, --sdr-ppm option ignored" << std::endl;
#endif
}
}
if (options_.count("sdr-antenna")) {
auto antenna = options_["sdr-antenna"].as<std::string>();
std::cerr << "SoapySDR: using antenna " << antenna << std::endl;
device_->setAntenna(SOAPY_SDR_RX, 0, antenna);
}
if (options_.count("sdr-device-settings")) {
for (auto kv : KwargsFromString(options_["sdr-device-settings"].as<std::string>())) {
std::cerr << "SoapySDR: using device setting " << kv.first << "=" << kv.second << std::endl;
device_->writeSetting(kv.first, kv.second);
}
}
if (options_.count("format")) {
format_ = options_["format"].as<SampleFormat>();
}
std::string soapy_format;
if (format_ == SampleFormat::UNKNOWN) {
double fullScale;
soapy_format = device_->getNativeStreamFormat(SOAPY_SDR_RX, 0, fullScale);
format_ = SoapyToFormat(soapy_format);
if (format_ == SampleFormat::UNKNOWN) {
throw config_error("Unsupported native SDR format: " + soapy_format + "; try specifying --format");
}
} else {
soapy_format = FormatToSoapy(format_);
if (soapy_format.empty()) {
throw config_error("Unsupported sample format");
}
}
std::vector<size_t> channels = {0};
SoapySDR::Kwargs stream_settings;
if (device_->getDriverKey() == "RTLSDR") {
// some soapysdr builds have a very low default here
stream_settings["buffsize"] = "262144";
}
if (options_.count("sdr-stream-settings")) {
for (auto kv : KwargsFromString(options_["sdr-stream-settings"].as<std::string>())) {
stream_settings[kv.first] = kv.second;
}
}
for (auto &kv : stream_settings) {
std::cerr << "SoapySDR: using stream setting " << kv.first << "=" << kv.second << std::endl;
}
try {
stream_ = {device_->setupStream(SOAPY_SDR_RX, soapy_format, channels, stream_settings), std::bind(&SoapySDR::Device::closeStream, device_, std::placeholders::_1)};
} catch (const std::runtime_error &err) {
throw config_error(std::string("Failed to construct soapysdr stream (cause: ") + err.what() + ")");
}
if (!stream_) {
throw config_error("Failed to construct soapysdr stream");
}
}
void SoapySampleSource::Start() {
if (!device_ || !stream_) {
Init();
}
device_->activateStream(stream_.get());
halt_ = false;
rx_thread_.reset(new std::thread(&SoapySampleSource::Run, this));
Keepalive();
}
void SoapySampleSource::Keepalive() {
if (rx_thread_ && rx_thread_->joinable()) {
// Keep the io_service alive while the rx_thread is active
auto self(shared_from_this());
timer_.expires_from_now(std::chrono::milliseconds(1000));
timer_.async_wait([self, this](const boost::system::error_code &ec) {
if (!ec) {
Keepalive();
}
});
}
}
void SoapySampleSource::Stop() {
if (stream_) {
// rtlsdr needs the rx thread to drain data before this returns..
device_->deactivateStream(stream_.get());
}
if (rx_thread_) {
halt_ = true;
rx_thread_->join();
rx_thread_.reset();
}
if (stream_) {
stream_.reset();
}
if (device_) {
device_.reset();
}
}
void SoapySampleSource::Run() {
const auto bytes_per_element = BytesPerSample(format_);
const auto elements = std::max<size_t>(65536, device_->getStreamMTU(stream_.get()));
Bytes block;
block.reserve(elements * bytes_per_element);
const auto overflow_report_interval = std::chrono::milliseconds(15000);
auto last_overflow_report = std::chrono::steady_clock::now();
unsigned overflow_count = 0;
while (!halt_) {
void *buffs[1] = {block.data()};
int flags = 0;
long long time_ns;
block.resize(elements * bytes_per_element);
auto elements_read = device_->readStream(stream_.get(), buffs, elements, flags, time_ns,
/* timeout, microseconds */ 5000000);
if (halt_) {
break;
}
if (elements_read < 0) {
if (elements_read == SOAPY_SDR_OVERFLOW) {
++overflow_count;
} else {
DispatchError(boost::system::error_code{elements_read, soapysdr_category});
break;
}
}
if (overflow_count > 0) {
auto now = std::chrono::steady_clock::now();
if (now - last_overflow_report > overflow_report_interval) {
std::cerr << "SoapySDR: " << overflow_count << " recent input overruns (sample data dropped)" << std::endl;
last_overflow_report = now;
overflow_count = 0;
}
}
if (elements_read <= 0) {
continue;
}
block.resize(elements_read * bytes_per_element);
// work out a starting timestamp
static auto unix_epoch = std::chrono::system_clock::from_time_t(0);
auto end_of_block = std::chrono::system_clock::now();
auto start_of_block = end_of_block - (std::chrono::milliseconds(1000) * elements / 2083333);
std::uint64_t timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(start_of_block - unix_epoch).count();
DispatchBuffer(timestamp, block);
}
}
| [
"oliver@mutability.co.uk"
] | oliver@mutability.co.uk |
86bd433c55629ae5538a783539eeb59df64c3717 | d7d0fe6a0fae0e4e276dde963143b321e6b3eb90 | /HiyokoQuest/HiyokoQuest/MyLibrary/GameMaster/Character/Stair/Stair.hpp | 338c43de199f5284680f772c3bacd2bbfa9e6c28 | [] | no_license | Lambda1/HiyokoQuest | ca177a26f01c39ba98a59d72405d5435b158cda8 | 8de3c302a3c625d35fdf4d6a2d0b8b67cee6aef4 | refs/heads/master | 2020-08-02T18:01:12.501610 | 2019-11-10T07:49:11 | 2019-11-10T07:49:11 | 211,456,409 | 1 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 378 | hpp | #ifndef __STAIR_HPP__
#define __STAIR_HPP__
#include "../Character.hpp"
class Stair : public Character
{
public:
Stair();
~Stair();
void Move(DIRECTION direct) override;
void Teleport(const POS_TYPE x, const POS_TYPE y) override;
void Update() override;
inline int GiveEXP() override { return exp; } /* 階段は倒されないので, 呼び出さない */
};
#endif | [
"breakthrough.dodorara@gmail.com"
] | breakthrough.dodorara@gmail.com |
d32502e86a1c1df770fbff0c8d967fc61f19aa81 | 6c0ccd3e2857cd5fd2941d6335ad77c8946d3a68 | /Engine/source/lighting/advanced/advancedLightBufferConditioner.cpp | 5dff21fb46bbd13f5fe05eb05a6d01dd2f2835ac | [
"MIT"
] | permissive | LuisAntonRebollo/Torque3D | 78dcca3f8b560df065725a099dee8640c2ef3e2d | c29842e8a780ddb1a47edb671f528d7c9177ffc0 | refs/heads/dev_linux_opengl | 2021-01-16T23:01:42.022171 | 2014-02-18T02:19:46 | 2014-02-18T02:19:46 | 5,912,926 | 3 | 0 | null | 2017-01-05T18:11:24 | 2012-09-22T12:36:42 | C++ | UTF-8 | C++ | false | false | 7,837 | cpp | //-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// 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.
//-----------------------------------------------------------------------------
#include "platform/platform.h"
#include "lighting/advanced/advancedLightBufferConditioner.h"
#include "shaderGen/shaderOp.h"
#include "gfx/gfxDevice.h"
#include "core/util/safeDelete.h"
AdvancedLightBufferConditioner::~AdvancedLightBufferConditioner()
{
}
Var *AdvancedLightBufferConditioner::_conditionOutput( Var *unconditionedOutput, MultiLine *meta )
{
Var *conditionedOutput = new Var;
if(GFX->getAdapterType() == OpenGL)
conditionedOutput->setType("vec4");
else
conditionedOutput->setType("float4");
DecOp *outputDecl = new DecOp(conditionedOutput);
if(mColorFormat == RGB)
{
conditionedOutput->setName("rgbLightInfoOut");
// If this is a 16 bit integer format, scale up/down the values. All other
// formats just write out the full 0..1
if(getBufferFormat() == GFXFormatR16G16B16A16)
meta->addStatement( new GenOp( " @ = max(4.0, (float4(lightColor, specular) * NL_att + float4(bufferSample.rgb, 0.0)) / 4.0);\r\n", outputDecl ) );
else
meta->addStatement( new GenOp( " @ = float4(lightColor, 0) * NL_att + float4(bufferSample.rgb, specular);\r\n", outputDecl ) );
}
else
{
// Input u'v' assumed to be scaled
conditionedOutput->setName("luvLightInfoOut");
meta->addStatement( new GenOp( " @ = float4( lerp(bufferSample.xy, lightColor.xy, saturate(NL_att / bufferSample.z) * 0.5),\r\n", outputDecl ) );
meta->addStatement( new GenOp( " bufferSample.z + NL_att, bufferSample.w + saturate(specular * NL_att) );\r\n" ) );
}
return conditionedOutput;
}
Var *AdvancedLightBufferConditioner::_unconditionInput( Var *conditionedInput, MultiLine *meta )
{
if(mColorFormat == RGB)
{
if(getBufferFormat() == GFXFormatR16G16B16A16)
meta->addStatement( new GenOp( " lightColor = @.rgb * 4.0;\r\n", conditionedInput ) );
else
meta->addStatement( new GenOp( " lightColor = @.rgb;\r\n", conditionedInput ) );
meta->addStatement( new GenOp( " NL_att = dot(@.rgb, float3(0.3576, 0.7152, 0.1192));\r\n", conditionedInput ) );
}
else
{
meta->addStatement( new GenOp( " // TODO: This clamps HDR values.\r\n" ) );
meta->addStatement( new GenOp( " NL_att = @.b;\r\n", conditionedInput ) );
meta->addStatement( new GenOp( " lightColor = DecodeLuv(float3(saturate(NL_att), @.rg * 0.62));\r\n", conditionedInput ) );
}
meta->addStatement( new GenOp( " specular = @.a;\r\n", conditionedInput ) );
return NULL;
}
Var *AdvancedLightBufferConditioner::printMethodHeader( MethodType methodType, const String &methodName, Stream &stream, MultiLine *meta )
{
Var *methodVar = new Var;
methodVar->setName(methodName);
DecOp *methodDecl = new DecOp(methodVar);
Var *lightColor = new Var;
lightColor->setName("lightColor");
DecOp *lightColorDecl = new DecOp(lightColor);
Var *NLAtt = new Var;
NLAtt->setName("NL_att");
DecOp *NLAttDecl = new DecOp(NLAtt);
Var *specular = new Var;
specular->setName("specular");
DecOp *specularDecl = new DecOp(specular);
Var *bufferSample = new Var;
bufferSample->setName("bufferSample");
DecOp *bufferSampleDecl = new DecOp(bufferSample);
const bool isCondition = ( methodType == ConditionerFeature::ConditionMethod );
if(GFX->getAdapterType() == OpenGL)
{
methodVar->setType(avar("%s", isCondition ? "vec4" : "void"));
lightColor->setType(avar("%s vec3", isCondition ? "in" : "out"));
NLAtt->setType(avar("%s float", isCondition ? "in" : "out"));
specular->setType(avar("%s float", isCondition ? "in" : "out"));
bufferSample->setType("in vec4");
}
else
{
methodVar->setType(avar("inline %s", isCondition ? "float4" : "void"));
lightColor->setType(avar("%s float3", isCondition ? "in" : "out"));
NLAtt->setType(avar("%s float", isCondition ? "in" : "out"));
specular->setType(avar("%s float", isCondition ? "in" : "out"));
bufferSample->setType("in float4");
}
// If this is LUV, print methods to convert RGB<->LUV as needed
if(mColorFormat == LUV)
{
if(!isCondition)
{
meta->addStatement( new GenOp( "float3 DecodeLuv(float3 Luv)\r\n{\r\n" ) );
meta->addStatement( new GenOp( " float2 xy = float2(9.0f, 4.0f) * Luv.yz / (dot(Luv.yz, float2(6.0f, -16.0f)) + 12.0f);\r\n" ) );
meta->addStatement( new GenOp( " float Ld = Luv.x;\r\n" ) );
meta->addStatement( new GenOp( " float3 XYZ = float3(xy.x, Ld, 1.0f - xy.x - xy.y);\r\n" ) );
meta->addStatement( new GenOp( " XYZ.xz = XYZ.xz * Ld / xy.y;\r\n" ) );
meta->addStatement( new GenOp( " const float3x3 XYZ2RGB =\r\n" ) );
meta->addStatement( new GenOp( " {\r\n" ) );
meta->addStatement( new GenOp( " 2.5651f, -1.1665f, -0.3986f,\r\n" ) );
meta->addStatement( new GenOp( " -1.0217f, 1.9777f, 0.0439f,\r\n" ) );
meta->addStatement( new GenOp( " 0.0753f, -0.2543f, 1.1892f\r\n" ) );
meta->addStatement( new GenOp( " };\r\n" ) );
meta->addStatement( new GenOp( " return mul(XYZ2RGB, XYZ);\r\n" ) );
meta->addStatement( new GenOp( "}\r\n\r\n" ) );
}
else
{
// Shouldn't need this
}
}
// Method header and opening bracket
if(isCondition)
{
// All parameters are input parameters, and the return value is float4.
// If this is an LUV buffer format, than the previous pixel value is needed
// for interpolation.
meta->addStatement( new GenOp( "@(@, @, @, @)\r\n", methodDecl, lightColorDecl, NLAttDecl, specularDecl, bufferSampleDecl ) );
}
else
{
// Sample as input, parameters as output. Void return.
meta->addStatement( new GenOp( "@(@, @, @, @)\r\n", methodDecl, bufferSampleDecl, lightColorDecl, NLAttDecl, specularDecl ) );
}
meta->addStatement( new GenOp( "{\r\n" ) );
// We don't use this way of passing var's around, so this should cause a crash
// if something uses this improperly
return ( isCondition ? NULL : bufferSample );
}
void AdvancedLightBufferConditioner::printMethodFooter( ConditionerFeature::MethodType methodType, Var *retVar, Stream &stream, MultiLine *meta )
{
// Return and closing bracket
if(methodType == ConditionerFeature::ConditionMethod)
meta->addStatement( new GenOp( "\r\n return @;\r\n", retVar ) );
// Uncondition will assign output parameters
meta->addStatement( new GenOp( "}\r\n" ) );
} | [
"davew@garagegames.com"
] | davew@garagegames.com |
edd82423d6b72bdc60a8c7e3cf6064b2db094884 | dd28694304246d09f40c1dadfda69ef790149dca | /allocator/my_construct.h | ab130eced2d63841af3de61408244cb3112e67b4 | [] | no_license | MarcusMogg/STLLearn | 442db10b4edd37a1d3c8823cb311f019c50c458a | e189a3534271f353f46d9ea0b4e80caf4b2b70b7 | refs/heads/master | 2023-01-02T09:35:47.063611 | 2020-10-25T08:59:29 | 2020-10-25T08:59:29 | 305,287,934 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,169 | h | #pragma once
#ifndef _MOG_CONSTRUCT_H_
#define _MOG_CONSTRUCT_H_
#include <new> // for placement new
namespace MOG
{
// construct 就是placement new的简单封装
template <class T1, class T2>
inline void _Construct(T1 *p1, const T2 &p2)
{
new (static_cast<void *>(p1)) T1(p2);
}
template <class T1>
inline void _Construct(T1 *p1)
{
new (static_cast<void *>(p1)) T1();
}
template <class T1, class T2>
inline void construct(T1 *p, const T2 &value)
{
_Construct(p, value);
}
template <class T1>
inline void construct(T1 *p)
{
_Construct(p);
}
// destroy的优化没写，type traits在后面
template <class T1>
inline void _Destroy(T1 *p)
{
p->~T1(); //显示调用析构函数
}
template <class T1>
inline void destroy(T1 *p)
{
_Destroy(p);
}
template <class ForwardIterator>
inline void _Destroy(ForwardIterator first, ForwardIterator last)
{
for (; first != last; ++first)
{
destroy(&(*first));
}
}
template <class ForwardIterator>
inline void destroy(ForwardIterator first, ForwardIterator last)
{
_Destroy(first, last);
}
} // namespace MOG
#endif
| [
"m1664907189@gmail.com"
] | m1664907189@gmail.com |
992ee4b0367bd54dada7fda8cf2eef264881f358 | 9b55a3f9fa33644aa1b42e99dee1e0c714af29ed | /include/palleon/ios/IosResourceManager.h | 88d587c79b3d089cf0a7018a3a6d8d44afe1c7a9 | [
"BSD-2-Clause"
] | permissive | jpd002/Palleon | 56597af91e7878a3311b0cc08d556a6e348d9d4e | ddcd68d0a0b572a820066a74c19d36633dbb0245 | refs/heads/master | 2021-04-09T17:40:42.634899 | 2016-11-27T21:58:18 | 2016-11-27T21:58:18 | 18,983,388 | 2 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 489 | h | #pragma once
#include "palleon/resources/ResourceManager.h"
namespace Palleon
{
class CIosResourceManager : public CResourceManager
{
public:
static void CreateInstance();
static void DestroyInstance();
virtual std::string MakeResourcePath(const std::string&) const override;
virtual StreamPtr MakeResourceStream(const std::string&) const override;
protected:
CIosResourceManager();
virtual ~CIosResourceManager();
};
}
| [
"jpd002@e658db38-2ae6-4b1c-8a17-0a8554443f32"
] | jpd002@e658db38-2ae6-4b1c-8a17-0a8554443f32 |
618b39e2f526e2e08f492ee0fd61ecc5a243c94c | d4a210e6850476c2b6e1cb0c152d4c26dd86ec32 | /IPZ-HMI/StateStack.hpp | a81fafb8ce19500396cd9036775ca338e57dbd84 | [] | no_license | mickes27/IPZ-HMI | 5a2372bce57a971aa3c8ce92dc5782a7b3915d75 | a89a6bf571dc11a5e8e6757b00c83186a51f9788 | refs/heads/master | 2020-03-18T07:12:22.519519 | 2018-06-18T09:55:13 | 2018-06-18T09:55:13 | 134,438,851 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,425 | hpp | #ifndef BOOK_STATESTACK_HPP
#define BOOK_STATESTACK_HPP
#include "State.hpp"
#include "StateIdentifiers.hpp"
#include "ResourceIdentifiers.hpp"
#include <SFML/System/NonCopyable.hpp>
#include <SFML/System/Time.hpp>
#include <vector>
#include <utility>
#include <functional>
#include <map>
namespace sf
{
class Event;
class RenderWindow;
}
class StateStack : private sf::NonCopyable
{
public:
enum Action
{
Push,
Pop,
Clear,
};
public:
explicit StateStack(State::Context context);
template <typename T>
void registerState(States::ID stateID);
void update(sf::Time dt);
void draw();
void handleEvent(const sf::Event& event);
void pushState(States::ID stateID);
void popState();
void clearStates();
bool isEmpty() const;
private:
State::Ptr createState(States::ID stateID);
void applyPendingChanges();
private:
struct PendingChange
{
explicit PendingChange(Action action, States::ID stateID = States::None);
Action action;
States::ID stateID;
};
private:
std::vector<State::Ptr> mStack;
std::vector<PendingChange> mPendingList;
State::Context mContext;
std::map<States::ID, std::function<State::Ptr()>> mFactories;
};
template <typename T>
void StateStack::registerState(States::ID stateID)
{
mFactories[stateID] = [this]()
{
return State::Ptr(new T(*this, mContext));
};
}
#endif // BOOK_STATESTACK_HPP
| [
"michal.zawislak@interia.pl"
] | michal.zawislak@interia.pl |
3969177bbbf8524d8717720a779f78abe8f39308 | 105e721a388111dc4c9343b805b52d881f1e2b6b | /export/release/windows/obj/src/resources/__res_56.cpp | 7f602c957352caef9185fc3aa0fe950808382ac7 | [] | no_license | SuperSpinDashGamer39/lololololololololo-very-hard | b198f7e9c135ec9e9fbe01d193861aebc26825ad | 37c5a3d7bf27ba3a2fbaa0d3180f7163f9a15e35 | refs/heads/main | 2023-08-20T16:21:12.832634 | 2021-10-10T02:19:53 | 2021-10-10T02:19:53 | 415,465,253 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | true | 794 | cpp | // Generated by Haxe 4.1.5
namespace hx {
unsigned char __res_56[] = {
0x80, 0x00, 0x00, 0x80,
137,80,78,71,13,10,26,10,0,0,
0,13,73,72,68,82,0,0,0,11,
0,0,0,11,8,6,0,0,0,169,
172,119,38,0,0,0,4,115,66,73,
84,8,8,8,8,124,8,100,136,0,
0,0,9,112,72,89,115,0,0,11,
18,0,0,11,18,1,210,221,126,252,
0,0,0,22,116,69,88,116,67,114,
101,97,116,105,111,110,32,84,105,109,
101,0,48,53,47,50,57,47,49,54,
187,85,64,89,0,0,0,28,116,69,
88,116,83,111,102,116,119,97,114,101,
0,65,100,111,98,101,32,70,105,114,
101,119,111,114,107,115,32,67,83,54,
232,188,178,140,0,0,0,46,73,68,
65,84,24,149,99,252,255,255,63,3,
22,240,159,129,129,129,17,93,144,9,
155,74,92,96,144,40,102,97,128,120,
6,27,192,16,103,97,192,226,107,134,
97,20,26,0,119,186,7,22,122,155,
230,145,0,0,0,0,73,69,78,68,
174,66,96,130,0x00 };
}
| [
"81721123+SuperSpinDashGamer39@users.noreply.github.com"
] | 81721123+SuperSpinDashGamer39@users.noreply.github.com |
db56ac73c05860bc7a0bddfb5c95e7946961b90e | 18a5a57ee0682fce5ddc07b259ee313806f14b25 | /src/qt/coincontroldialog.cpp | dcb508666073e2bfc2313db74cb9459e8e27b451 | [
"MIT"
] | permissive | 375187588/brixcoin6.0 | f83f6b378b1e2acf04d048bbd74f8369d52d5a6e | fea63b5edaa67e4a71338973ba7dd341993ea078 | refs/heads/master | 2023-03-18T04:47:56.122821 | 2018-12-11T06:08:28 | 2018-12-11T06:08:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 34,399 | cpp | // Copyright (c) 2011-2015 The Bitcoin Core developers
// Copyright (c) 2014-2017 The Brixcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "coincontroldialog.h"
#include "ui_coincontroldialog.h"
#include "addresstablemodel.h"
#include "bitcoinunits.h"
#include "guiutil.h"
#include "optionsmodel.h"
#include "platformstyle.h"
#include "txmempool.h"
#include "walletmodel.h"
#include "wallet/coincontrol.h"
#include "init.h"
#include "policy/policy.h"
#include "validation.h" // For mempool
#include "wallet/wallet.h"
#include "instantx.h"
#include "privatesend-client.h"
#include <boost/assign/list_of.hpp> // for 'map_list_of()'
#include <QApplication>
#include <QCheckBox>
#include <QCursor>
#include <QDialogButtonBox>
#include <QFlags>
#include <QIcon>
#include <QSettings>
#include <QString>
#include <QTreeWidget>
#include <QTreeWidgetItem>
QList<CAmount> CoinControlDialog::payAmounts;
CCoinControl* CoinControlDialog::coinControl = new CCoinControl();
bool CoinControlDialog::fSubtractFeeFromAmount = false;
bool CCoinControlWidgetItem::operator<(const QTreeWidgetItem &other) const {
int column = treeWidget()->sortColumn();
if (column == CoinControlDialog::COLUMN_AMOUNT || column == CoinControlDialog::COLUMN_DATE || column == CoinControlDialog::COLUMN_CONFIRMATIONS || column == CoinControlDialog::COLUMN_PRIVATESEND_ROUNDS)
return data(column, Qt::UserRole).toLongLong() < other.data(column, Qt::UserRole).toLongLong();
return QTreeWidgetItem::operator<(other);
}
CoinControlDialog::CoinControlDialog(const PlatformStyle *_platformStyle, QWidget *parent) :
QDialog(parent),
ui(new Ui::CoinControlDialog),
model(0),
platformStyle(_platformStyle)
{
ui->setupUi(this);
/* Open CSS when configured */
this->setStyleSheet(GUIUtil::loadStyleSheet());
// context menu actions
QAction *copyAddressAction = new QAction(tr("Copy address"), this);
QAction *copyLabelAction = new QAction(tr("Copy label"), this);
QAction *copyAmountAction = new QAction(tr("Copy amount"), this);
copyTransactionHashAction = new QAction(tr("Copy transaction ID"), this); // we need to enable/disable this
lockAction = new QAction(tr("Lock unspent"), this); // we need to enable/disable this
unlockAction = new QAction(tr("Unlock unspent"), this); // we need to enable/disable this
// context menu
contextMenu = new QMenu(this);
contextMenu->addAction(copyAddressAction);
contextMenu->addAction(copyLabelAction);
contextMenu->addAction(copyAmountAction);
contextMenu->addAction(copyTransactionHashAction);
contextMenu->addSeparator();
contextMenu->addAction(lockAction);
contextMenu->addAction(unlockAction);
// context menu signals
connect(ui->treeWidget, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(showMenu(QPoint)));
connect(copyAddressAction, SIGNAL(triggered()), this, SLOT(copyAddress()));
connect(copyLabelAction, SIGNAL(triggered()), this, SLOT(copyLabel()));
connect(copyAmountAction, SIGNAL(triggered()), this, SLOT(copyAmount()));
connect(copyTransactionHashAction, SIGNAL(triggered()), this, SLOT(copyTransactionHash()));
connect(lockAction, SIGNAL(triggered()), this, SLOT(lockCoin()));
connect(unlockAction, SIGNAL(triggered()), this, SLOT(unlockCoin()));
// 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 *clipboardLowOutputAction = new QAction(tr("Copy dust"), this);
QAction *clipboardChangeAction = new QAction(tr("Copy change"), this);
connect(clipboardQuantityAction, SIGNAL(triggered()), this, SLOT(clipboardQuantity()));
connect(clipboardAmountAction, SIGNAL(triggered()), this, SLOT(clipboardAmount()));
connect(clipboardFeeAction, SIGNAL(triggered()), this, SLOT(clipboardFee()));
connect(clipboardAfterFeeAction, SIGNAL(triggered()), this, SLOT(clipboardAfterFee()));
connect(clipboardBytesAction, SIGNAL(triggered()), this, SLOT(clipboardBytes()));
connect(clipboardLowOutputAction, SIGNAL(triggered()), this, SLOT(clipboardLowOutput()));
connect(clipboardChangeAction, SIGNAL(triggered()), this, SLOT(clipboardChange()));
ui->labelCoinControlQuantity->addAction(clipboardQuantityAction);
ui->labelCoinControlAmount->addAction(clipboardAmountAction);
ui->labelCoinControlFee->addAction(clipboardFeeAction);
ui->labelCoinControlAfterFee->addAction(clipboardAfterFeeAction);
ui->labelCoinControlBytes->addAction(clipboardBytesAction);
ui->labelCoinControlLowOutput->addAction(clipboardLowOutputAction);
ui->labelCoinControlChange->addAction(clipboardChangeAction);
// toggle tree/list mode
connect(ui->radioTreeMode, SIGNAL(toggled(bool)), this, SLOT(radioTreeMode(bool)));
connect(ui->radioListMode, SIGNAL(toggled(bool)), this, SLOT(radioListMode(bool)));
// click on checkbox
connect(ui->treeWidget, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(viewItemChanged(QTreeWidgetItem*, int)));
// click on header
#if QT_VERSION < 0x050000
ui->treeWidget->header()->setClickable(true);
#else
ui->treeWidget->header()->setSectionsClickable(true);
#endif
connect(ui->treeWidget->header(), SIGNAL(sectionClicked(int)), this, SLOT(headerSectionClicked(int)));
// ok button
connect(ui->buttonBox, SIGNAL(clicked( QAbstractButton*)), this, SLOT(buttonBoxClicked(QAbstractButton*)));
// (un)select all
connect(ui->pushButtonSelectAll, SIGNAL(clicked()), this, SLOT(buttonSelectAllClicked()));
// Toggle lock state
connect(ui->pushButtonToggleLock, SIGNAL(clicked()), this, SLOT(buttonToggleLockClicked()));
// change coin control first column label due Qt4 bug.
// see https://github.com/bitcoin/bitcoin/issues/5716
ui->treeWidget->headerItem()->setText(COLUMN_CHECKBOX, QString());
ui->treeWidget->setColumnWidth(COLUMN_CHECKBOX, 84);
ui->treeWidget->setColumnWidth(COLUMN_AMOUNT, 100);
ui->treeWidget->setColumnWidth(COLUMN_LABEL, 170);
ui->treeWidget->setColumnWidth(COLUMN_ADDRESS, 190);
ui->treeWidget->setColumnWidth(COLUMN_PRIVATESEND_ROUNDS, 88);
ui->treeWidget->setColumnWidth(COLUMN_DATE, 80);
ui->treeWidget->setColumnWidth(COLUMN_CONFIRMATIONS, 100);
ui->treeWidget->setColumnHidden(COLUMN_TXHASH, true); // store transaction hash in this column, but don't show it
ui->treeWidget->setColumnHidden(COLUMN_VOUT_INDEX, true); // store vout index in this column, but don't show it
// default view is sorted by amount desc
sortView(COLUMN_AMOUNT, Qt::DescendingOrder);
// restore list mode and sortorder as a convenience feature
QSettings settings;
if (settings.contains("nCoinControlMode") && !settings.value("nCoinControlMode").toBool())
ui->radioTreeMode->click();
if (settings.contains("nCoinControlSortColumn") && settings.contains("nCoinControlSortOrder"))
sortView(settings.value("nCoinControlSortColumn").toInt(), ((Qt::SortOrder)settings.value("nCoinControlSortOrder").toInt()));
}
CoinControlDialog::~CoinControlDialog()
{
QSettings settings;
settings.setValue("nCoinControlMode", ui->radioListMode->isChecked());
settings.setValue("nCoinControlSortColumn", sortColumn);
settings.setValue("nCoinControlSortOrder", (int)sortOrder);
delete ui;
}
void CoinControlDialog::setModel(WalletModel *_model)
{
this->model = _model;
if(_model && _model->getOptionsModel() && _model->getAddressTableModel())
{
updateView();
updateLabelLocked();
CoinControlDialog::updateLabels(_model, this);
}
}
// ok button
void CoinControlDialog::buttonBoxClicked(QAbstractButton* button)
{
if (ui->buttonBox->buttonRole(button) == QDialogButtonBox::AcceptRole)
done(QDialog::Accepted); // closes the dialog
}
// (un)select all
void CoinControlDialog::buttonSelectAllClicked()
{
Qt::CheckState state = Qt::Checked;
for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++)
{
if (ui->treeWidget->topLevelItem(i)->checkState(COLUMN_CHECKBOX) != Qt::Unchecked)
{
state = Qt::Unchecked;
break;
}
}
ui->treeWidget->setEnabled(false);
for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++)
if (ui->treeWidget->topLevelItem(i)->checkState(COLUMN_CHECKBOX) != state)
ui->treeWidget->topLevelItem(i)->setCheckState(COLUMN_CHECKBOX, state);
ui->treeWidget->setEnabled(true);
if (state == Qt::Unchecked)
coinControl->UnSelectAll(); // just to be sure
CoinControlDialog::updateLabels(model, this);
}
// Toggle lock state
void CoinControlDialog::buttonToggleLockClicked()
{
QTreeWidgetItem *item;
QString theme = GUIUtil::getThemeName();
// Works in list-mode only
if(ui->radioListMode->isChecked()){
ui->treeWidget->setEnabled(false);
for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++){
item = ui->treeWidget->topLevelItem(i);
COutPoint outpt(uint256S(item->text(COLUMN_TXHASH).toStdString()), item->text(COLUMN_VOUT_INDEX).toUInt());
if (model->isLockedCoin(uint256S(item->text(COLUMN_TXHASH).toStdString()), item->text(COLUMN_VOUT_INDEX).toUInt())){
model->unlockCoin(outpt);
item->setDisabled(false);
item->setIcon(COLUMN_CHECKBOX, QIcon());
}
else{
model->lockCoin(outpt);
item->setDisabled(true);
item->setIcon(COLUMN_CHECKBOX, QIcon(":/icons/" + theme + "/lock_closed"));
}
updateLabelLocked();
}
ui->treeWidget->setEnabled(true);
CoinControlDialog::updateLabels(model, this);
}
else{
QMessageBox msgBox;
msgBox.setObjectName("lockMessageBox");
msgBox.setStyleSheet(GUIUtil::loadStyleSheet());
msgBox.setText(tr("Please switch to \"List mode\" to use this function."));
msgBox.exec();
}
}
// context menu
void CoinControlDialog::showMenu(const QPoint &point)
{
QTreeWidgetItem *item = ui->treeWidget->itemAt(point);
if(item)
{
contextMenuItem = item;
// disable some items (like Copy Transaction ID, lock, unlock) for tree roots in context menu
if (item->text(COLUMN_TXHASH).length() == 64) // transaction hash is 64 characters (this means its a child node, so its not a parent node in tree mode)
{
copyTransactionHashAction->setEnabled(true);
if (model->isLockedCoin(uint256S(item->text(COLUMN_TXHASH).toStdString()), item->text(COLUMN_VOUT_INDEX).toUInt()))
{
lockAction->setEnabled(false);
unlockAction->setEnabled(true);
}
else
{
lockAction->setEnabled(true);
unlockAction->setEnabled(false);
}
}
else // this means click on parent node in tree mode -> disable all
{
copyTransactionHashAction->setEnabled(false);
lockAction->setEnabled(false);
unlockAction->setEnabled(false);
}
// show context menu
contextMenu->exec(QCursor::pos());
}
}
// context menu action: copy amount
void CoinControlDialog::copyAmount()
{
GUIUtil::setClipboard(BitcoinUnits::removeSpaces(contextMenuItem->text(COLUMN_AMOUNT)));
}
// context menu action: copy label
void CoinControlDialog::copyLabel()
{
if (ui->radioTreeMode->isChecked() && contextMenuItem->text(COLUMN_LABEL).length() == 0 && contextMenuItem->parent())
GUIUtil::setClipboard(contextMenuItem->parent()->text(COLUMN_LABEL));
else
GUIUtil::setClipboard(contextMenuItem->text(COLUMN_LABEL));
}
// context menu action: copy address
void CoinControlDialog::copyAddress()
{
if (ui->radioTreeMode->isChecked() && contextMenuItem->text(COLUMN_ADDRESS).length() == 0 && contextMenuItem->parent())
GUIUtil::setClipboard(contextMenuItem->parent()->text(COLUMN_ADDRESS));
else
GUIUtil::setClipboard(contextMenuItem->text(COLUMN_ADDRESS));
}
// context menu action: copy transaction id
void CoinControlDialog::copyTransactionHash()
{
GUIUtil::setClipboard(contextMenuItem->text(COLUMN_TXHASH));
}
// context menu action: lock coin
void CoinControlDialog::lockCoin()
{
QString theme = GUIUtil::getThemeName();
if (contextMenuItem->checkState(COLUMN_CHECKBOX) == Qt::Checked)
contextMenuItem->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
COutPoint outpt(uint256S(contextMenuItem->text(COLUMN_TXHASH).toStdString()), contextMenuItem->text(COLUMN_VOUT_INDEX).toUInt());
model->lockCoin(outpt);
contextMenuItem->setDisabled(true);
contextMenuItem->setIcon(COLUMN_CHECKBOX, QIcon(":/icons/" + theme + "/lock_closed"));
updateLabelLocked();
}
// context menu action: unlock coin
void CoinControlDialog::unlockCoin()
{
COutPoint outpt(uint256S(contextMenuItem->text(COLUMN_TXHASH).toStdString()), contextMenuItem->text(COLUMN_VOUT_INDEX).toUInt());
model->unlockCoin(outpt);
contextMenuItem->setDisabled(false);
contextMenuItem->setIcon(COLUMN_CHECKBOX, QIcon());
updateLabelLocked();
}
// copy label "Quantity" to clipboard
void CoinControlDialog::clipboardQuantity()
{
GUIUtil::setClipboard(ui->labelCoinControlQuantity->text());
}
// copy label "Amount" to clipboard
void CoinControlDialog::clipboardAmount()
{
GUIUtil::setClipboard(ui->labelCoinControlAmount->text().left(ui->labelCoinControlAmount->text().indexOf(" ")));
}
// copy label "Fee" to clipboard
void CoinControlDialog::clipboardFee()
{
GUIUtil::setClipboard(ui->labelCoinControlFee->text().left(ui->labelCoinControlFee->text().indexOf(" ")).replace(ASYMP_UTF8, ""));
}
// copy label "After fee" to clipboard
void CoinControlDialog::clipboardAfterFee()
{
GUIUtil::setClipboard(ui->labelCoinControlAfterFee->text().left(ui->labelCoinControlAfterFee->text().indexOf(" ")).replace(ASYMP_UTF8, ""));
}
// copy label "Bytes" to clipboard
void CoinControlDialog::clipboardBytes()
{
GUIUtil::setClipboard(ui->labelCoinControlBytes->text().replace(ASYMP_UTF8, ""));
}
// copy label "Dust" to clipboard
void CoinControlDialog::clipboardLowOutput()
{
GUIUtil::setClipboard(ui->labelCoinControlLowOutput->text());
}
// copy label "Change" to clipboard
void CoinControlDialog::clipboardChange()
{
GUIUtil::setClipboard(ui->labelCoinControlChange->text().left(ui->labelCoinControlChange->text().indexOf(" ")).replace(ASYMP_UTF8, ""));
}
// treeview: sort
void CoinControlDialog::sortView(int column, Qt::SortOrder order)
{
sortColumn = column;
sortOrder = order;
ui->treeWidget->sortItems(column, order);
ui->treeWidget->header()->setSortIndicator(sortColumn, sortOrder);
}
// treeview: clicked on header
void CoinControlDialog::headerSectionClicked(int logicalIndex)
{
if (logicalIndex == COLUMN_CHECKBOX) // click on most left column -> do nothing
{
ui->treeWidget->header()->setSortIndicator(sortColumn, sortOrder);
}
else
{
if (sortColumn == logicalIndex)
sortOrder = ((sortOrder == Qt::AscendingOrder) ? Qt::DescendingOrder : Qt::AscendingOrder);
else
{
sortColumn = logicalIndex;
sortOrder = ((sortColumn == COLUMN_LABEL || sortColumn == COLUMN_ADDRESS) ? Qt::AscendingOrder : Qt::DescendingOrder); // if label or address then default => asc, else default => desc
}
sortView(sortColumn, sortOrder);
}
}
// toggle tree mode
void CoinControlDialog::radioTreeMode(bool checked)
{
if (checked && model)
updateView();
}
// toggle list mode
void CoinControlDialog::radioListMode(bool checked)
{
if (checked && model)
updateView();
}
// checkbox clicked by user
void CoinControlDialog::viewItemChanged(QTreeWidgetItem* item, int column)
{
if (column == COLUMN_CHECKBOX && item->text(COLUMN_TXHASH).length() == 64) // transaction hash is 64 characters (this means its a child node, so its not a parent node in tree mode)
{
COutPoint outpt(uint256S(item->text(COLUMN_TXHASH).toStdString()), item->text(COLUMN_VOUT_INDEX).toUInt());
if (item->checkState(COLUMN_CHECKBOX) == Qt::Unchecked)
coinControl->UnSelect(outpt);
else if (item->isDisabled()) // locked (this happens if "check all" through parent node)
item->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
else {
coinControl->Select(outpt);
int nRounds = pwalletMain->GetOutpointPrivateSendRounds(outpt);
if (coinControl->fUsePrivateSend && nRounds < privateSendClient.nPrivateSendRounds) {
QMessageBox::warning(this, windowTitle(),
tr("Non-anonymized input selected. <b>PrivateSend will be disabled.</b><br><br>If you still want to use PrivateSend, please deselect all non-nonymized inputs first and then check PrivateSend checkbox again."),
QMessageBox::Ok, QMessageBox::Ok);
coinControl->fUsePrivateSend = false;
}
}
// selection changed -> update labels
if (ui->treeWidget->isEnabled()) // do not update on every click for (un)select all
CoinControlDialog::updateLabels(model, this);
}
// TODO: Remove this temporary qt5 fix after Qt5.3 and Qt5.4 are no longer used.
// Fixed in Qt5.5 and above: https://bugreports.qt.io/browse/QTBUG-43473
#if QT_VERSION >= 0x050000
else if (column == COLUMN_CHECKBOX && item->childCount() > 0)
{
if (item->checkState(COLUMN_CHECKBOX) == Qt::PartiallyChecked && item->child(0)->checkState(COLUMN_CHECKBOX) == Qt::PartiallyChecked)
item->setCheckState(COLUMN_CHECKBOX, Qt::Checked);
}
#endif
}
// shows count of locked unspent outputs
void CoinControlDialog::updateLabelLocked()
{
std::vector<COutPoint> vOutpts;
model->listLockedCoins(vOutpts);
if (vOutpts.size() > 0)
{
ui->labelLocked->setText(tr("(%1 locked)").arg(vOutpts.size()));
ui->labelLocked->setVisible(true);
}
else ui->labelLocked->setVisible(false);
}
void CoinControlDialog::updateLabels(WalletModel *model, QDialog* dialog)
{
if (!model)
return;
// nPayAmount
CAmount nPayAmount = 0;
bool fDust = false;
CMutableTransaction txDummy;
Q_FOREACH(const CAmount &amount, CoinControlDialog::payAmounts)
{
nPayAmount += amount;
if (amount > 0)
{
CTxOut txout(amount, (CScript)std::vector<unsigned char>(24, 0));
txDummy.vout.push_back(txout);
if (txout.IsDust(dustRelayFee))
fDust = true;
}
}
CAmount nAmount = 0;
CAmount nPayFee = 0;
CAmount nAfterFee = 0;
CAmount nChange = 0;
unsigned int nBytes = 0;
unsigned int nBytesInputs = 0;
double dPriority = 0;
double dPriorityInputs = 0;
unsigned int nQuantity = 0;
int nQuantityUncompressed = 0;
bool fAllowFree = false;
std::vector<COutPoint> vCoinControl;
std::vector<COutput> vOutputs;
coinControl->ListSelected(vCoinControl);
model->getOutputs(vCoinControl, vOutputs);
BOOST_FOREACH(const COutput& out, vOutputs) {
// unselect already spent, very unlikely scenario, this could happen
// when selected are spent elsewhere, like rpc or another computer
uint256 txhash = out.tx->GetHash();
COutPoint outpt(txhash, out.i);
if (model->isSpent(outpt))
{
coinControl->UnSelect(outpt);
continue;
}
// Quantity
nQuantity++;
// Amount
nAmount += out.tx->tx->vout[out.i].nValue;
// Priority
dPriorityInputs += (double)out.tx->tx->vout[out.i].nValue * (out.nDepth+1);
// Bytes
CTxDestination address;
if(ExtractDestination(out.tx->tx->vout[out.i].scriptPubKey, address))
{
CPubKey pubkey;
CKeyID *keyid = boost::get<CKeyID>(&address);
if (keyid && model->getPubKey(*keyid, pubkey))
{
nBytesInputs += (pubkey.IsCompressed() ? 148 : 180);
if (!pubkey.IsCompressed())
nQuantityUncompressed++;
}
else
nBytesInputs += 148; // in all error cases, simply assume 148 here
}
else nBytesInputs += 148;
// Add inputs to calculate InstantSend Fee later
if(coinControl->fUseInstantSend)
txDummy.vin.push_back(CTxIn());
}
// calculation
if (nQuantity > 0)
{
// Bytes
nBytes = nBytesInputs + ((CoinControlDialog::payAmounts.size() > 0 ? CoinControlDialog::payAmounts.size() + 1 : 2) * 34) + 10; // always assume +1 output for change here
// in the subtract fee from amount case, we can tell if zero change already and subtract the bytes, so that fee calculation afterwards is accurate
if (CoinControlDialog::fSubtractFeeFromAmount)
if (nAmount - nPayAmount == 0)
nBytes -= 34;
// Fee
nPayFee = CWallet::GetMinimumFee(nBytes, nTxConfirmTarget, mempool);
if (nPayFee > 0 && coinControl->nMinimumTotalFee > nPayFee)
nPayFee = coinControl->nMinimumTotalFee;
// InstantSend Fee
if (coinControl->fUseInstantSend) nPayFee = std::max(nPayFee, CTxLockRequest(txDummy).GetMinFee());
// Allow free? (require at least hard-coded threshold and default to that if no estimate)
double mempoolEstimatePriority = mempool.estimateSmartPriority(nTxConfirmTarget);
dPriority = dPriorityInputs / (nBytes - nBytesInputs + (nQuantityUncompressed * 29)); // 29 = 180 - 151 (uncompressed public keys are over the limit. max 151 bytes of the input are ignored for priority)
double dPriorityNeeded = std::max(mempoolEstimatePriority, AllowFreeThreshold());
fAllowFree = (dPriority >= dPriorityNeeded);
if (fSendFreeTransactions)
if (fAllowFree && nBytes <= MAX_FREE_TRANSACTION_CREATE_SIZE)
nPayFee = 0;
if (nPayAmount > 0)
{
nChange = nAmount - nPayAmount;
if (!CoinControlDialog::fSubtractFeeFromAmount)
nChange -= nPayFee;
// PrivateSend Fee = overpay
if(coinControl->fUsePrivateSend && nChange > 0)
{
nPayFee += nChange;
nChange = 0;
}
// Never create dust outputs; if we would, just add the dust to the fee.
if (nChange > 0 && nChange < MIN_CHANGE)
{
CTxOut txout(nChange, (CScript)std::vector<unsigned char>(24, 0));
if (txout.IsDust(dustRelayFee))
{
if (CoinControlDialog::fSubtractFeeFromAmount) // dust-change will be raised until no dust
nChange = txout.GetDustThreshold(dustRelayFee);
else
{
nPayFee += nChange;
nChange = 0;
}
}
}
if (nChange == 0 && !CoinControlDialog::fSubtractFeeFromAmount)
nBytes -= 34;
}
// after fee
nAfterFee = std::max<CAmount>(nAmount - nPayFee, 0);
}
// actually update labels
int nDisplayUnit = BitcoinUnits::BRIX;
if (model && model->getOptionsModel())
nDisplayUnit = model->getOptionsModel()->getDisplayUnit();
QLabel *l1 = dialog->findChild<QLabel *>("labelCoinControlQuantity");
QLabel *l2 = dialog->findChild<QLabel *>("labelCoinControlAmount");
QLabel *l3 = dialog->findChild<QLabel *>("labelCoinControlFee");
QLabel *l4 = dialog->findChild<QLabel *>("labelCoinControlAfterFee");
QLabel *l5 = dialog->findChild<QLabel *>("labelCoinControlBytes");
QLabel *l7 = dialog->findChild<QLabel *>("labelCoinControlLowOutput");
QLabel *l8 = dialog->findChild<QLabel *>("labelCoinControlChange");
// enable/disable "dust" and "change"
dialog->findChild<QLabel *>("labelCoinControlLowOutputText")->setEnabled(nPayAmount > 0);
dialog->findChild<QLabel *>("labelCoinControlLowOutput") ->setEnabled(nPayAmount > 0);
dialog->findChild<QLabel *>("labelCoinControlChangeText") ->setEnabled(nPayAmount > 0);
dialog->findChild<QLabel *>("labelCoinControlChange") ->setEnabled(nPayAmount > 0);
// stats
l1->setText(QString::number(nQuantity)); // Quantity
l2->setText(BitcoinUnits::formatWithUnit(nDisplayUnit, nAmount)); // Amount
l3->setText(BitcoinUnits::formatWithUnit(nDisplayUnit, nPayFee)); // Fee
l4->setText(BitcoinUnits::formatWithUnit(nDisplayUnit, nAfterFee)); // After Fee
l5->setText(((nBytes > 0) ? ASYMP_UTF8 : "") + QString::number(nBytes)); // Bytes
l7->setText(fDust ? tr("yes") : tr("no")); // Dust
l8->setText(BitcoinUnits::formatWithUnit(nDisplayUnit, nChange)); // Change
if (nPayFee > 0 && (coinControl->nMinimumTotalFee < nPayFee))
{
l3->setText(ASYMP_UTF8 + l3->text());
l4->setText(ASYMP_UTF8 + l4->text());
if (nChange > 0 && !CoinControlDialog::fSubtractFeeFromAmount)
l8->setText(ASYMP_UTF8 + l8->text());
}
// turn label red when dust
l7->setStyleSheet((fDust) ? "color:red;" : "");
// tool tips
QString toolTipDust = tr("This label turns red if any recipient receives an amount smaller than the current dust threshold.");
// how many satoshis the estimated fee can vary per byte we guess wrong
double dFeeVary;
if (payTxFee.GetFeePerK() > 0)
dFeeVary = (double)std::max(CWallet::GetRequiredFee(1000), payTxFee.GetFeePerK()) / 1000;
else {
dFeeVary = (double)std::max(CWallet::GetRequiredFee(1000), mempool.estimateSmartFee(nTxConfirmTarget).GetFeePerK()) / 1000;
}
QString toolTip4 = tr("Can vary +/- %1 duff(s) per input.").arg(dFeeVary);
l3->setToolTip(toolTip4);
l4->setToolTip(toolTip4);
l7->setToolTip(toolTipDust);
l8->setToolTip(toolTip4);
dialog->findChild<QLabel *>("labelCoinControlFeeText") ->setToolTip(l3->toolTip());
dialog->findChild<QLabel *>("labelCoinControlAfterFeeText") ->setToolTip(l4->toolTip());
dialog->findChild<QLabel *>("labelCoinControlBytesText") ->setToolTip(l5->toolTip());
dialog->findChild<QLabel *>("labelCoinControlLowOutputText")->setToolTip(l7->toolTip());
dialog->findChild<QLabel *>("labelCoinControlChangeText") ->setToolTip(l8->toolTip());
// Insufficient funds
QLabel *label = dialog->findChild<QLabel *>("labelCoinControlInsuffFunds");
if (label)
label->setVisible(nChange < 0);
}
void CoinControlDialog::updateView()
{
if (!model || !model->getOptionsModel() || !model->getAddressTableModel())
return;
bool treeMode = ui->radioTreeMode->isChecked();
QString theme = GUIUtil::getThemeName();
ui->treeWidget->clear();
ui->treeWidget->setEnabled(false); // performance, otherwise updateLabels would be called for every checked checkbox
ui->treeWidget->setAlternatingRowColors(!treeMode);
QFlags<Qt::ItemFlag> flgCheckbox = Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable;
QFlags<Qt::ItemFlag> flgTristate = Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable | Qt::ItemIsTristate;
int nDisplayUnit = model->getOptionsModel()->getDisplayUnit();
std::map<QString, std::vector<COutput> > mapCoins;
model->listCoins(mapCoins);
BOOST_FOREACH(const PAIRTYPE(QString, std::vector<COutput>)& coins, mapCoins) {
CCoinControlWidgetItem *itemWalletAddress = new CCoinControlWidgetItem();
itemWalletAddress->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
QString sWalletAddress = coins.first;
QString sWalletLabel = model->getAddressTableModel()->labelForAddress(sWalletAddress);
if (sWalletLabel.isEmpty())
sWalletLabel = tr("(no label)");
if (treeMode)
{
// wallet address
ui->treeWidget->addTopLevelItem(itemWalletAddress);
itemWalletAddress->setFlags(flgTristate);
itemWalletAddress->setCheckState(COLUMN_CHECKBOX, Qt::Unchecked);
// label
itemWalletAddress->setText(COLUMN_LABEL, sWalletLabel);
itemWalletAddress->setToolTip(COLUMN_LABEL, sWalletLabel);
// address
itemWalletAddress->setText(COLUMN_ADDRESS, sWalletAddress);
itemWalletAddress->setToolTip(COLUMN_ADDRESS, sWalletAddress);
}
CAmount nSum = 0;
int nChildren = 0;
BOOST_FOREACH(const COutput& out, coins.second) {
nSum += out.tx->tx->vout[out.i].nValue;
nChildren++;
CCoinControlWidgetItem *itemOutput;
if (treeMode) itemOutput = new CCoinControlWidgetItem(itemWalletAddress);
else itemOutput = new CCoinControlWidgetItem(ui->treeWidget);
itemOutput->setFlags(flgCheckbox);
itemOutput->setCheckState(COLUMN_CHECKBOX,Qt::Unchecked);
// address
CTxDestination outputAddress;
QString sAddress = "";
if(ExtractDestination(out.tx->tx->vout[out.i].scriptPubKey, outputAddress))
{
sAddress = QString::fromStdString(CBitcoinAddress(outputAddress).ToString());
// if listMode or change => show brixcoin address. In tree mode, address is not shown again for direct wallet address outputs
if (!treeMode || (!(sAddress == sWalletAddress)))
itemOutput->setText(COLUMN_ADDRESS, sAddress);
itemOutput->setToolTip(COLUMN_ADDRESS, sAddress);
}
// label
if (!(sAddress == sWalletAddress)) // change
{
// tooltip from where the change comes from
itemOutput->setToolTip(COLUMN_LABEL, tr("change from %1 (%2)").arg(sWalletLabel).arg(sWalletAddress));
itemOutput->setText(COLUMN_LABEL, tr("(change)"));
}
else if (!treeMode)
{
QString sLabel = model->getAddressTableModel()->labelForAddress(sAddress);
if (sLabel.isEmpty())
sLabel = tr("(no label)");
itemOutput->setText(COLUMN_LABEL, sLabel);
}
// amount
itemOutput->setText(COLUMN_AMOUNT, BitcoinUnits::format(nDisplayUnit, out.tx->tx->vout[out.i].nValue));
itemOutput->setToolTip(COLUMN_AMOUNT, BitcoinUnits::format(nDisplayUnit, out.tx->tx->vout[out.i].nValue));
itemOutput->setData(COLUMN_AMOUNT, Qt::UserRole, QVariant((qlonglong)out.tx->tx->vout[out.i].nValue)); // padding so that sorting works correctly
// date
itemOutput->setText(COLUMN_DATE, GUIUtil::dateTimeStr(out.tx->GetTxTime()));
itemOutput->setToolTip(COLUMN_DATE, GUIUtil::dateTimeStr(out.tx->GetTxTime()));
itemOutput->setData(COLUMN_DATE, Qt::UserRole, QVariant((qlonglong)out.tx->GetTxTime()));
// PrivateSend rounds
COutPoint outpoint = COutPoint(out.tx->tx->GetHash(), out.i);
int nRounds = pwalletMain->GetOutpointPrivateSendRounds(outpoint);
if (nRounds >= 0 || fDebug) itemOutput->setText(COLUMN_PRIVATESEND_ROUNDS, QString::number(nRounds));
else itemOutput->setText(COLUMN_PRIVATESEND_ROUNDS, tr("n/a"));
itemOutput->setData(COLUMN_PRIVATESEND_ROUNDS, Qt::UserRole, QVariant((qlonglong)nRounds));
// confirmations
itemOutput->setText(COLUMN_CONFIRMATIONS, QString::number(out.nDepth));
itemOutput->setData(COLUMN_CONFIRMATIONS, Qt::UserRole, QVariant((qlonglong)out.nDepth));
// transaction hash
uint256 txhash = out.tx->GetHash();
itemOutput->setText(COLUMN_TXHASH, QString::fromStdString(txhash.GetHex()));
// vout index
itemOutput->setText(COLUMN_VOUT_INDEX, QString::number(out.i));
// disable locked coins
if (model->isLockedCoin(txhash, out.i))
{
COutPoint outpt(txhash, out.i);
coinControl->UnSelect(outpt); // just to be sure
itemOutput->setDisabled(true);
itemOutput->setIcon(COLUMN_CHECKBOX, QIcon(":/icons/" + theme + "/lock_closed"));
}
// set checkbox
if (coinControl->IsSelected(COutPoint(txhash, out.i)))
itemOutput->setCheckState(COLUMN_CHECKBOX, Qt::Checked);
}
// amount
if (treeMode)
{
itemWalletAddress->setText(COLUMN_CHECKBOX, "(" + QString::number(nChildren) + ")");
itemWalletAddress->setText(COLUMN_AMOUNT, BitcoinUnits::format(nDisplayUnit, nSum));
itemWalletAddress->setToolTip(COLUMN_AMOUNT, BitcoinUnits::format(nDisplayUnit, nSum));
itemWalletAddress->setData(COLUMN_AMOUNT, Qt::UserRole, QVariant((qlonglong)nSum));
}
}
// expand all partially selected
if (treeMode)
{
for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++)
if (ui->treeWidget->topLevelItem(i)->checkState(COLUMN_CHECKBOX) == Qt::PartiallyChecked)
ui->treeWidget->topLevelItem(i)->setExpanded(true);
}
// sort view
sortView(sortColumn, sortOrder);
ui->treeWidget->setEnabled(true);
}
| [
"admin@africawebsolutions.org"
] | admin@africawebsolutions.org |
3831b55f92311839bdeb69ec70c81ee527885bca | a9a2b9084146ada6216b071a333408386ea90024 | /v8/src/ia32/frames-ia32.cc | 61d6876a136542e20e861489ccb6489b6b75b83e | [
"MIT",
"bzip2-1.0.6",
"BSD-3-Clause"
] | permissive | bteixeira/sciborgV8 | 57a12c77a08a2507aa56a94ddb047d4ad5e67e5d | bb06893f41d6ec66e8311c5eeb48afc55f1bb8e6 | refs/heads/master | 2021-01-16T21:02:10.427881 | 2014-01-13T17:32:00 | 2014-01-13T17:32:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,119 | cc | // Copyright 2006-2008 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "v8.h"
#if defined(V8_TARGET_ARCH_IA32)
#include "assembler.h"
#include "assembler-ia32.h"
#include "assembler-ia32-inl.h"
#include "frames.h"
namespace v8 {
namespace internal {
Register JavaScriptFrame::fp_register() { return ebp; }
Register JavaScriptFrame::context_register() { return esi; }
Register StubFailureTrampolineFrame::fp_register() { return ebp; }
Register StubFailureTrampolineFrame::context_register() { return esi; }
} } // namespace v8::internal
#endif // V8_TARGET_ARCH_IA32
| [
"bruno.teixeira@zalando.de"
] | bruno.teixeira@zalando.de |
c599a04e713f5017d59213acdfc066b172b6e1cb | 70abdf4e8e2e18318b1c451f1ecb8808c3af1153 | /CBY_Projects/CBY_2D_DX_GameProjet/WeaponMgr.h | c6d23fd28529aba03deb4d46ad8436ba67d436d5 | [] | no_license | Byeng-Yong-Choi/Byeng_Yong-Game | 0815e0944cd8c7d8d0093fc1d58662f5bd75845f | 0ac592e66f6d895b277ceb2c829338b13b94f14f | refs/heads/master | 2023-03-11T07:12:34.809028 | 2021-02-22T19:10:29 | 2021-02-22T19:10:29 | 276,743,710 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 822 | h | #pragma once
#include "WeaponQueue.h"
#include "C_ObjectMT.h"
#include <memory>
typedef std::vector<TowerWeapon*>::iterator Weaiter;
class WeaponMgr :public Singleton<WeaponMgr>
{
public:
D3DXMATRIX m_matWorld;
D3DXMATRIX m_matView;
D3DXMATRIX m_matProj;
std::vector<TowerWeapon*> m_pWeaponList;
WeaponQueue m_WeaponQueue;
public:
bool Init();
bool Frame();
bool Render();
bool Release();
void WeaponTargetPositionSet(TowerWeapon* weapon, D3DXVECTOR3 pos);
void WeaponMake(TowerWeapon* weapon, D3DXMATRIX* world,int imon, bool blv);
void SetMatrix(D3DXMATRIX* world, D3DXMATRIX* view, D3DXMATRIX* proj);
Weaiter WeaponPop(Weaiter iweapon);
void WeaponPop(int iweapon);
void Process(std::shared_ptr<C_Tower>& tower);
public:
WeaponMgr();
~WeaponMgr();
};
#define TOWER_WEAPON WeaponMgr::GetInstance()
| [
"cby0109@naver.com"
] | cby0109@naver.com |
bd3d9a17eb15ae20e3fb6014e410716afdc1201c | c7c5511488d2be20f8fe385da44c4735a4076741 | /ch06/local_variable.cpp | dfc0ec714cf67fe2b7f460988d828d405f80e9d9 | [] | no_license | aleecan/jumping-into-cpp | 9acf5173f4fc1d017bd7e3ef7bb98b6fd673caee | 0399328b34bf98c03c524a481eac630866e90e71 | refs/heads/master | 2020-08-03T10:18:23.002428 | 2019-01-24T10:46:15 | 2019-01-24T10:46:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 518 | cpp | #include <cassert>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <iostream>
#include <sstream>
using namespace std;
#define REP(i, n) for(int i = 0; i < (int)(n); ++ i)
#define FOR(i, b, e) for(auto i = b; i < e; ++ i)
#define all(x) (x).begin(), (x).end()
void changeArgument(int x) {
x = x + 5;
}
int main() {
int y = 4;
changeArgument(y);
cout << y;
}
| [
"noreply@github.com"
] | aleecan.noreply@github.com |
9dc48a834c9bcb587403f03856bc6c9c093aa3b3 | 00d65fed66798b82b1455736458543a189f88c19 | /file.cpp | d5707221bd2e109ca9ac39cf68f94a4e6b631b18 | [] | no_license | lipan6461188/FILE | 41d002d6cd079fdcc26212ffcac712e25ec68f76 | 09b0e834b25528feef5185f59c886bba86867c2f | refs/heads/master | 2021-01-17T11:57:57.292676 | 2014-12-26T12:40:12 | 2014-12-26T12:40:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,422 | cpp | #include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <stdlib.h>
/*
LeetekiMacBook-Pro:Desktop lee$ ls -lR testDir
total 0
drwxr-xr-x 4 lee staff 136 12 24 21:58 Dir1
drwxr-xr-x 3 lee staff 102 12 24 21:58 Dir2
drwxr-xr-x 2 lee staff 68 12 24 21:58 Dir3
-rw-r--r-- 1 lee staff 0 12 24 21:58 file1
-rw-r--r-- 1 lee staff 0 12 24 21:58 file2
-rw-r--r-- 1 lee staff 0 12 24 21:58 file3
testDir/Dir1:
total 0
-rw-r--r-- 1 lee staff 0 12 24 21:58 file1.1
-rw-r--r-- 1 lee staff 0 12 24 21:58 file1.2
testDir/Dir2:
total 0
-rw-r--r-- 1 lee staff 0 12 24 21:58 file2.1
testDir/Dir3:
*/
//三个字符串拼接
char *join(char *string1, char *string2, char *string3)
{
char *result = (char*)malloc(strlen(string1) + strlen(string2) + strlen(string3) + 1);
strcpy(result, string1);
strcat(result, string2);
strcat(result, string3);
return result;
}
//文件权限信息
char *permission(struct stat entry)
{
char *result = (char*)malloc(10 * sizeof(char));
//文件类型
//if ( (entry.st_mode & S_IFREG) == S_IFREG) {
result[0] = '_';
//}
if ( (entry.st_mode & S_IFLNK) == S_IFLNK) {
result[0] = 's';
}
if ( (entry.st_mode & S_IFBLK) == S_IFBLK) {
result[0] = 'b';
}
if ( (entry.st_mode & S_IFDIR) == S_IFDIR) {
result[0] = 'd';
}
//文件所有者的权限
if( (entry.st_mode & S_IRUSR) == S_IRUSR )
result[1] = 'r';
else
result[1] = '_';
if( (entry.st_mode & S_IWUSR) == S_IWUSR )
result[2] = 'w';
else
result[2] = '_';
if( (entry.st_mode & S_IXUSR) == S_IXUSR )
result[3] = 'x';
else
result[3] = '_';
//文件用户组的权限
if( (entry.st_mode & S_IRGRP) == S_IRGRP )
result[4] = 'r';
else
result[4] = '_';
if( (entry.st_mode & S_IWGRP) == S_IWGRP )
result[5] = 'w';
else
result[5] = '_';
if( (entry.st_mode & S_IXGRP) == S_IXGRP )
result[6] = 'x';
else
result[6] = '_';
//其他用户的权限
if( (entry.st_mode & S_IROTH) == S_IROTH )
result[7] = 'r';
else
result[7] = '_';
if( (entry.st_mode & S_IWOTH) == S_IWOTH )
result[8] = 'w';
else
result[8] = '_';
if( (entry.st_mode & S_IXOTH) == S_IXOTH )
result[9] = 'x';
else
result[9] = '_';
return result;
}
//返回空格
char *blank(int i){
char *result = (char*)malloc(4*i*sizeof(char));
int f = 0;
for (;f<4*i;f+=4) {
result[f] = ' ';
result[f+1] = ' ';
result[f+2] = ' ';
result[f+3] = ' ';
}
return result;
}
void printdir(char *dir, int depth)
{
DIR *dp;
struct dirent *entry;
struct stat statbuf;
if((dp = opendir(dir)) == NULL){
perror("open directory meets error\n");
exit(0);
}
chdir(dir);
while((entry = readdir(dp))){
char *newDir = join(dir, "/", entry->d_name);
lstat(newDir,&statbuf);
if (S_ISDIR(statbuf.st_mode)) {
if ( !strncmp(entry->d_name,".",strlen(entry->d_name)) || !strncmp(entry->d_name,"..",strlen(entry->d_name)) )
continue;
long year = statbuf.st_ctime / 31536000 + 1969 ;
printf("%s%s %d %d %lld %ld %s \n",blank(depth),permission(statbuf),statbuf.st_uid,statbuf.st_gid,statbuf.st_size,year,entry->d_name);
// printf("sss%ssss",blank(depth));
printdir(newDir, depth+1);
}else{
//非常粗略的年份
long year = statbuf.st_ctime / 31536000 + 1969 ;
//依次打印出权限、UID、GID、size、修改年份、文件名
printf("%s%s %d %d %lld %ld %s \n",blank(depth),permission(statbuf),statbuf.st_uid,statbuf.st_gid,statbuf.st_size,year,entry->d_name);
}
free(newDir);
if(depth == 0) printf("\n");
}
chdir("..");
closedir(dp);
}
//由当前目录输出
int main(int argc, const char * argv[])
{
char *dir = (char*)malloc(1000*sizeof(char));
getwd(dir);
printdir(dir,0);
free(dir);
return 0;
}
| [
"hnsfyfyzlp@126.com"
] | hnsfyfyzlp@126.com |
13df38ee1f49aa485a64ae4a83f0a07b8b7a997e | 829b3f2d0ae685d01fe097c03bf5c1976cbc4723 | /deps/boost/include/boost/geometry/srs/projections/proj/geos.hpp | 01c0ac92a2e07ba211b50928c94903d5694b8f33 | [
"Apache-2.0"
] | permissive | liyoung1992/mediasoup-sfu-cpp | f0f0321f8974beb1f4263c9e658402620d82385f | b76564e068626b0d675f5486e56da3d69151e287 | refs/heads/main | 2023-08-21T21:40:51.710022 | 2021-10-14T06:29:18 | 2021-10-14T06:29:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 15,932 | hpp | // Boost.Geometry - gis-projections (based on PROJ4)
// Copyright (c) 2008-2015 Barend Gehrels, Amsterdam, the Netherlands.
// This file was modified by Oracle on 2017, 2018, 2019.
// Modifications copyright (c) 2017-2019, Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle.
// 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)
// This file is converted from PROJ4, http://trac.osgeo.org/proj
// PROJ4 is originally written by Gerald Evenden (then of the USGS)
// PROJ4 is maintained by Frank Warmerdam
// PROJ4 is converted to Boost.Geometry by Barend Gehrels
// Last updated version of proj: 5.0.0
// Original copyright notice:
// Copyright (c) 2004 Gerald I. Evenden
// Copyright (c) 2012 Martin Raspaud
// See also (section 4.4.3.2):
// http://www.eumetsat.int/en/area4/msg/news/us_doc/cgms_03_26.pdf
// 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 BOOST_GEOMETRY_PROJECTIONS_GEOS_HPP
#define BOOST_GEOMETRY_PROJECTIONS_GEOS_HPP
#include <boost/math/special_functions/hypot.hpp>
#include <boost/geometry/srs/projections/impl/base_static.hpp>
#include <boost/geometry/srs/projections/impl/base_dynamic.hpp>
#include <boost/geometry/srs/projections/impl/projects.hpp>
#include <boost/geometry/srs/projections/impl/factory_entry.hpp>
#include <boost/geometry/srs/projections/impl/pj_param.hpp>
namespace boost { namespace geometry
{
namespace projections
{
#ifndef DOXYGEN_NO_DETAIL
namespace detail { namespace geos
{
template <typename T>
struct par_geos
{
T h;
T radius_p;
T radius_p2;
T radius_p_inv2;
T radius_g;
T radius_g_1;
T C;
bool flip_axis;
};
template <typename T, typename Parameters>
struct base_geos_ellipsoid
{
par_geos<T> m_proj_parm;
// FORWARD(e_forward) ellipsoid
// Project coordinates from geographic (lon, lat) to cartesian (x, y)
inline void fwd(Parameters const& , T const& lp_lon, T lp_lat, T& xy_x, T& xy_y) const
{
T r, Vx, Vy, Vz, tmp;
/* Calculation of geocentric latitude. */
lp_lat = atan (this->m_proj_parm.radius_p2 * tan (lp_lat));
/* Calculation of the three components of the vector from satellite to
** position on earth surface (lon,lat).*/
r = (this->m_proj_parm.radius_p) / boost::math::hypot(this->m_proj_parm.radius_p * cos (lp_lat), sin (lp_lat));
Vx = r * cos (lp_lon) * cos (lp_lat);
Vy = r * sin (lp_lon) * cos (lp_lat);
Vz = r * sin (lp_lat);
/* Check visibility. */
if (((this->m_proj_parm.radius_g - Vx) * Vx - Vy * Vy - Vz * Vz * this->m_proj_parm.radius_p_inv2) < 0.) {
BOOST_THROW_EXCEPTION( projection_exception(error_tolerance_condition) );
}
/* Calculation based on view angles from satellite. */
tmp = this->m_proj_parm.radius_g - Vx;
if(this->m_proj_parm.flip_axis) {
xy_x = this->m_proj_parm.radius_g_1 * atan (Vy / boost::math::hypot (Vz, tmp));
xy_y = this->m_proj_parm.radius_g_1 * atan (Vz / tmp);
} else {
xy_x = this->m_proj_parm.radius_g_1 * atan (Vy / tmp);
xy_y = this->m_proj_parm.radius_g_1 * atan (Vz / boost::math::hypot (Vy, tmp));
}
}
// INVERSE(e_inverse) ellipsoid
// Project coordinates from cartesian (x, y) to geographic (lon, lat)
inline void inv(Parameters const& , T const& xy_x, T const& xy_y, T& lp_lon, T& lp_lat) const
{
T Vx, Vy, Vz, a, b, det, k;
/* Setting three components of vector from satellite to position.*/
Vx = -1.0;
if(this->m_proj_parm.flip_axis) {
Vz = tan (xy_y / this->m_proj_parm.radius_g_1);
Vy = tan (xy_x / this->m_proj_parm.radius_g_1) * boost::math::hypot(1.0, Vz);
} else {
Vy = tan (xy_x / this->m_proj_parm.radius_g_1);
Vz = tan (xy_y / this->m_proj_parm.radius_g_1) * boost::math::hypot(1.0, Vy);
}
/* Calculation of terms in cubic equation and determinant.*/
a = Vz / this->m_proj_parm.radius_p;
a = Vy * Vy + a * a + Vx * Vx;
b = 2 * this->m_proj_parm.radius_g * Vx;
if ((det = (b * b) - 4 * a * this->m_proj_parm.C) < 0.) {
BOOST_THROW_EXCEPTION( projection_exception(error_tolerance_condition) );
}
/* Calculation of three components of vector from satellite to position.*/
k = (-b - sqrt(det)) / (2. * a);
Vx = this->m_proj_parm.radius_g + k * Vx;
Vy *= k;
Vz *= k;
/* Calculation of longitude and latitude.*/
lp_lon = atan2 (Vy, Vx);
lp_lat = atan (Vz * cos (lp_lon) / Vx);
lp_lat = atan (this->m_proj_parm.radius_p_inv2 * tan (lp_lat));
}
static inline std::string get_name()
{
return "geos_ellipsoid";
}
};
template <typename T, typename Parameters>
struct base_geos_spheroid
{
par_geos<T> m_proj_parm;
// FORWARD(s_forward) spheroid
// Project coordinates from geographic (lon, lat) to cartesian (x, y)
inline void fwd(Parameters const& , T const& lp_lon, T const& lp_lat, T& xy_x, T& xy_y) const
{
T Vx, Vy, Vz, tmp;
/* Calculation of the three components of the vector from satellite to
** position on earth surface (lon,lat).*/
tmp = cos(lp_lat);
Vx = cos (lp_lon) * tmp;
Vy = sin (lp_lon) * tmp;
Vz = sin (lp_lat);
/* Check visibility.*/
// TODO: in proj4 5.0.0 this check is not present
if (((this->m_proj_parm.radius_g - Vx) * Vx - Vy * Vy - Vz * Vz) < 0.)
BOOST_THROW_EXCEPTION( projection_exception(error_tolerance_condition) );
/* Calculation based on view angles from satellite.*/
tmp = this->m_proj_parm.radius_g - Vx;
if(this->m_proj_parm.flip_axis) {
xy_x = this->m_proj_parm.radius_g_1 * atan(Vy / boost::math::hypot(Vz, tmp));
xy_y = this->m_proj_parm.radius_g_1 * atan(Vz / tmp);
} else {
xy_x = this->m_proj_parm.radius_g_1 * atan(Vy / tmp);
xy_y = this->m_proj_parm.radius_g_1 * atan(Vz / boost::math::hypot(Vy, tmp));
}
}
// INVERSE(s_inverse) spheroid
// Project coordinates from cartesian (x, y) to geographic (lon, lat)
inline void inv(Parameters const& , T const& xy_x, T const& xy_y, T& lp_lon, T& lp_lat) const
{
T Vx, Vy, Vz, a, b, det, k;
/* Setting three components of vector from satellite to position.*/
Vx = -1.0;
if(this->m_proj_parm.flip_axis) {
Vz = tan (xy_y / (this->m_proj_parm.radius_g - 1.0));
Vy = tan (xy_x / (this->m_proj_parm.radius_g - 1.0)) * sqrt (1.0 + Vz * Vz);
} else {
Vy = tan (xy_x / (this->m_proj_parm.radius_g - 1.0));
Vz = tan (xy_y / (this->m_proj_parm.radius_g - 1.0)) * sqrt (1.0 + Vy * Vy);
}
/* Calculation of terms in cubic equation and determinant.*/
a = Vy * Vy + Vz * Vz + Vx * Vx;
b = 2 * this->m_proj_parm.radius_g * Vx;
if ((det = (b * b) - 4 * a * this->m_proj_parm.C) < 0.) {
BOOST_THROW_EXCEPTION( projection_exception(error_tolerance_condition) );
}
/* Calculation of three components of vector from satellite to position.*/
k = (-b - sqrt(det)) / (2 * a);
Vx = this->m_proj_parm.radius_g + k * Vx;
Vy *= k;
Vz *= k;
/* Calculation of longitude and latitude.*/
lp_lon = atan2 (Vy, Vx);
lp_lat = atan (Vz * cos (lp_lon) / Vx);
}
static inline std::string get_name()
{
return "geos_spheroid";
}
};
inline bool geos_flip_axis(srs::detail::proj4_parameters const& params)
{
std::string sweep_axis = pj_get_param_s(params, "sweep");
if (sweep_axis.empty())
return false;
else {
if (sweep_axis[1] != '\0' || (sweep_axis[0] != 'x' && sweep_axis[0] != 'y'))
BOOST_THROW_EXCEPTION( projection_exception(error_invalid_sweep_axis) );
if (sweep_axis[0] == 'x')
return true;
else
return false;
}
}
template <typename T>
inline bool geos_flip_axis(srs::dpar::parameters<T> const& params)
{
typename srs::dpar::parameters<T>::const_iterator
it = pj_param_find(params, srs::dpar::sweep);
if (it == params.end()) {
return false;
} else {
srs::dpar::value_sweep s = static_cast<srs::dpar::value_sweep>(it->template get_value<int>());
return s == srs::dpar::sweep_x;
}
}
// Geostationary Satellite View
template <typename Params, typename Parameters, typename T>
inline void setup_geos(Params const& params, Parameters& par, par_geos<T>& proj_parm)
{
std::string sweep_axis;
if ((proj_parm.h = pj_get_param_f<T, srs::spar::h>(params, "h", srs::dpar::h)) <= 0.)
BOOST_THROW_EXCEPTION( projection_exception(error_h_less_than_zero) );
if (par.phi0 != 0.0)
BOOST_THROW_EXCEPTION( projection_exception(error_unknown_prime_meridian) );
proj_parm.flip_axis = geos_flip_axis(params);
proj_parm.radius_g_1 = proj_parm.h / par.a;
proj_parm.radius_g = 1. + proj_parm.radius_g_1;
proj_parm.C = proj_parm.radius_g * proj_parm.radius_g - 1.0;
if (par.es != 0.0) {
proj_parm.radius_p = sqrt (par.one_es);
proj_parm.radius_p2 = par.one_es;
proj_parm.radius_p_inv2 = par.rone_es;
} else {
proj_parm.radius_p = proj_parm.radius_p2 = proj_parm.radius_p_inv2 = 1.0;
}
}
}} // namespace detail::geos
#endif // doxygen
/*!
\brief Geostationary Satellite View projection
\ingroup projections
\tparam Geographic latlong point type
\tparam Cartesian xy point type
\tparam Parameters parameter type
\par Projection characteristics
- Azimuthal
- Spheroid
- Ellipsoid
\par Projection parameters
- h: Height (real)
- sweep: Sweep axis ('x' or 'y') (string)
\par Example
\image html ex_geos.gif
*/
template <typename T, typename Parameters>
struct geos_ellipsoid : public detail::geos::base_geos_ellipsoid<T, Parameters>
{
template <typename Params>
inline geos_ellipsoid(Params const& params, Parameters const& par)
{
detail::geos::setup_geos(params, par, this->m_proj_parm);
}
};
/*!
\brief Geostationary Satellite View projection
\ingroup projections
\tparam Geographic latlong point type
\tparam Cartesian xy point type
\tparam Parameters parameter type
\par Projection characteristics
- Azimuthal
- Spheroid
- Ellipsoid
\par Projection parameters
- h: Height (real)
- sweep: Sweep axis ('x' or 'y') (string)
\par Example
\image html ex_geos.gif
*/
template <typename T, typename Parameters>
struct geos_spheroid : public detail::geos::base_geos_spheroid<T, Parameters>
{
template <typename Params>
inline geos_spheroid(Params const& params, Parameters const& par)
{
detail::geos::setup_geos(params, par, this->m_proj_parm);
}
};
#ifndef DOXYGEN_NO_DETAIL
namespace detail
{
// Static projection
BOOST_GEOMETRY_PROJECTIONS_DETAIL_STATIC_PROJECTION_FI2(srs::spar::proj_geos, geos_spheroid, geos_ellipsoid)
// Factory entry(s)
BOOST_GEOMETRY_PROJECTIONS_DETAIL_FACTORY_ENTRY_FI2(geos_entry, geos_spheroid, geos_ellipsoid)
BOOST_GEOMETRY_PROJECTIONS_DETAIL_FACTORY_INIT_BEGIN(geos_init)
{
BOOST_GEOMETRY_PROJECTIONS_DETAIL_FACTORY_INIT_ENTRY(geos, geos_entry);
}
} // namespace detail
#endif // doxygen
} // namespace projections
}} // namespace boost::geometry
#endif // BOOST_GEOMETRY_PROJECTIONS_GEOS_HPP
| [
"yanhua133@126.com"
] | yanhua133@126.com |
744d7e9b77197eaa19dfa3cd25aadc97291c9d3e | d001abba19711d678f2ba09dfbd5c84357be6bb0 | /src/contest/codeforces/194div1/B.cpp | cb4789d3789a0d4d6079233d9eb7d7ad4981d8aa | [] | no_license | cormoran/CompetitiveProgramming | 89f8b3ceda97985d32b8cd91056b49abeb243e6f | fa0e479ab299f53984fa7541d088c10c447fb6e4 | refs/heads/master | 2020-04-17T19:59:49.724498 | 2020-03-28T15:46:26 | 2020-03-28T15:46:26 | 65,995,023 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 933 | cpp | //#include<bits/stdc++.h>
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#include<string>
#include<cmath>
#include<cassert>
#include<map>
using namespace std;
typedef pair<int,int> pii;
typedef long long ll;
typedef ll int__;
#define rep(i,j) for(int__ (i)=0;(i)<(j);(i)++)
#define repeat(i,j,k) for(int__ i=(j);i<(k);(i)++)
#define all(v) v.begin(),v.end()
int main()
{
int n,m;
cin>>n>>m;
vector<vector<bool>> B(n,vector<bool>(n,false));
rep(i,m){
int x,y;
cin>>x>>y;
B[x-1][y-1]=true;
}
int ans=0;
rep(i,n){
if(i==0||i==n-1)continue;
bool flg[2]={};
rep(j,n){
flg[0]|=B[i][j];
flg[1]|=B[j][i];
}
if(n%2==1 && i==n/2){
if(!flg[0])ans++;
else if(!flg[1])ans++;
}else{
if(!flg[0])ans++;
if(!flg[1])ans++;
}
}
cout<<ans<<endl;
return 0;
}
| [
"cormoran707@gmail.com"
] | cormoran707@gmail.com |
ec451718dfd92a556a2bab87ad89a96585e7e8b4 | 1e4eb5d90dac4ca7c620c150b8d05701dc8920f2 | /grammar-infer/include/DomTreePass.h | 42f7bac6df9bad2280543d932a47f1f45645341e | [
"MIT"
] | permissive | Microsvuln/grammar-infer | 4c609feea93288dd6f68befbcf7dc9ce7ddde605 | 5db1a4010c3ab7d80a10f0e8e2637b38c29e7c34 | refs/heads/master | 2021-12-15T05:00:42.000766 | 2017-07-27T00:41:15 | 2017-07-27T00:41:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 911 | h |
#ifndef DOM_TREE_PASS_H
#define DOM_TREE_PASS_H
#include "llvm/IR/Module.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/Pass.h"
#include "llvm/Analysis/PostDominators.h"
namespace giprofiler {
struct DomTreePass : public llvm::FunctionPass {
static char ID;
static std::string passName;
std::unique_ptr<llvm::PostDominatorTreeWrapperPass> pdtwp;
llvm::PostDominatorTree *pdt;
llvm::Function* f;
llvm::DenseMap<llvm::BasicBlock*, unsigned> basicBlockIDMap;
DomTreePass() : llvm::FunctionPass(ID) { }
virtual const char*
getPassName() const override {
return DomTreePass::passName.c_str();
}
std::vector<llvm::Instruction*> immediatePostDominators(
llvm::Function *fn, llvm::Instruction *def
);
bool immediatePostDominates(llvm::Instruction *def, llvm::Instruction *use);
bool runOnFunction(llvm::Function& f) override;
};
}
#endif | [
"salehen.rahman@gmail.com"
] | salehen.rahman@gmail.com |
514b902a9095316d301cea8a6dd22ad9fa229567 | 7becf7c6b16bc756eeb32a77f76eb14d5f702190 | /normal_cplusplus/cpp_normal/template_err_case1.h | 713357a34a02972281057f78984c13d7977883af | [] | no_license | dajunx/code_snippets | fe0efa9a348a3e937cd830a76aa7320851fd6c1f | 71da90dabbb79b804b7f544149e1c1420609c8ca | refs/heads/master | 2021-07-13T05:59:18.581525 | 2020-06-06T08:56:19 | 2020-06-06T08:56:19 | 159,127,330 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,693 | h | /*
测试 template
编程容易出现的一个问题。尚不能描述错处的原因，只知道当template和typedef有冲突的case。
TODO 待研究
*/
#include "cplusplus_common_def.hpp"
//header file.
//#include <boost/make_shared.hpp>
//#include <boost/shared_ptr.hpp>
//#include <iostream>
class base {
public:
base() {}
virtual ~base() {}
};
class child1 : public base {
public:
child1() {}
~child1() {}
void show() { std::cout << "child1" << std::endl; }
};
class child2 : public base {
public:
child2() {}
~child2() {}
void show() { std::cout << "child2" << std::endl; }
};
class test1 {
public:
test1() {}
~test1() {}
// 这个地方会让下面函数 typename
typedef child1 des;
template <typename des> void fun1(boost::shared_ptr<base> const &ptr_base);
// ps:若把上述两行逻辑修改为如下实现，则child2 调用
// fun1函数能够正常调用show函数
// template <typename child1> void fun1(boost::shared_ptr<base> const
// &ptr_base);
};
template <typename des>
void test1::fun1(boost::shared_ptr<base> const &ptr_base) {
boost::shared_ptr<des> ptr_ch = boost::dynamic_pointer_cast<des>(ptr_base);
if (ptr_ch) {
ptr_ch->show();
} else {
int i = 0;
}
}
bool test_template_err_case1() {
boost::shared_ptr<child1> ptr_ch1 = boost::make_shared<child1>();
boost::shared_ptr<child2> ptr_ch2 = boost::make_shared<child2>();
test1 tt;
tt.fun1<child1>(boost::dynamic_pointer_cast<base>(ptr_ch1));
// 在当前程序编码环境下，如下调用fun1函数 会造成
// ptr_ch为NULL的情况，原因待探究
tt.fun1<child2>(boost::dynamic_pointer_cast<base>(ptr_ch2));
return true;
} | [
"892888763@qq.com"
] | 892888763@qq.com |
66723dec06b4363e1db1b87fa6c344bccca7d59b | ce21f8fbacb8c2154218ed1f48f0857ab0be72b6 | /src/crypto/elliptic_secp256k1.cpp | 5db15008ffd9df63b3d123e70b185841bb7609c3 | [] | no_license | cyvasia/fc | f2468a795796166c8217cff5f37d3c3d37b97a8a | fa6cc117884a24493b1c556e0d413d9660ec2114 | refs/heads/master | 2020-09-20T04:54:49.914911 | 2019-11-27T08:28:29 | 2019-11-27T08:32:34 | 178,368,655 | 0 | 1 | null | 2019-03-29T08:53:47 | 2019-03-29T08:53:46 | null | UTF-8 | C++ | false | false | 27,808 | cpp | #include <fc/crypto/elliptic.hpp>
#include <fc/crypto/base58.hpp>
#include <fc/crypto/hmac.hpp>
#include <fc/crypto/openssl.hpp>
#include <fc/crypto/sha512.hpp>
#include <fc/fwd_impl.hpp>
#include <fc/exception/exception.hpp>
#include <fc/log/logger.hpp>
#include <assert.h>
#include <secp256k1.h>
#include <secp256k1_rangeproof.h>
#include <secp256k1_recovery.h>
#ifdef _MSC_VER
# include <malloc.h>
#else
# include <alloca.h>
#endif
#include "_elliptic_impl_priv.hpp"
namespace fc { namespace ecc {
namespace detail
{
const secp256k1_context* _get_context() {
static secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN /*| SECP256K1_CONTEXT_RANGEPROOF | SECP256K1_CONTEXT_COMMIT*/ );
return ctx;
}
void _init_lib() {
static const secp256k1_context* ctx = _get_context();
static int init_o = init_openssl();
(void)ctx;
(void)init_o;
}
class public_key_impl
{
public:
public_key_impl() BOOST_NOEXCEPT
{
_init_lib();
}
public_key_impl( const public_key_impl& cpy ) BOOST_NOEXCEPT
: _key( cpy._key )
{
_init_lib();
}
public_key_data _key;
};
typedef fc::array<char,37> chr37;
chr37 _derive_message( const public_key_data& key, int i );
fc::sha256 _left( const fc::sha512& v );
fc::sha256 _right( const fc::sha512& v );
const ec_group& get_curve();
const private_key_secret& get_curve_order();
const private_key_secret& get_half_curve_order();
}
static const public_key_data empty_pub;
static const private_key_secret empty_priv;
fc::sha512 private_key::get_shared_secret( const public_key& other )const
{
FC_ASSERT( my->_key != empty_priv );
FC_ASSERT( other.my->_key != empty_pub );
public_key_data pub(other.my->_key);
secp256k1_pubkey _pk;
size_t _sz = pub.size();
FC_ASSERT( secp256k1_ec_pubkey_parse( detail::_get_context(), &_pk, (unsigned char*) pub.begin(), pub.size()) );
FC_ASSERT( secp256k1_ec_pubkey_tweak_mul( detail::_get_context(), &_pk, (unsigned char*) my->_key.data() ) );
FC_ASSERT( secp256k1_ec_pubkey_serialize( detail::_get_context(), (unsigned char*) pub.begin(), &_sz, &_pk, SECP256K1_EC_COMPRESSED) );
return fc::sha512::hash( pub.begin() + 1, pub.size() - 1 );
}
public_key::public_key() {}
public_key::public_key( const public_key &pk ) : my( pk.my ) {}
public_key::public_key( public_key &&pk ) : my( std::move( pk.my ) ) {}
public_key::~public_key() {}
public_key& public_key::operator=( const public_key& pk )
{
my = pk.my;
return *this;
}
public_key& public_key::operator=( public_key&& pk )
{
my = pk.my;
return *this;
}
bool public_key::valid()const
{
return my->_key != empty_pub;
}
public_key public_key::add( const fc::sha256& digest )const
{
FC_ASSERT( my->_key != empty_pub );
public_key_data new_key;
memcpy( new_key.begin(), my->_key.begin(), new_key.size() );
secp256k1_pubkey _pk;
size_t _sz = new_key.size();
FC_ASSERT( secp256k1_ec_pubkey_parse( detail::_get_context(), &_pk, (unsigned char*) new_key.begin(), new_key.size()) );
FC_ASSERT( secp256k1_ec_pubkey_tweak_add( detail::_get_context(), &_pk, (unsigned char*) digest.data() ) );
FC_ASSERT( secp256k1_ec_pubkey_serialize( detail::_get_context(), (unsigned char*) new_key.begin(), &_sz, &_pk, SECP256K1_EC_COMPRESSED) );
return public_key( new_key );
}
std::string public_key::to_base58() const
{
FC_ASSERT( my->_key != empty_pub );
return to_base58( my->_key );
}
public_key_data public_key::serialize()const
{
FC_ASSERT( my->_key != empty_pub );
return my->_key;
}
public_key_point_data public_key::serialize_ecc_point()const
{
FC_ASSERT( my->_key != empty_pub );
public_key_point_data dat;
secp256k1_pubkey _pk;
size_t _sz = dat.size();
FC_ASSERT( secp256k1_ec_pubkey_parse( detail::_get_context(), &_pk, (unsigned char*) my->_key.begin(), my->_key.size()) );
FC_ASSERT( secp256k1_ec_pubkey_serialize( detail::_get_context(), (unsigned char*) dat.begin(), &_sz, &_pk, SECP256K1_EC_UNCOMPRESSED) );
FC_ASSERT( _sz == dat.size() );
return dat;
}
public_key::public_key( const public_key_point_data& dat )
{
const char* front = &dat.data[0];
if( *front == 0 ){}
else
{
EC_KEY *key = EC_KEY_new_by_curve_name( NID_secp256k1 );
key = o2i_ECPublicKey( &key, (const unsigned char**)&front, sizeof(dat) );
FC_ASSERT( key );
EC_KEY_set_conv_form( key, POINT_CONVERSION_COMPRESSED );
unsigned char* buffer = (unsigned char*) my->_key.begin();
i2o_ECPublicKey( key, &buffer ); // FIXME: questionable memory handling
EC_KEY_free( key );
}
}
public_key::public_key( const public_key_data& dat )
{
my->_key = dat;
}
public_key::public_key( const compact_signature& c, const fc::sha256& digest, bool check_canonical )
{
int nV = c.data[0];
if (nV >= 27 && nV < 31)
nV -= 27;
else if (nV >= 31 && nV < 35)
nV -= 31;
else
FC_THROW_EXCEPTION( exception, "unable to reconstruct public key from signature" );
if( check_canonical )
{
FC_ASSERT( is_canonical( c ), "signature is not canonical" );
}
auto _sz = my->_key.size();
secp256k1_ecdsa_recoverable_signature sig;
if(secp256k1_ecdsa_recoverable_signature_parse_compact( detail::_get_context(), &sig, c.begin() + 1, nV ))
{
secp256k1_pubkey pubkey;
FC_ASSERT( secp256k1_ecdsa_recover( detail::_get_context(), &pubkey, &sig, (unsigned char*) digest.data()) );
FC_ASSERT( secp256k1_ec_pubkey_serialize( detail::_get_context(), (unsigned char*) my->_key.begin(), &_sz, &pubkey, SECP256K1_EC_COMPRESSED) );
}
FC_ASSERT( _sz == my->_key.size() );
}
extended_public_key::extended_public_key( const public_key& k, const fc::sha256& c,
int child, int parent, uint8_t depth )
: public_key(k), c(c), child_num(child), parent_fp(parent), depth(depth) { }
extended_public_key extended_public_key::derive_normal_child(int i) const
{
hmac_sha512 mac;
public_key_data key = serialize();
const detail::chr37 data = detail::_derive_message( key, i );
fc::sha512 l = mac.digest( c.data(), c.data_size(), data.begin(), data.size() );
fc::sha256 left = detail::_left(l);
FC_ASSERT( left < detail::get_curve_order() );
secp256k1_pubkey _pk;
size_t _sz = key.size();
FC_ASSERT( secp256k1_ec_pubkey_parse( detail::_get_context(), &_pk, (unsigned char*) key.begin(), key.size()) );
FC_ASSERT( secp256k1_ec_pubkey_tweak_add( detail::_get_context(), &_pk, (unsigned char*) left.data() ) > 0 );
FC_ASSERT( secp256k1_ec_pubkey_serialize( detail::_get_context(), (unsigned char*) key.begin(), &_sz, &_pk, SECP256K1_EC_COMPRESSED) );
// FIXME: check validity - if left + key == infinity then invalid
extended_public_key result( key, detail::_right(l), i, fingerprint(), depth + 1 );
return result;
}
static void to_bignum( const unsigned char* in, ssl_bignum& out, unsigned int len )
{
if ( *in & 0x80 )
{
unsigned char *buffer = (unsigned char*)alloca(len + 1);
*buffer = 0;
memcpy( buffer + 1, in, len );
BN_bin2bn( buffer, sizeof(buffer), out );
}
else
{
BN_bin2bn( in, len, out );
}
}
static void to_bignum( const private_key_secret& in, ssl_bignum& out )
{
to_bignum( (unsigned char*) in.data(), out, in.data_size() );
}
static void from_bignum( const ssl_bignum& in, unsigned char* out, unsigned int len )
{
unsigned int l = BN_num_bytes( in );
if ( l > len )
{
unsigned char *buffer = (unsigned char*)alloca(l);
BN_bn2bin( in, buffer );
memcpy( out, buffer + l - len, len );
}
else
{
memset( out, 0, len - l );
BN_bn2bin( in, out + len - l );
}
}
static void from_bignum( const ssl_bignum& in, private_key_secret& out )
{
from_bignum( in, (unsigned char*) out.data(), out.data_size() );
}
static void invert( const private_key_secret& in, private_key_secret& out )
{
ssl_bignum bn_in;
to_bignum( in, bn_in );
ssl_bignum bn_n;
to_bignum( detail::get_curve_order(), bn_n );
ssl_bignum bn_inv;
bn_ctx ctx( BN_CTX_new() );
FC_ASSERT( BN_mod_inverse( bn_inv, bn_in, bn_n, ctx ) );
from_bignum( bn_inv, out );
}
static void to_point( const public_key_data& in, ec_point& out )
{
bn_ctx ctx( BN_CTX_new() );
const ec_group& curve = detail::get_curve();
private_key_secret x;
memcpy( x.data(), in.begin() + 1, x.data_size() );
ssl_bignum bn_x;
to_bignum( x, bn_x );
FC_ASSERT( EC_POINT_set_compressed_coordinates_GFp( curve, out, bn_x, *in.begin() & 1, ctx ) > 0 );
}
static void from_point( const ec_point& in, public_key_data& out )
{
bn_ctx ctx( BN_CTX_new() );
const ec_group& curve = detail::get_curve();
ssl_bignum bn_x;
ssl_bignum bn_y;
FC_ASSERT( EC_POINT_get_affine_coordinates_GFp( curve, in, bn_x, bn_y, ctx ) > 0 );
private_key_secret x;
from_bignum( bn_x, x );
memcpy( out.begin() + 1, x.data(), out.size() - 1 );
*out.begin() = BN_is_bit_set( bn_y, 0 ) ? 3 : 2;
}
// static void print(const unsigned char* data) {
// for (int i = 0; i < 32; i++) {
// printf("%02x", *data++);
// }
// }
//
// static void print(private_key_secret key) {
// print((unsigned char*) key.data());
// }
//
// static void print(public_key_data key) {
// print((unsigned char*) key.begin() + 1);
// }
static void canonicalize( unsigned char *int256 )
{
fc::sha256 biggi( (char*) int256, 32 );
if ( detail::get_half_curve_order() >= biggi )
{
return; // nothing to do
}
ssl_bignum bn_k;
to_bignum( int256, bn_k, 32 );
ssl_bignum bn_n;
to_bignum( detail::get_curve_order(), bn_n );
FC_ASSERT( BN_sub( bn_k, bn_n, bn_k ) );
from_bignum( bn_k, int256, 32 );
}
static public_key compute_k( const private_key_secret& a, const private_key_secret& c,
const public_key& p )
{
private_key_secret prod = a;
FC_ASSERT( secp256k1_ec_privkey_tweak_mul( detail::_get_context(), (unsigned char*) prod.data(), (unsigned char*) c.data() ) > 0 );
invert( prod, prod );
public_key_data P = p.serialize();
secp256k1_pubkey _pk;
size_t _sz = P.size();
FC_ASSERT( secp256k1_ec_pubkey_parse( detail::_get_context(), &_pk, (unsigned char*) P.begin(), P.size()) );
FC_ASSERT( secp256k1_ec_pubkey_tweak_mul( detail::_get_context(), &_pk, (unsigned char*) prod.data() ) );
FC_ASSERT( secp256k1_ec_pubkey_serialize( detail::_get_context(), (unsigned char*) P.begin(), &_sz, &_pk, SECP256K1_EC_COMPRESSED) );
// printf("K: "); print(P); printf("\n");
return public_key( P );
}
static public_key compute_t( const private_key_secret& a, const private_key_secret& b,
const private_key_secret& c, const private_key_secret& d,
const public_key_data& p, const public_key_data& q )
{
private_key_secret prod;
invert( c, prod ); // prod == c^-1
FC_ASSERT( secp256k1_ec_privkey_tweak_mul( detail::_get_context(), (unsigned char*) prod.data(), (unsigned char*) d.data() ) > 0 );
// prod == c^-1 * d
public_key_data accu = p;
secp256k1_pubkey _pk;
size_t _sz = accu.size();
FC_ASSERT( secp256k1_ec_pubkey_parse( detail::_get_context(), &_pk, (unsigned char*) accu.begin(), accu.size()) );
FC_ASSERT( secp256k1_ec_pubkey_tweak_mul( detail::_get_context(), &_pk, (unsigned char*) prod.data() ) );
FC_ASSERT( secp256k1_ec_pubkey_serialize( detail::_get_context(), (unsigned char*) accu.begin(), &_sz, &_pk, SECP256K1_EC_COMPRESSED) );
// accu == prod * P == c^-1 * d * P
ec_point point_accu( EC_POINT_new( detail::get_curve() ) );
to_point( accu, point_accu );
ec_point point_q( EC_POINT_new( detail::get_curve() ) );
to_point( q, point_q );
bn_ctx ctx(BN_CTX_new());
FC_ASSERT( EC_POINT_add( detail::get_curve(), point_accu, point_accu, point_q, ctx ) > 0 );
from_point( point_accu, accu );
// accu == c^-1 * a * P + Q
FC_ASSERT( secp256k1_ec_pubkey_parse( detail::_get_context(), &_pk, (unsigned char*) accu.begin(), accu.size()) );
FC_ASSERT( secp256k1_ec_pubkey_tweak_add( detail::_get_context(), &_pk, (unsigned char*) b.data() ) );
FC_ASSERT( secp256k1_ec_pubkey_serialize( detail::_get_context(), (unsigned char*) accu.begin(), &_sz, &_pk, SECP256K1_EC_COMPRESSED) );
// accu == c^-1 * a * P + Q + b*G
public_key_data k = compute_k( a, c, p ).serialize();
memcpy( prod.data(), k.begin() + 1, prod.data_size() );
// prod == Kx
FC_ASSERT( secp256k1_ec_privkey_tweak_mul( detail::_get_context(), (unsigned char*) prod.data(), (unsigned char*) a.data() ) > 0 );
// prod == Kx * a
invert( prod, prod );
// prod == (Kx * a)^-1
FC_ASSERT( secp256k1_ec_pubkey_parse( detail::_get_context(), &_pk, (unsigned char*) accu.begin(), accu.size()) );
FC_ASSERT( secp256k1_ec_pubkey_tweak_mul( detail::_get_context(), &_pk, (unsigned char*) prod.data() ) );
FC_ASSERT( secp256k1_ec_pubkey_serialize( detail::_get_context(), (unsigned char*) accu.begin(), &_sz, &_pk, SECP256K1_EC_COMPRESSED) );
// accu == (c^-1 * a * P + Q + b*G) * (Kx * a)^-1
// printf("T: "); print(accu); printf("\n");
return public_key( accu );
}
extended_private_key::extended_private_key( const private_key& k, const sha256& c,
int child, int parent, uint8_t depth )
: private_key(k), c(c), child_num(child), parent_fp(parent), depth(depth) { }
extended_private_key extended_private_key::private_derive_rest( const fc::sha512& hash,
int i) const
{
fc::sha256 left = detail::_left(hash);
FC_ASSERT( left < detail::get_curve_order() );
FC_ASSERT( secp256k1_ec_privkey_tweak_add( detail::_get_context(), (unsigned char*) left.data(), (unsigned char*) get_secret().data() ) > 0 );
extended_private_key result( private_key::regenerate( left ), detail::_right(hash),
i, fingerprint(), depth + 1 );
return result;
}
public_key extended_private_key::blind_public_key( const extended_public_key& bob, int i ) const
{
private_key_secret a = generate_a(i).get_secret();
private_key_secret b = generate_b(i).get_secret();
private_key_secret c = generate_c(i).get_secret();
private_key_secret d = generate_d(i).get_secret();
public_key_data p = bob.generate_p(i).serialize();
public_key_data q = bob.generate_q(i).serialize();
// printf("a: "); print(a); printf("\n");
// printf("b: "); print(b); printf("\n");
// printf("c: "); print(c); printf("\n");
// printf("d: "); print(d); printf("\n");
// printf("P: "); print(p); printf("\n");
// printf("Q: "); print(q); printf("\n");
return compute_t( a, b, c, d, p, q );
}
blinded_hash extended_private_key::blind_hash( const fc::sha256& hash, int i ) const
{
private_key_secret a = generate_a(i).get_secret();
private_key_secret b = generate_b(i).get_secret();
FC_ASSERT( secp256k1_ec_privkey_tweak_mul( detail::_get_context(), (unsigned char*) a.data(), (unsigned char*) hash.data() ) > 0 );
FC_ASSERT( secp256k1_ec_privkey_tweak_add( detail::_get_context(), (unsigned char*) a.data(), (unsigned char*) b.data() ) > 0 );
// printf("hash: "); print(hash); printf("\n");
// printf("blinded: "); print(a); printf("\n");
return a;
}
private_key_secret extended_private_key::compute_p( int i ) const
{
private_key_secret p_inv = derive_normal_child( 2*i ).get_secret();
invert( p_inv, p_inv );
// printf("p: "); print(p_inv); printf("\n");
return p_inv;
}
private_key_secret extended_private_key::compute_q( int i, const private_key_secret& p ) const
{
private_key_secret q = derive_normal_child( 2*i + 1 ).get_secret();
FC_ASSERT( secp256k1_ec_privkey_tweak_mul( detail::_get_context(), (unsigned char*) q.data(), (unsigned char*) p.data() ) > 0 );
// printf("q: "); print(q); printf("\n");
return q;
}
blind_signature extended_private_key::blind_sign( const blinded_hash& hash, int i ) const
{
private_key_secret p = compute_p( i );
private_key_secret q = compute_q( i, p );
FC_ASSERT( secp256k1_ec_privkey_tweak_mul( detail::_get_context(), (unsigned char*) p.data(), (unsigned char*) hash.data() ) > 0 );
FC_ASSERT( secp256k1_ec_privkey_tweak_add( detail::_get_context(), (unsigned char*) p.data(), (unsigned char*) q.data() ) > 0 );
// printf("blind_sig: "); print(p); printf("\n");
return p;
}
compact_signature extended_private_key::unblind_signature( const extended_public_key& bob,
const blind_signature& sig,
const fc::sha256& hash,
int i ) const
{
private_key_secret a = generate_a(i).get_secret();
private_key_secret b = generate_b(i).get_secret();
private_key_secret c = generate_c(i).get_secret();
private_key_secret d = generate_d(i).get_secret();
public_key p = bob.generate_p(i);
public_key q = bob.generate_q(i);
public_key_data k = compute_k( a, c, p );
public_key_data t = compute_t( a, b, c, d, p, q ).serialize();
FC_ASSERT( secp256k1_ec_privkey_tweak_mul( detail::_get_context(), (unsigned char*) c.data(), (unsigned char*) sig.data() ) > 0 );
FC_ASSERT( secp256k1_ec_privkey_tweak_add( detail::_get_context(), (unsigned char*) c.data(), (unsigned char*) d.data() ) > 0 );
compact_signature result;
memcpy( result.begin() + 1, k.begin() + 1, 32 );
memcpy( result.begin() + 33, c.data(), 32 );
canonicalize( result.begin() + 33 );
// printf("unblinded: "); print(result.begin() + 33); printf("\n");
for ( int i = 0; i < 4; i++ )
{
secp256k1_ecdsa_recoverable_signature sig;
if(secp256k1_ecdsa_recoverable_signature_parse_compact( detail::_get_context(), &sig, result.begin() + 1, i ))
{
secp256k1_pubkey pubkey;
if (secp256k1_ecdsa_recover( detail::_get_context(), &pubkey, &sig, (unsigned char*) hash.data() ))
{
public_key_data pub;
auto _sz = pub.size();
FC_ASSERT( secp256k1_ec_pubkey_serialize( detail::_get_context(), (unsigned char*) pub.begin(), &_sz, &pubkey, SECP256K1_EC_COMPRESSED) );
if ( 0 == memcmp( t.begin(), pub.begin(), _sz ) )
{
result.data[0] = 27 + 4 + i;
return result;
}
}
}
}
FC_ASSERT( 0, "Failed to unblind - use different i" );
}
commitment_type blind( const blind_factor_type& blind, uint64_t value )
{
commitment_type result;
secp256k1_pedersen_commitment _commit;
FC_ASSERT( secp256k1_pedersen_commit( detail::_get_context(), &_commit, (unsigned char*)&blind, value, secp256k1_generator_h ) );
FC_ASSERT( secp256k1_pedersen_commitment_serialize( detail::_get_context(), (unsigned char*) result.begin(), &_commit) );
return result;
}
commitment_type blind( blind_factor_type blind_factor, uint64_t blind_tweak, uint64_t value )
{
FC_ASSERT( blind_tweak );
blind_factor_type blind_tweak_;
memcpy(blind_tweak_.data(), &blind_tweak, sizeof (blind_tweak));
FC_ASSERT( secp256k1_ec_privkey_tweak_mul( detail::_get_context(), (unsigned char *) blind_factor.data(), (const unsigned char *) blind_tweak_.data()) );
return blind(blind_factor, value);
}
blind_factor_type blind_sum( const std::vector<blind_factor_type>& blinds_in, uint32_t non_neg )
{
blind_factor_type result;
std::vector<const unsigned char*> blinds(blinds_in.size());
for( uint32_t i = 0; i < blinds_in.size(); ++i ) blinds[i] = (const unsigned char*)&blinds_in[i];
FC_ASSERT( secp256k1_pedersen_blind_sum( detail::_get_context(), (unsigned char*)&result, blinds.data(), blinds_in.size(), non_neg ) );
return result;
}
/** verifies taht commnits + neg_commits + excess == 0 */
bool verify_sum( const std::vector<commitment_type>& commits_in, const std::vector<commitment_type>& neg_commits_in, int64_t excess )
{
std::vector<std::unique_ptr<secp256k1_pedersen_commitment>> pos, neg;
std::vector<secp256k1_pedersen_commitment*> _pos, _neg;
for (auto && c : commits_in)
{
std::unique_ptr<secp256k1_pedersen_commitment> _c(new secp256k1_pedersen_commitment);
FC_ASSERT( secp256k1_pedersen_commitment_parse(detail::_get_context(), _c.get(), (unsigned char*) c.begin()) );
pos.push_back(std::move(_c));
}
for (auto && c : neg_commits_in)
{
std::unique_ptr<secp256k1_pedersen_commitment> _c(new secp256k1_pedersen_commitment);
FC_ASSERT( secp256k1_pedersen_commitment_parse(detail::_get_context(), _c.get(), (unsigned char*) c.begin()) );
neg.push_back(std::move(_c));
}
if ( 0 != excess )
{
std::unique_ptr<secp256k1_pedersen_commitment> _commit(new secp256k1_pedersen_commitment);
blind_factor_type blind;
FC_ASSERT( secp256k1_pedersen_commit( detail::_get_context(), _commit.get(), (unsigned char*)blind.data(), excess, secp256k1_generator_h ) );
if (excess > 0)
neg.push_back(std::move(_commit));
else
pos.push_back(std::move(_commit));
}
for ( auto && p : pos)
_pos.push_back(p.get());
for ( auto && p : neg)
_neg.push_back(p.get());
return secp256k1_pedersen_verify_tally( detail::_get_context(), _pos.data(), _pos.size(), _neg.data(), _neg.size() );
}
bool verify_range( uint64_t& min_val, uint64_t& max_val, const commitment_type& commit, const std::vector<char>& proof )
{
secp256k1_pedersen_commitment _c;
FC_ASSERT( secp256k1_pedersen_commitment_parse(detail::_get_context(), &_c, (unsigned char*) commit.begin()) );
return secp256k1_rangeproof_verify(
detail::_get_context(),
&min_val,
&max_val,
&_c,
(const unsigned char *)proof.data(),
proof.size(),
nullptr,
0,
secp256k1_generator_h
);
}
std::vector<char> range_proof_sign( uint64_t min_value,
const commitment_type& commit,
const blind_factor_type& commit_blind,
const blind_factor_type& nonce,
int8_t base10_exp,
uint8_t min_bits,
uint64_t actual_value
)
{
size_t proof_len = 5134;
std::vector<char> proof(proof_len);
secp256k1_pedersen_commitment _c;
FC_ASSERT( secp256k1_pedersen_commitment_parse(detail::_get_context(), &_c, (unsigned char*) commit.begin()) );
FC_ASSERT( secp256k1_rangeproof_sign(
detail::_get_context(),
(unsigned char*)proof.data(),
&proof_len,
min_value,
&_c,
(const unsigned char*)&commit_blind,
(const unsigned char*)&nonce,
base10_exp,
min_bits,
actual_value,
nullptr, 0, nullptr, 0,
secp256k1_generator_h
));
proof.resize(proof_len);
return proof;
}
bool verify_range_proof_rewind( blind_factor_type& blind_out,
uint64_t& value_out,
string& message_out,
const blind_factor_type& nonce,
uint64_t& min_val,
uint64_t& max_val,
commitment_type commit,
const std::vector<char>& proof )
{
char msg[4096];
size_t mlen = 0;
secp256k1_pedersen_commitment _commit;
FC_ASSERT( secp256k1_pedersen_commitment_parse(detail::_get_context(), &_commit, (unsigned char*) commit.begin()) );
FC_ASSERT( secp256k1_rangeproof_rewind(
detail::_get_context(),
(unsigned char*)&blind_out,
&value_out,
(unsigned char*)msg,
&mlen,
(const unsigned char*)&nonce,
&min_val,
&max_val,
&_commit,
(const unsigned char*)proof.data(),
proof.size(),
nullptr,
0,
secp256k1_generator_h
));
message_out = std::string( msg, mlen );
return true;
}
range_proof_info range_get_info( const std::vector<char>& proof )
{
range_proof_info result;
FC_ASSERT( secp256k1_rangeproof_info( detail::_get_context(),
(int*)&result.exp,
(int*)&result.mantissa,
(uint64_t*)&result.min_value,
(uint64_t*)&result.max_value,
(const unsigned char*)proof.data(),
(int)proof.size() ) );
return result;
}
} }
| [
"gagikk@gmail.com"
] | gagikk@gmail.com |
086f16bdbad87cf7d0c4e5b18dc182f5d6f91465 | 7749ea76f93f93934720d4fe0685fa803f12e495 | /media/gpu/vaapi/vp9_vaapi_video_decoder_delegate.cc | 0c5837cb4b094a3cafa83f3e0d098248eacd9c8e | [
"BSD-3-Clause"
] | permissive | ofzo/chromium | 1dd7a8250455d8a5a6bf8862102df1574a7e5f7f | 3d96eb58fa564e3f21dbaccca476989b65876971 | refs/heads/master | 2023-04-26T07:15:17.707499 | 2020-09-17T09:11:54 | 2020-09-17T09:11:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,104 | cc | // Copyright 2018 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 "media/gpu/vaapi/vp9_vaapi_video_decoder_delegate.h"
#include <type_traits>
#include "base/stl_util.h"
#include "base/trace_event/trace_event.h"
#include "media/gpu/decode_surface_handler.h"
#include "media/gpu/macros.h"
#include "media/gpu/vaapi/va_surface.h"
#include "media/gpu/vaapi/vaapi_common.h"
#include "media/gpu/vaapi/vaapi_wrapper.h"
namespace media {
VP9VaapiVideoDecoderDelegate::VP9VaapiVideoDecoderDelegate(
DecodeSurfaceHandler<VASurface>* const vaapi_dec,
scoped_refptr<VaapiWrapper> vaapi_wrapper)
: VaapiVideoDecoderDelegate(vaapi_dec, std::move(vaapi_wrapper)) {}
VP9VaapiVideoDecoderDelegate::~VP9VaapiVideoDecoderDelegate() = default;
scoped_refptr<VP9Picture> VP9VaapiVideoDecoderDelegate::CreateVP9Picture() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
const auto va_surface = vaapi_dec_->CreateSurface();
if (!va_surface)
return nullptr;
return new VaapiVP9Picture(std::move(va_surface));
}
bool VP9VaapiVideoDecoderDelegate::SubmitDecode(
scoped_refptr<VP9Picture> pic,
const Vp9SegmentationParams& seg,
const Vp9LoopFilterParams& lf,
const Vp9ReferenceFrameVector& ref_frames,
base::OnceClosure done_cb) {
TRACE_EVENT0("media,gpu", "VP9VaapiVideoDecoderDelegate::SubmitDecode");
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// |done_cb| should be null as we return false from IsFrameContextRequired().
DCHECK(!done_cb);
VADecPictureParameterBufferVP9 pic_param;
memset(&pic_param, 0, sizeof(pic_param));
const Vp9FrameHeader* frame_hdr = pic->frame_hdr.get();
DCHECK(frame_hdr);
pic_param.frame_width = base::checked_cast<uint16_t>(frame_hdr->frame_width);
pic_param.frame_height =
base::checked_cast<uint16_t>(frame_hdr->frame_height);
CHECK_EQ(kVp9NumRefFrames, base::size(pic_param.reference_frames));
for (size_t i = 0; i < base::size(pic_param.reference_frames); ++i) {
auto ref_pic = ref_frames.GetFrame(i);
if (ref_pic) {
pic_param.reference_frames[i] =
ref_pic->AsVaapiVP9Picture()->GetVASurfaceID();
} else {
pic_param.reference_frames[i] = VA_INVALID_SURFACE;
}
}
#define FHDR_TO_PP_PF1(a) pic_param.pic_fields.bits.a = frame_hdr->a
#define FHDR_TO_PP_PF2(a, b) pic_param.pic_fields.bits.a = b
FHDR_TO_PP_PF2(subsampling_x, frame_hdr->subsampling_x == 1);
FHDR_TO_PP_PF2(subsampling_y, frame_hdr->subsampling_y == 1);
FHDR_TO_PP_PF2(frame_type, frame_hdr->IsKeyframe() ? 0 : 1);
FHDR_TO_PP_PF1(show_frame);
FHDR_TO_PP_PF1(error_resilient_mode);
FHDR_TO_PP_PF1(intra_only);
FHDR_TO_PP_PF1(allow_high_precision_mv);
FHDR_TO_PP_PF2(mcomp_filter_type, frame_hdr->interpolation_filter);
FHDR_TO_PP_PF1(frame_parallel_decoding_mode);
FHDR_TO_PP_PF1(reset_frame_context);
FHDR_TO_PP_PF1(refresh_frame_context);
FHDR_TO_PP_PF2(frame_context_idx, frame_hdr->frame_context_idx_to_save_probs);
FHDR_TO_PP_PF2(segmentation_enabled, seg.enabled);
FHDR_TO_PP_PF2(segmentation_temporal_update, seg.temporal_update);
FHDR_TO_PP_PF2(segmentation_update_map, seg.update_map);
FHDR_TO_PP_PF2(last_ref_frame, frame_hdr->ref_frame_idx[0]);
FHDR_TO_PP_PF2(last_ref_frame_sign_bias,
frame_hdr->ref_frame_sign_bias[Vp9RefType::VP9_FRAME_LAST]);
FHDR_TO_PP_PF2(golden_ref_frame, frame_hdr->ref_frame_idx[1]);
FHDR_TO_PP_PF2(golden_ref_frame_sign_bias,
frame_hdr->ref_frame_sign_bias[Vp9RefType::VP9_FRAME_GOLDEN]);
FHDR_TO_PP_PF2(alt_ref_frame, frame_hdr->ref_frame_idx[2]);
FHDR_TO_PP_PF2(alt_ref_frame_sign_bias,
frame_hdr->ref_frame_sign_bias[Vp9RefType::VP9_FRAME_ALTREF]);
FHDR_TO_PP_PF2(lossless_flag, frame_hdr->quant_params.IsLossless());
#undef FHDR_TO_PP_PF2
#undef FHDR_TO_PP_PF1
pic_param.filter_level = lf.level;
pic_param.sharpness_level = lf.sharpness;
pic_param.log2_tile_rows = frame_hdr->tile_rows_log2;
pic_param.log2_tile_columns = frame_hdr->tile_cols_log2;
pic_param.frame_header_length_in_bytes = frame_hdr->uncompressed_header_size;
pic_param.first_partition_size = frame_hdr->header_size_in_bytes;
SafeArrayMemcpy(pic_param.mb_segment_tree_probs, seg.tree_probs);
SafeArrayMemcpy(pic_param.segment_pred_probs, seg.pred_probs);
pic_param.profile = frame_hdr->profile;
pic_param.bit_depth = frame_hdr->bit_depth;
DCHECK((pic_param.profile == 0 && pic_param.bit_depth == 8) ||
(pic_param.profile == 2 && pic_param.bit_depth == 10));
VASliceParameterBufferVP9 slice_param;
memset(&slice_param, 0, sizeof(slice_param));
slice_param.slice_data_size = frame_hdr->frame_size;
slice_param.slice_data_offset = 0;
slice_param.slice_data_flag = VA_SLICE_DATA_FLAG_ALL;
static_assert(
std::extent<decltype(Vp9SegmentationParams::feature_enabled)>() ==
std::extent<decltype(slice_param.seg_param)>(),
"seg_param array of incorrect size");
for (size_t i = 0; i < base::size(slice_param.seg_param); ++i) {
VASegmentParameterVP9& seg_param = slice_param.seg_param[i];
#define SEG_TO_SP_SF(a, b) seg_param.segment_flags.fields.a = b
SEG_TO_SP_SF(
segment_reference_enabled,
seg.FeatureEnabled(i, Vp9SegmentationParams::SEG_LVL_REF_FRAME));
SEG_TO_SP_SF(segment_reference,
seg.FeatureData(i, Vp9SegmentationParams::SEG_LVL_REF_FRAME));
SEG_TO_SP_SF(segment_reference_skipped,
seg.FeatureEnabled(i, Vp9SegmentationParams::SEG_LVL_SKIP));
#undef SEG_TO_SP_SF
SafeArrayMemcpy(seg_param.filter_level, lf.lvl[i]);
seg_param.luma_dc_quant_scale = seg.y_dequant[i][0];
seg_param.luma_ac_quant_scale = seg.y_dequant[i][1];
seg_param.chroma_dc_quant_scale = seg.uv_dequant[i][0];
seg_param.chroma_ac_quant_scale = seg.uv_dequant[i][1];
}
if (!vaapi_wrapper_->SubmitBuffers(
{{VAPictureParameterBufferType, sizeof(pic_param), &pic_param},
{VASliceParameterBufferType, sizeof(slice_param), &slice_param},
{VASliceDataBufferType, frame_hdr->frame_size, frame_hdr->data}})) {
return false;
}
return vaapi_wrapper_->ExecuteAndDestroyPendingBuffers(
pic->AsVaapiVP9Picture()->va_surface()->id());
}
bool VP9VaapiVideoDecoderDelegate::OutputPicture(
scoped_refptr<VP9Picture> pic) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
const VaapiVP9Picture* vaapi_pic = pic->AsVaapiVP9Picture();
vaapi_dec_->SurfaceReady(vaapi_pic->va_surface(), vaapi_pic->bitstream_id(),
vaapi_pic->visible_rect(),
vaapi_pic->get_colorspace());
return true;
}
bool VP9VaapiVideoDecoderDelegate::IsFrameContextRequired() const {
return false;
}
bool VP9VaapiVideoDecoderDelegate::GetFrameContext(
scoped_refptr<VP9Picture> pic,
Vp9FrameContext* frame_ctx) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
NOTIMPLEMENTED() << "Frame context update not supported";
return false;
}
} // namespace media
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
a02af7b6c84450b3a727091739c974814a6a2e83 | 301ed54244fd41502fd6f23a2e016c6e0cfba2dd | /02 CONTESTS/Codeforces/ED96/B.cpp | 4fb2a8342bdf1754d637340c68ae7284ece41f4a | [] | no_license | iCodeIN/Competitive-Programming-4 | 660607a74c4a846340b6fb08316668057f75a7ba | 05b55d2736f6b22758cd57f3ed5093cf8a2f4e2f | refs/heads/master | 2023-02-22T12:53:39.878593 | 2021-01-28T10:57:50 | 2021-01-28T10:57:50 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,485 | cpp | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define INF (int) 9e18
#define HELL (int) (1e9 + 7)
#define int long long
#define double long double
#define uint unsigned long long
#define pii pair<int, int>
#define pb push_back
#define fs first
#define sc second
#define size(aa) (int) aa.size()
#define deb(xx) cerr << #xx << " => " << xx << "\n"
#define debp(aa) cerr << #aa << " => " <<"("<<aa.fs<<", "<<aa.sc<<") " << "\n";
#define deba(xx) cerr<<#xx<<"\n";for (auto z : xx) cerr << z << " "; cerr << "\n";
#define debpa(xx) cerr<<#xx<<"\n";for (auto z : xx)cerr<<"("<<z.fs<<", "<<z.sc<<") "; cerr << "\n";
#define debm(xx) cerr<<#xx<<"\n";for (auto z : xx){for(auto b : z) cerr << b << " "; cerr << "\n";}
#define getMat(xx, nn, mm, vall) vector<vector<int>> xx(nn, vector<int> (mm, vall))
#define fastio ios_base :: sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
#define pout cout << fixed << setprecision(10)
int fastpow(int a, int b, int m = HELL) { int res = 1; a %= m;
while (b > 0) { if (b & 1) res = (res * a) % m; a = (a * a) % m; b >>= 1; } return res;}
#define inv(a) fastpow(a, HELL - 2)
#define mul(a, b) ((a % HELL) * (b % HELL)) % HELL
int32_t main() { fastio;
int t; cin >> t;
while (t--) {
int n, k; cin >> n >> k;
vector<int> arr(n);
for (auto &a : arr) cin >> a;
sort(arr.begin(), arr.end(), greater<int>());
for (int i = 1; i < min(n, k + 1); i++) {
arr[0] += arr[i];
}
cout << arr[0] << endl;
}
return 0;
} | [
"yashjain0530@gmail.com"
] | yashjain0530@gmail.com |
9a8f2841a4bc6d4496f98197a55feadeccbdb84d | cb8e59744cec10f4833b2d67f3b0b67b0335dac0 | /depends/libyarn/src/rpc/SaslClient.h | 4cd77547072189884a14e5e36c5a3458ea8fcd6a | [
"Apache-2.0",
"PostgreSQL"
] | permissive | jiny2/incubator-hawq | 4349937b90e3883202a4d7ffe7335d35b0d78a48 | d6ac62b7c4569e9320e395beaa04db24e9e3b011 | refs/heads/master | 2021-01-15T19:13:09.913306 | 2015-10-10T03:10:12 | 2015-10-10T03:10:12 | 43,993,714 | 1 | 0 | null | 2015-10-10T04:18:24 | 2015-10-10T04:18:24 | null | UTF-8 | C++ | false | false | 1,183 | h | /********************************************************************
* Copyright (c) 2014, Pivotal Inc.
* All rights reserved.
*
* Author: Zhanwei Wang
********************************************************************/
#ifndef _HDFS_LIBHDFS3_RPC_SASLCLIENT_H_
#define _HDFS_LIBHDFS3_RPC_SASLCLIENT_H_
#include <gsasl.h>
#include "libyarncommon/Token.h"
#include "network/Socket.h"
#include "RpcAuth.h"
#include "YARNRpcHeader.pb.h"
namespace Yarn {
namespace Internal {
#define SWITCH_TO_SIMPLE_AUTH -88
class SaslClient {
public:
SaslClient(const hadoop::common::RpcSaslProto_SaslAuth & auth, const Token & token,
const std::string & principal);
~SaslClient();
std::string evaluateChallenge(const std::string & chanllege);
bool isComplete();
std::string getQOP();
private:
void initKerberos(const hadoop::common::RpcSaslProto_SaslAuth & auth,
const std::string & principal);
void initDigestMd5(const hadoop::common::RpcSaslProto_SaslAuth & auth, const Token & token);
private:
Gsasl * ctx;
Gsasl_session * session;
bool complete;
};
}
}
#endif /* _HDFS_LIBHDFS3_RPC_SASLCLIENT_H_ */
| [
"rvs@apache.org"
] | rvs@apache.org |
2a60a5553e50e5c40e421f1986f01b8ee8df5b64 | b122925a68dd997c9a9bc208fd0f53e4baa113de | /build/iOS/Preview1/include/Fuse.Gestures.DoubleClicked.h | 3602d4a7bf553edaee7cbe794c2e58d003382c71 | [] | no_license | samscislowicz/Lensy | e2ca1e5838176687299236bff23ef1f692a6504e | 69270bad64ee7e8884e322f8e9e481e314293d30 | refs/heads/master | 2021-01-25T01:03:05.456091 | 2017-06-23T23:29:30 | 2017-06-23T23:29:30 | 94,716,371 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,728 | h | // This file was generated based on '/Users/Sam/Library/Application Support/Fusetools/Packages/Fuse.Gestures/1.0.2/$.uno'.
// WARNING: Changes might be lost if you edit this file directly.
#pragma once
#include <Fuse.Animations.IBase-d3bd6f2e.h>
#include <Fuse.Animations.IUnwr-594abe9.h>
#include <Fuse.Binding.h>
#include <Fuse.Gestures.ClickerTrigger.h>
#include <Fuse.INotifyUnrooted.h>
#include <Fuse.IProperties.h>
#include <Fuse.Scripting.IScriptObject.h>
#include <Uno.Collections.ICollection-1.h>
#include <Uno.Collections.IEnumerable-1.h>
#include <Uno.Collections.IList-1.h>
namespace g{namespace Fuse{namespace Gestures{struct DoubleClicked;}}}
namespace g{namespace Fuse{namespace Input{struct PointerEventArgs;}}}
namespace g{
namespace Fuse{
namespace Gestures{
// public sealed class DoubleClicked :96
// {
::g::Fuse::Triggers::Trigger_type* DoubleClicked_typeof();
void DoubleClicked__ctor_6_fn(DoubleClicked* __this);
void DoubleClicked__add_Handler_fn(DoubleClicked* __this, uDelegate* value);
void DoubleClicked__remove_Handler_fn(DoubleClicked* __this, uDelegate* value);
void DoubleClicked__New2_fn(DoubleClicked** __retval);
void DoubleClicked__OnClicked_fn(DoubleClicked* __this, ::g::Fuse::Input::PointerEventArgs* args, int* clickCount);
void DoubleClicked__OnRooted_fn(DoubleClicked* __this);
void DoubleClicked__OnUnrooted_fn(DoubleClicked* __this);
struct DoubleClicked : ::g::Fuse::Gestures::ClickerTrigger
{
uStrong<uDelegate*> Handler1;
void ctor_6();
void add_Handler(uDelegate* value);
void remove_Handler(uDelegate* value);
void OnClicked(::g::Fuse::Input::PointerEventArgs* args, int clickCount);
static DoubleClicked* New2();
};
// }
}}} // ::g::Fuse::Gestures
| [
"samantha.scislowicz@gmail.com"
] | samantha.scislowicz@gmail.com |
442ed5e4433ad5f61dfec2969e5230ea7930fb0f | 4072e2fdbd2c63e51b524faee90e77b5899818bf | /sync_thread.h | 75a4fe9697aa1d2326bf056fa46fddda6b4c1f21 | [] | no_license | SaeedKeshavarzi/DynamicThreadSync | 9ef0fd581ce66c0121216054e44ac7755c509f02 | 2145e0f2b01a9b8d350298ec955f4c99e2f128ce | refs/heads/master | 2020-07-03T00:44:18.228798 | 2019-10-05T09:54:13 | 2019-10-05T09:54:13 | 201,729,947 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,402 | h | #ifndef _SYNC_THREAD_H_
#define _SYNC_THREAD_H_
#include <atomic>
#include <queue>
#include <utility>
#include <mutex>
#include <condition_variable>
class sync_thread_t
{
public:
sync_thread_t() = default;
sync_thread_t(const sync_thread_t&) = delete;
sync_thread_t& operator=(const sync_thread_t&) = delete;
inline sync_thread_t(std::size_t _n_threads)
{
n_threads = _n_threads;
}
inline ~sync_thread_t()
{
enable(false);
}
inline bool enable() const
{
return on;
}
inline void enable(bool value)
{
if (value)
on = true;
else
{
std::lock_guard<std::mutex> lock(guard);
on = false;
if (n_involved_thread > 0)
_break_barrier();
}
}
inline std::size_t thread_count() const
{
return n_threads;
}
inline void thread_count(std::size_t count)
{
std::lock_guard<std::mutex> lock(guard);
n_threads = count;
if ((n_involved_thread > 0) && (n_involved_thread >= n_threads))
_break_barrier();
}
inline void register_thread()
{
std::lock_guard<std::mutex> lock(guard);
n_threads.fetch_add(1);
}
inline void unregister_thread()
{
std::lock_guard<std::mutex> lock(guard);
n_threads.fetch_sub(1);
if ((n_involved_thread > 0) && (n_involved_thread >= n_threads))
_break_barrier();
}
inline void register_callback(void(*callback)(void*), void * param)
{
std::lock_guard<std::mutex> lock(guard);
callback_queue.push(std::make_pair(callback, param));
}
inline void clear_callbacks()
{
std::lock_guard<std::mutex> lock(guard);
std::queue<callback_pack_t>().swap(callback_queue);
}
inline bool sync()
{
std::unique_lock<std::mutex> lock(guard);
if (!on || (n_threads == 0))
return false;
++n_involved_thread;
if (n_involved_thread < n_threads)
cv.wait(lock);
else // (n_involved_thread == n_threads)
_break_barrier();
return on;
}
template<class _Rep, class _Period>
inline bool sync_for(const std::chrono::duration<_Rep, _Period>& rel_time)
{
std::unique_lock<std::mutex> lock(guard);
if (!on || (n_threads == 0))
return false;
++n_involved_thread;
if (n_involved_thread < n_threads)
{
if (cv.wait_for(lock, rel_time) == std::cv_status::timeout)
{
--n_involved_thread;
return false;
}
}
else // (n_involved_thread == n_threads)
_break_barrier();
return on;
}
template<class _Clock, class _Duration>
inline bool sync_until(const std::chrono::time_point<_Clock, _Duration>& timeout_time)
{
std::unique_lock<std::mutex> lock(guard);
if (!on || (n_threads == 0))
return false;
++n_involved_thread;
if (n_involved_thread < n_threads)
{
if (cv.wait_until(lock, timeout_time) == std::cv_status::timeout)
{
--n_involved_thread;
return false;
}
}
else // (n_involved_thread == n_threads)
_break_barrier();
return on;
}
private:
using callback_pack_t = std::pair<void(*)(void*), void*>;
inline void _break_barrier()
{
while (!callback_queue.empty())
{
callback_pack_t & callback_pack = callback_queue.front();
callback_pack.first(callback_pack.second);
callback_queue.pop();
}
n_involved_thread = 0;
cv.notify_all();
}
mutable std::mutex guard;
mutable std::condition_variable cv;
std::queue<callback_pack_t> callback_queue;
std::atomic_size_t n_threads{ 0 };
std::atomic_size_t n_involved_thread{ 0 };
std::atomic_bool on{ true };
};
#endif // !_SYNC_THREAD_H_
| [
"Saeed@Keshavarzi.com"
] | Saeed@Keshavarzi.com |
3829a144fd2a0608eb032d9cd09544cdf1f5b3fc | fe8a8f7e2e4d7d7a2e5a8e26f3c0e277b9565158 | /StackProject/ConsoleApplication98/Main.cpp | 760e10120689b1108b3b602fc0e9372ad4e049b2 | [] | no_license | miguel231997/implementing-a-Stack | a148af09aef7fdbfdfd8ea37f4c9b349ec696ccc | 0effc773a802e9bc95c884cea8260c4c15514965 | refs/heads/master | 2021-01-19T10:15:11.636923 | 2017-04-10T19:55:28 | 2017-04-10T19:55:28 | 87,844,329 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,936 | cpp | #include "StackInterface.h"
#include "ArrayStack.h"
#include "LinkedStack.h"
#include "PrecondViolatedExcept.h"
#include <iostream>
#include <string>
#include <vector>
using namespace std;
void StackTester(StackInterface<string>* StackPtr)
{
std::cout << "isEmpty: returns " << StackPtr->isEmpty()
<< "; should be 1 (true)" << std::endl;
std::string items[] = { "one", "two", "three", "four", "five", "one" };
std::cout << "Add 6 items to the Stack: " << std::endl;
for (int i = 0; i < 6; i++)
{
StackPtr->push(items[i]);
} // end for
std::cout << "isEmpty: returns " << StackPtr->isEmpty()
<< "; should be 0 (false)" << std::endl;
std::cout << "Try to add another entry: add(\"extra\") returns "
<< StackPtr->push("extra") << std::endl;
cout << "Contents of stack (backwards):" << endl;
while (!StackPtr->isEmpty()) {
string item = StackPtr->peek();
StackPtr->pop();
cout << item << endl;
}
} // end StackTester
void stackTester(StackInterface<int>* StackPtr)
{
std::cout << "isEmpty: returns " << StackPtr->isEmpty()
<< "; should be 1 (true)" << std::endl;
int items[] = { 2, 4, 6, 8, 10, 12 };
cout << "Add 6 items to the Stack: " << std::endl;
for (int i = 0; i < 6; i++)
{
StackPtr->push(items[i]);
} // end for
std::cout << "isEmpty: returns " << StackPtr->isEmpty()
<< "; should be 0 (false)" << std::endl;
std::cout << "Try to add another entry: add(2) returns "
<< StackPtr->push(2) << std::endl;
while (!StackPtr->isEmpty()) {
int item = StackPtr->peek();
StackPtr->pop();
cout << item << endl;
}
} // end StackTester
int main()
{
StackInterface<std::string> *StackPtr = nullptr;
char userChoice;
std::cout << "Enter 'A' to test the array-based implementation\n"
<< " or 'L' to test the link-based implementation: ";
std::cin >> userChoice;
if (toupper(userChoice) == 'A')
{
StackPtr = new ArrayStack<string>();
std::cout << "Testing the Array-Based Stack:" << std::endl;
}
else
{
StackPtr = new LinkedStack<string>();
std::cout << "Testing the Link-Based Stack:" << std::endl;
} // end if
std::cout << "The initial Stack is empty." << std::endl;
StackTester(StackPtr);
delete StackPtr;
StackPtr = nullptr;
std::cout << "All done!" << std::endl;
//drsturm
{
StackInterface<int> *StackPtr = nullptr;
char userChoice;
std::cout << "Enter 'A' to test the array-based implementation\n"
<< " or 'L' to test the link-based implementation: ";
std::cin >> userChoice;
if (toupper(userChoice) == 'A')
{
StackPtr = new ArrayStack<int>();
std::cout << "Testing the Array-Based Stack:" << std::endl;
}
else
{
StackPtr = new LinkedStack<int>();
std::cout << "Testing the Link-Based Stack:" << std::endl;
} // end if
std::cout << "The initial Stack is empty." << std::endl;
stackTester(StackPtr);
delete StackPtr;
StackPtr = nullptr;
std::cout << "All done!" << std::endl;
}
return 0;
} // end main | [
"miguelgalindo1214@gmail.com"
] | miguelgalindo1214@gmail.com |
c9a48e8aa5b502e6d5e2259e894b9f0dc23e636f | 74cae79eaa85a0f78e56a44af9c5b9e82cdc67c1 | /PhysicsEngine/git_repos/dobot/influxdb_connector/lib/influxdb_cpp/lib/rxcpp/src/subjects/rx-synchronize.hpp | 858eef31a96ddbf25f0e51cb172016d37f516692 | [
"Apache-2.0"
] | permissive | luoxz-ai/server | 0aa53fb2ac89060cf5a1552728cfd3a684e8e671 | 1f64ec3083d5c584829bb39977bd7cde06d1332f | refs/heads/main | 2023-03-13T13:29:02.077785 | 2021-03-25T15:05:06 | 2021-03-25T15:05:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,314 | hpp | // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
#pragma once
#if !defined(RXCPP_RX_SYNCHRONIZE_HPP)
#define RXCPP_RX_SYNCHRONIZE_HPP
#include "../rx-includes.hpp"
namespace rxcpp {
namespace subjects {
namespace detail {
template<class T, class Coordination>
class synchronize_observer : public detail::multicast_observer<T>
{
typedef synchronize_observer<T, Coordination> this_type;
typedef detail::multicast_observer<T> base_type;
typedef rxu::decay_t<Coordination> coordination_type;
typedef typename coordination_type::coordinator_type coordinator_type;
typedef typename coordinator_type::template get<subscriber<T>>::type output_type;
struct synchronize_observer_state : public std::enable_shared_from_this<synchronize_observer_state>
{
typedef rxn::notification<T> notification_type;
typedef typename notification_type::type base_notification_type;
typedef std::deque<base_notification_type> queue_type;
struct mode
{
enum type {
Invalid = 0,
Processing,
Empty,
Disposed
};
};
mutable std::mutex lock;
mutable std::condition_variable wake;
mutable queue_type fill_queue;
composite_subscription lifetime;
mutable typename mode::type current;
coordinator_type coordinator;
output_type destination;
void ensure_processing(std::unique_lock<std::mutex>& guard) const {
if (!guard.owns_lock()) {
std::terminate();
}
if (current == mode::Empty) {
current = mode::Processing;
auto keepAlive = this->shared_from_this();
auto drain_queue = [keepAlive, this](const rxsc::schedulable& self){
RXCPP_TRY {
std::unique_lock<std::mutex> guard(lock);
if (!destination.is_subscribed()) {
current = mode::Disposed;
fill_queue.clear();
guard.unlock();
lifetime.unsubscribe();
return;
}
if (fill_queue.empty()) {
current = mode::Empty;
return;
}
auto notification = std::move(fill_queue.front());
fill_queue.pop_front();
guard.unlock();
notification->accept(destination);
self();
} RXCPP_CATCH(...) {
destination.on_error(rxu::current_exception());
std::unique_lock<std::mutex> guard(lock);
current = mode::Empty;
}
};
auto selectedDrain = on_exception(
[&](){return coordinator.act(drain_queue);},
destination);
if (selectedDrain.empty()) {
return;
}
auto processor = coordinator.get_worker();
processor.schedule(lifetime, selectedDrain.get());
}
}
synchronize_observer_state(coordinator_type coor, composite_subscription cs, output_type scbr)
: lifetime(std::move(cs))
, current(mode::Empty)
, coordinator(std::move(coor))
, destination(std::move(scbr))
{
}
template<class V>
void on_next(V v) const {
if (lifetime.is_subscribed()) {
std::unique_lock<std::mutex> guard(lock);
fill_queue.push_back(notification_type::on_next(std::move(v)));
ensure_processing(guard);
}
wake.notify_one();
}
void on_error(rxu::error_ptr e) const {
if (lifetime.is_subscribed()) {
std::unique_lock<std::mutex> guard(lock);
fill_queue.push_back(notification_type::on_error(e));
ensure_processing(guard);
}
wake.notify_one();
}
void on_completed() const {
if (lifetime.is_subscribed()) {
std::unique_lock<std::mutex> guard(lock);
fill_queue.push_back(notification_type::on_completed());
ensure_processing(guard);
}
wake.notify_one();
}
};
std::shared_ptr<synchronize_observer_state> state;
public:
synchronize_observer(coordination_type cn, composite_subscription dl, composite_subscription il)
: base_type(dl)
{
auto o = make_subscriber<T>(dl, make_observer_dynamic<T>( *static_cast<base_type*>(this) ));
// creates a worker whose lifetime is the same as the destination subscription
auto coordinator = cn.create_coordinator(dl);
state = std::make_shared<synchronize_observer_state>(std::move(coordinator), std::move(il), std::move(o));
}
subscriber<T> get_subscriber() const {
return make_subscriber<T>(this->get_id(), state->lifetime, observer<T, detail::synchronize_observer<T, Coordination>>(*this)).as_dynamic();
}
template<class V>
void on_next(V v) const {
state->on_next(std::move(v));
}
void on_error(rxu::error_ptr e) const {
state->on_error(e);
}
void on_completed() const {
state->on_completed();
}
};
}
template<class T, class Coordination>
class synchronize
{
detail::synchronize_observer<T, Coordination> s;
public:
explicit synchronize(Coordination cn, composite_subscription cs = composite_subscription())
: s(std::move(cn), std::move(cs), composite_subscription())
{
}
bool has_observers() const {
return s.has_observers();
}
subscriber<T> get_subscriber() const {
return s.get_subscriber();
}
observable<T> get_observable() const {
auto keepAlive = s;
return make_observable_dynamic<T>([=](subscriber<T> o){
keepAlive.add(keepAlive.get_subscriber(), std::move(o));
});
}
};
}
class synchronize_in_one_worker : public coordination_base
{
rxsc::scheduler factory;
class input_type
{
rxsc::worker controller;
rxsc::scheduler factory;
identity_one_worker coordination;
public:
explicit input_type(rxsc::worker w)
: controller(w)
, factory(rxsc::make_same_worker(w))
, coordination(factory)
{
}
inline rxsc::worker get_worker() const {
return controller;
}
inline rxsc::scheduler get_scheduler() const {
return factory;
}
inline rxsc::scheduler::clock_type::time_point now() const {
return factory.now();
}
template<class Observable>
auto in(Observable o) const
-> decltype(o.publish_synchronized(coordination).ref_count()) {
return o.publish_synchronized(coordination).ref_count();
}
template<class Subscriber>
auto out(Subscriber s) const
-> Subscriber {
return s;
}
template<class F>
auto act(F f) const
-> F {
return f;
}
};
public:
explicit synchronize_in_one_worker(rxsc::scheduler sc) : factory(sc) {}
typedef coordinator<input_type> coordinator_type;
inline rxsc::scheduler::clock_type::time_point now() const {
return factory.now();
}
inline coordinator_type create_coordinator(composite_subscription cs = composite_subscription()) const {
auto w = factory.create_worker(std::move(cs));
return coordinator_type(input_type(std::move(w)));
}
};
inline synchronize_in_one_worker synchronize_event_loop() {
static synchronize_in_one_worker r(rxsc::make_event_loop());
return r;
}
inline synchronize_in_one_worker synchronize_new_thread() {
static synchronize_in_one_worker r(rxsc::make_new_thread());
return r;
}
}
#endif
| [
"kbiermeier1@web.de"
] | kbiermeier1@web.de |
5769a64dd384287fd16ea7b93ffc0ba6c328d01d | bbac388eb6b53daec63190e2f271a18fe9bfb163 | /caddi2018/C.cpp | 7363399e611c2fbdc00119c3758cd7bbb3720b27 | [] | no_license | tatsumack/atcoder | 8d94cf29160b6553b0c089cb795c54efd3fb0f7b | fbe1e1eab80c4c0680ec046acdc6214426b19650 | refs/heads/master | 2023-06-17T23:09:54.056132 | 2021-07-04T13:03:59 | 2021-07-04T13:03:59 | 124,963,709 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,018 | cpp | #include <limits.h>
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define int long long
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define REPS(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define FOR(i, a, b) for (int i = (a), i##_len = (b); i <= i##_len; ++i)
#define REV(i, a, b) for (int i = (a); i >= (b); --i)
#define CLR(a, b) memset((a), (b), sizeof(a))
#define DUMP(x) cout << #x << " = " << (x) << endl;
#define INF (LLONG_MAX - 1e5)
#define fcout cout << fixed << setprecision(10)
using namespace std;
int count(vector<int> AA, int d) {
vector<double> A(AA.size());
REP(i, AA.size()) A[i] = log2(AA[i]);
int res = 0;
REV(i, d - 1, 0) {
if (i == A.size() - 1 || A[i] > A[i + 1]) {
continue;
}
int diff = A[i+1] - A[i];
if (diff % 2 == 0) diff++;
res += diff;
A[i] += diff;
}
FOR(i, d, A.size() - 1) {
if (i == 0 || A[i] > A[i - 1]) continue;
int diff = A[i-1] - A[i];
if (diff % 2 != 0) diff++;
res += diff;
A[i] += diff;
}
return res;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int N;
cin >> N;
vector<int> A(N);
REP(i, N) cin >> A[i];
if (N == 1) {
cout << 0 << endl;
return 0;
}
int l = 0;
int r = N + 1;
REP(i, 25) {
int a = (l + l + r) / 3;
int b = (l + r + r) / 3;
if (count(A, a) > count(A, b)) {
l = a;
} else {
r = b;
}
}
cout << min({count(A, l), count(A, (l + r) / 2), count(A, r)}) << endl;
return 0;
}
| [
"tatsu.mack@gmail.com"
] | tatsu.mack@gmail.com |
d99dc3d4ef216a06628b99d1497cd650589f6f83 | 5a9f7e7a9dfaba5b1aa44a580d6e2b1612d5ed51 | /stacks/largest_rectangle(O(n)).cpp | 244d5183898b237f8dc1686116df6e4f94d27d1b | [] | no_license | Ishikanagar07/data_structures | 628000db6f8a6b987a42e4ac6aee56a62342b006 | 407329b34bc7bcbe5969f7e15c1e17bd61cf237e | refs/heads/main | 2023-06-04T21:19:37.341590 | 2021-06-27T09:54:21 | 2021-06-27T09:54:21 | 366,239,219 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,370 | cpp | class Solution {
public:
int largestRectangleArea(vector<int>& heights) {
int n = heights.size();
vector<int> left(n),right(n);
stack<int> mystack;
for(int i=0;i<n;++i) //Fill left
{
if(mystack.empty())
{ left[i] = 0; mystack.push(i); }
else
{
while(!mystack.empty() and heights[mystack.top()]>=heights[i])
mystack.pop();
left[i] = mystack.empty()?0:mystack.top()+1;
mystack.push(i);
}
}
while(!mystack.empty()) //Clear stack
mystack.pop();
for(int i=n-1;i>=0;--i) //Fill right
{
if(mystack.empty())
{ right[i] = n-1; mystack.push(i); }
else
{
while(!mystack.empty() and heights[mystack.top()]>=heights[i])
mystack.pop();
right[i] = mystack.empty()?n-1:mystack.top()-1;
mystack.push(i);
}
}
int mx_area = 0; //Stores max_area
for(int i=0;i<n;++i)
mx_area = max(mx_area,heights[i]*(right[i]-left[i]+1));
return mx_area;
}
};
//Source => https://www.youtube.com/watch?v=vcv3REtIvEo
//also refer => https://www.youtube.com/watch?v=0do2734xhnU
| [
"noreply@github.com"
] | Ishikanagar07.noreply@github.com |
fbeead37a0944daab1e197b8604712c4f55d2399 | 6d8adaaa4d85dfb33f903770d7e5a8ef4c60773f | /ivp/src/lib_geometry/XYWedge.h | c573d7fb6d81af170b2ecbc030bc7c9ec09b9e8a | [] | no_license | moos-ivp/svn-mirror | 3509614f054dbc9d2ecc19d503b3f20298138f66 | d537fa58f7891688bb64220e35c267ae6ef4f476 | refs/heads/master | 2023-06-25T15:10:16.009010 | 2023-06-14T12:45:58 | 2023-06-14T12:45:58 | 82,476,527 | 6 | 9 | null | null | null | null | UTF-8 | C++ | false | false | 3,395 | h | /*****************************************************************/
/* NAME: Michael Benjamin */
/* ORGN: Dept of Mechanical Eng / CSAIL, MIT Cambridge MA */
/* FILE: XYWedge.h */
/* DATE: Sep 10th 2015 */
/* */
/* This file is part of IvP Helm Core Libs */
/* */
/* IvP Helm Core Libs is free software: you can redistribute it */
/* and/or modify it under the terms of the Lesser GNU General */
/* Public License as published by the Free Software Foundation, */
/* either version 3 of the License, or (at your option) any */
/* later version. */
/* */
/* IvP Helm Core Libs 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 Lesser GNU General Public License for more */
/* details. */
/* */
/* You should have received a copy of the Lesser GNU General */
/* Public License along with MOOS-IvP. If not, see */
/* <http://www.gnu.org/licenses/>. */
/*****************************************************************/
#ifndef XY_WEDGE_HEADER
#define XY_WEDGE_HEADER
#include <string>
#include "XYObject.h"
class XYWedge : public XYObject {
public:
XYWedge();
virtual ~XYWedge() {}
void setX(double);
void setY(double);
bool setRadLow(double);
bool setRadHigh(double);
void setLangle(double);
void setHangle(double);
double getX() const {return(m_x);}
double getY() const {return(m_y);}
double getLangle() const {return(m_langle);}
double getHangle() const {return(m_hangle);}
double getRadLow() const {return(m_radlow);}
double getRadHigh() const {return(m_radhgh);}
double getMinX() const {return(m_xmin);}
double getMaxX() const {return(m_xmax);}
double getMinY() const {return(m_ymin);}
double getMaxY() const {return(m_ymax);}
std::vector<double> getPointCache() const {return(m_pt_cache);}
std::string get_spec(unsigned int prec=1, std::string param="") const;
bool isValid() const;
bool initialize(double degrees_per_pt=1);
protected: // Config variables
double m_x;
double m_y;
double m_langle;
double m_hangle;
double m_radlow;
double m_radhgh;
protected: // State variables
bool m_x_set;
bool m_y_set;
bool m_langle_set;
bool m_hangle_set;
bool m_radlow_set;
bool m_radhgh_set;
protected: // State variables (cached values)
double m_xmin;
double m_xmax;
double m_ymin;
double m_ymax;
double m_llx; // low angle low radius
double m_lly;
double m_lhx; // low angle high radius
double m_lhy;
double m_hlx; // high angle low radius
double m_hly;
double m_hhx; // high angle high radius
double m_hhy;
bool m_initialized;
std::vector<double> m_pt_cache;
};
#endif
| [
"mikerb@7b6de600-d9ab-45c9-a1ca-e8145d3c6daf"
] | mikerb@7b6de600-d9ab-45c9-a1ca-e8145d3c6daf |
c93fcc70bd737dd0c44bf129bf99a49106853d93 | a0227698bd495f7310589ee9a887de290ad1297b | /ObjectsMgr.h | 7e304648bcea0a08b4037eb08ded4c7f53231451 | [] | no_license | virucho/sTVr | 19781e00e14916faf97d2cd75049f60f63d4dbfc | f0b023d807392b2177693f705b8b6bbcaa4cfa52 | refs/heads/master | 2021-01-23T13:49:41.278968 | 2015-01-07T16:34:35 | 2015-01-07T16:34:35 | 28,089,786 | 1 | 1 | null | null | null | null | ISO-8859-1 | C++ | false | false | 4,106 | h | /************************************************************************************
* Copyright (c) 2014-2015, TU Ilmenau
*
* Build with Irrlicht framework
* STVR use:
* Vuzix SDK 3.3
* Irrlicht 1.8
* IrrEdit 4.5
* DirectX 9
* Viel Dank guys
* ===================================================================================
* Authors: Luis Rojas (luis-alejandro.rojas-vargas@tu-ilmenau.de)
*************************************************************************************/
#ifndef __C_OBJMGR_H_INCLUDED__
#define __C_OBJMGR_H_INCLUDED__
/****************************************************************/
/* Defines */
/****************************************************************/
#ifndef M_PI
#define M_PI 3.14159265358979323846f /* As in Linux's math.h */
#endif
#ifndef DEGREE_TO_RAD
#define DEGREE_TO_RAD (M_PI/180.0f)
#endif
#ifndef RAD_TO_DEGREE
#define RAD_TO_DEGREE (180.0f/M_PI)
#endif
/****************************************************************/
/* Include */
/****************************************************************/
#include <irrlicht.h>
#include <string>
/****************************************************************/
/* Namespace */
/****************************************************************/
using namespace irr; //Haupt Namespace von Irrlicht
using namespace core; //Zusätzliche Namespace
/****************************************************************/
/* Class */
/****************************************************************/
class ObjeScene
{
public:
enum MyModeltype
{
MMT_PERMANENT=1, // Model is always in memory until the end from the App
MMT_TEMP // Model is destroy when the scene finish
};
private:
std::string ModelName;
std::string IdName;
std::string AddFolder;
MyModeltype Modeltype; // Type of Load (in memory) from the model
bool inScene;
vector3df ObjPosition;
vector3df ObjRotation;
vector3df ObjScale;
public:
ObjeScene(std::string name, MyModeltype type)
{
IdName = name;
inScene = false;
ObjScale = vector3df(1.0f, 1.0f, 1.0f);
ModelName = name;
Modeltype = type;
};
ObjeScene()
{
IdName = "NA";
inScene = false;
ObjScale = vector3df(1.0f, 1.0f, 1.0f);
Modeltype = MMT_TEMP;
};
//Properties
void setModelName(std::string Name) {ModelName = Name;}
void setIdName(std::string Id) {IdName = Id;}
void setAddFolder(std::string folder) {AddFolder = folder;}
void setPosition(vector3df Pos) {ObjPosition = Pos;}
void setRotation(vector3df Rot) {ObjRotation = Rot;}
void setScale(vector3df Scale) {ObjScale = Scale;}
void setModeltype(MyModeltype type) {Modeltype = type;}
void setinScene(bool isinscene) {inScene = isinscene;}
std::string getModelName() { return ModelName;}
std::string getIdName() { return IdName;}
std::string getAddfolder() {return AddFolder;}
vector3df getPosition() {return ObjPosition;}
vector3df getRotation() {return ObjRotation;}
vector3df getScale() {return ObjScale;}
MyModeltype getModeltype() {return Modeltype;}
bool getinScene() {return inScene;}
//Funciones
void UpdateCoords(vector3df Position, vector3df Rotation, vector3df Scale)
{
ObjPosition = Position;
ObjRotation = Rotation;
ObjScale = Scale;
};
static vector3df ConvertToDeg(vector3df Rotation)
{
float x = RAD_TO_DEGREE * Rotation.X;
float y = RAD_TO_DEGREE * Rotation.Y;
float z = RAD_TO_DEGREE * Rotation.Z;
return vector3df(x, y, z);
};
};
/****************************************************************/
/* Global */
/****************************************************************/
/****************************************************************/
/* Functions */
/****************************************************************/
#endif // __C_OBJMGR_H_INCLUDED__ | [
"en_virucho@hotmail.com"
] | en_virucho@hotmail.com |
f0b30037b790d6f2eaa3f03da1b7a2b4cb6ad092 | 54b5a799c16ce90e48c680c951740a7db42f3624 | /taichi/system/memory_pool.h | 2e294f38750ddcc1a591a261dac72f5cc3a2ba97 | [
"MIT"
] | permissive | netext/taichi | 16fb88af00941bb59a29b05d3d322857d48dacf8 | 66c0b43d2c9b4554b862501d0dc80c233982efb4 | refs/heads/master | 2022-06-12T03:00:59.856252 | 2020-05-06T18:52:23 | 2020-05-06T18:52:23 | 261,973,095 | 1 | 0 | MIT | 2020-05-07T06:52:40 | 2020-05-07T06:52:39 | null | UTF-8 | C++ | false | false | 1,033 | h | #pragma once
#include "taichi/common/util.h"
#include "taichi/system/unified_allocator.h"
#define TI_RUNTIME_HOST
#include "taichi/runtime/llvm/context.h"
#include <mutex>
#include <vector>
#include <memory>
#include <thread>
TLANG_NAMESPACE_BEGIN
class Program;
// A memory pool that runs on the host
class MemoryPool {
public:
std::vector<std::unique_ptr<UnifiedAllocator>> allocators;
static constexpr std::size_t default_allocator_size =
1 << 30; // 1 GB per allocator
bool terminating, killed;
std::mutex mut;
std::mutex mut_allocators;
std::unique_ptr<std::thread> th;
int processed_tail;
bool use_unified_memory;
Program *prog;
MemRequestQueue *queue;
MemoryPool(Program *prog);
template <typename T>
T fetch(volatile void *ptr);
template <typename T>
void push(volatile T *dest, const T &val);
void *allocate(std::size_t size, std::size_t alignment);
void set_queue(MemRequestQueue *queue);
void daemon();
void terminate();
~MemoryPool();
};
TLANG_NAMESPACE_END
| [
"yuanmhu@gmail.com"
] | yuanmhu@gmail.com |
44e74f11d9c7397462295cc81b5263027a52fccc | 0ac6782681ab2ded3bcc36f8e7bd5f1db2c77aa0 | /ImportMatrix/bin/src/JoinUltraBigMatrix.cpp | b19df9f51521a47fe207f2563f726988dbfee2aa | [] | no_license | RitchieLabIGH/GECKO | 8f1af3b666b5bc60a1602e1bf154285c565c32c4 | 19f83a2b09acf0f3cdb962afa759440bb60697e8 | refs/heads/master | 2020-04-08T16:10:33.154218 | 2020-04-02T09:33:12 | 2020-04-02T09:33:12 | 159,507,523 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 10,603 | cpp | #include <cstdio>
#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <vector>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <sstream>
#include <cstdlib>
#include <ctime>
#include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string.hpp>
using namespace std;
int main(int argc, char* argv[]){
string file_output_final = argv[1];
string file_input1 = argv[2];
string file_input2 = argv[3];
uint64_t size_sample = 500000000; //200M
/**
* ouverture des fichiers de sortie
* **/
ofstream file_output_final_ptr(file_output_final.c_str(), ios::out);
/**
* recuperation des infos sur les fichiers input
* **/
uint64_t nbline1 = 0;
uint64_t nbline2 = 0;
uint64_t nbcol1 = 0;
uint64_t nbcol2 = 0;
ifstream file_input_ptr1(file_input1.c_str(), ios::in);
ifstream file_input_ptr2(file_input2.c_str(), ios::in);
if(!file_input_ptr1 or !file_input_ptr2){
return EXIT_FAILURE;
}
string file1_header1, file1_header2, file2_header1, file2_header2;
string line;
getline(file_input_ptr1, file1_header1); getline(file_input_ptr1, file1_header2);
getline(file_input_ptr2, file2_header1); getline(file_input_ptr2, file2_header2);
vector<string> content00;
boost::split(content00, file1_header2, boost::is_any_of("\t"));
nbcol1 = content00.size()-1; //nombre de donnees nouvelles sans tenir compte de l'ID
boost::split(content00, file2_header2, boost::is_any_of("\t"));
nbcol2 = content00.size()-1; //nombre de donnees nouvelles sans tenir compte de l'ID
cerr << nbcol1 << " samples for file1 and " << nbcol2 << " samples for file2" << endl;
while(getline(file_input_ptr1, line)){
nbline1++;
}
while(getline(file_input_ptr2, line)){
nbline2++;
}
cerr << nbline1 << " kmers for file1 and " << nbline2 << " kmers for file2" << endl;
file_input_ptr1.close();
file_input_ptr2.close();
string h1 = file1_header1;
string h2 = file1_header2;
boost::split(content00, file2_header1, boost::is_any_of("\t"));
for(uint64_t i = 1; i < content00.size(); i++){
h1+="\t"+content00[i];
}
boost::split(content00, file2_header2, boost::is_any_of("\t"));
for(uint64_t i = 1; i < content00.size(); i++){
h2+="\t"+content00[i];
}
file_output_final_ptr << h1 << endl;
file_output_final_ptr << h2 << endl;
/**
* traitement par paquet de file1
* **/
uint64_t nbpaquet1 = nbline1/size_sample;
uint64_t nbpaquet2 = nbline2/size_sample;
cerr << "nbpaquet1 = " << nbpaquet1 << endl;
cerr << "nbpaquet2 = " << nbpaquet2 << endl;
uint64_t log_cpt_total1 = 0;
uint64_t log_cpt_total2 = 0;
for(uint64_t paquet = 0; paquet<nbpaquet1; paquet++){
cerr << "paquet " << paquet << endl;
uint64_t log_cpt_tmp = 0;
//pointeur à la bonne ligne
ifstream file_ptr1(file_input1.c_str(), ios::in);
for(uint64_t cpt = 0; cpt<(2+paquet*size_sample); cpt++){
getline(file_ptr1, line);
}
cerr << 2+paquet*size_sample << " lines ignored" << endl;
//creation dictionnaire
map<uint64_t, string> dictionnaire;
for(uint64_t cpt = 0; cpt<size_sample; cpt++){
getline(file_ptr1, line);
vector<string> content;
boost::split(content, line, boost::is_any_of("\t"));
dictionnaire[strtoull(content[0].c_str(), NULL, 0)] = line;
}
file_ptr1.close();
cerr << size_sample << " kmers read" << endl;
//lecture file2
ifstream file_ptr2(file_input2.c_str(), ios::in);
while(getline(file_ptr2, line)){
vector<string> content;
boost::split(content, line, boost::is_any_of("\t"));
uint64_t idc = strtoull(content[0].c_str(), NULL, 0);
map<uint64_t, string>::iterator it = dictionnaire.find(idc);
if(it!=dictionnaire.end()){
log_cpt_tmp++;
//ecriture dans output
string ltw = it->second;
for(uint64_t i = 1; i < content.size(); i++){
ltw+="\t"+content[i];
}
file_output_final_ptr << ltw << endl;
//suppression de l'entree dictionnaire
dictionnaire.erase (it);
}
}
file_ptr2.close();
cerr << log_cpt_tmp << " found in 2nd file" << endl;
//traitement des fails
log_cpt_tmp = 0;
string basis = "";
for(uint64_t i = 0; i<nbcol2; i++){
basis=basis+"\t0";
}
for(map<uint64_t, string>::iterator it = dictionnaire.begin(); it!=dictionnaire.end(); it++){
file_output_final_ptr << it->second << basis << endl;
log_cpt_tmp++;
}
cerr << log_cpt_tmp << " kmers written" << endl << endl;
}
if(true){
ifstream file_ptr1(file_input1.c_str(), ios::in);
//pointeur à la bonne ligne
for(uint64_t cpt = 0; cpt<(2+nbpaquet1*size_sample); cpt++){
getline(file_ptr1, line);
}
//creation dictionnaire
map<uint64_t, string> dictionnairefinal;
while(getline(file_ptr1, line)){
vector<string> content;
boost::split(content, line, boost::is_any_of("\t"));
dictionnairefinal[strtoull(content[0].c_str(), NULL, 0)] = line;
}
file_ptr1.close();
//lecture file2
ifstream file_ptr2(file_input2.c_str(), ios::in);
while(getline(file_ptr2, line)){
vector<string> content;
boost::split(content, line, boost::is_any_of("\t"));
uint64_t idc = strtoull(content[0].c_str(), NULL, 0);
map<uint64_t, string>::iterator it = dictionnairefinal.find(idc);
if(it!=dictionnairefinal.end()){
//ecriture dans output
string ltw = it->second;
for(uint64_t i = 1; i < content.size(); i++){
ltw+="\t"+content[i];
}
file_output_final_ptr << ltw << endl;
//suppression de l'entree dictionnaire
dictionnairefinal.erase (it);
}
}
file_ptr2.close();
//traitement des fails
string basis = "";
for(uint64_t i = 0; i<nbcol2; i++){
basis=basis+"\t0";
}
for(map<uint64_t, string>::iterator it = dictionnairefinal.begin(); it!=dictionnairefinal.end(); it++){
file_output_final_ptr << it->second << basis << endl;
}
}
/**
* traitement par paquet de file2
* **/
for(uint64_t paquet = 0; paquet<nbpaquet2; paquet++){
//pointeur à la bonne ligne
ifstream file_ptr2(file_input2.c_str(), ios::in);
for(uint64_t cpt = 0; cpt<(2+paquet*size_sample); cpt++){
getline(file_ptr2, line);
}
//creation dictionnaire
map<uint64_t, string> dictionnaire;
for(uint64_t cpt = 0; cpt<size_sample; cpt++){
getline(file_ptr2, line);
vector<string> content;
boost::split(content, line, boost::is_any_of("\t"));
dictionnaire[strtoull(content[0].c_str(), NULL, 0)] = line;
}
file_ptr2.close();
//lecture file1
ifstream file_ptr1(file_input1.c_str(), ios::in);
while(getline(file_ptr1, line)){
vector<string> content;
boost::split(content, line, boost::is_any_of("\t"));
uint64_t idc = strtoull(content[0].c_str(), NULL, 0);
map<uint64_t, string>::iterator it = dictionnaire.find(idc);
if(it!=dictionnaire.end()){
//ecriture dans output
//file_output_final_ptr << it->second << "\t" << line << endl;
//suppression de l'entree dictionnaire
dictionnaire.erase (it);
}
}
file_ptr1.close();
//traitement des fails
string basis = "";
for(uint64_t i = 0; i<nbcol2; i++){
basis=basis+"\t0";
}
for(map<uint64_t, string>::iterator it = dictionnaire.begin(); it!=dictionnaire.end(); it++){
vector<string> content;
boost::split(content, it->second, boost::is_any_of("\t"));
string interstice = "";
for(uint64_t i =1; i<content.size(); i++){
interstice+="\t"+content[i];
}
file_output_final_ptr << content[0] << basis << interstice << endl;
}
}
if(true){
//pointeur à la bonne ligne
ifstream file_ptr2(file_input2.c_str(), ios::in);
for(uint64_t cpt = 0; cpt<(2+nbpaquet2*size_sample); cpt++){
getline(file_ptr2, line);
}
//creation dictionnaire
map<uint64_t, string> dictionnairefinal2;
while(getline(file_ptr2, line)){
vector<string> content;
boost::split(content, line, boost::is_any_of("\t"));
dictionnairefinal2[strtoull(content[0].c_str(), NULL, 0)] = line;
}
file_ptr2.close();
//lecture file1
ifstream file_ptr1(file_input1.c_str(), ios::in);
while(getline(file_ptr1, line)){
vector<string> content;
boost::split(content, line, boost::is_any_of("\t"));
uint64_t idc = strtoull(content[0].c_str(), NULL, 0);
map<uint64_t, string>::iterator it = dictionnairefinal2.find(idc);
if(it!=dictionnairefinal2.end()){
//ecriture dans output
//file_output_final_ptr << it->second << "\t" << line << endl;
//suppression de l'entree dictionnaire
dictionnairefinal2.erase (it);
}
}
file_ptr1.close();
//traitement des fails
string basis = "";
for(uint64_t i = 0; i<nbcol2; i++){
basis=basis+"\t0";
}
for(map<uint64_t, string>::iterator it = dictionnairefinal2.begin(); it!=dictionnairefinal2.end(); it++){
vector<string> content;
boost::split(content, it->second, boost::is_any_of("\t"));
string interstice = "";
for(uint64_t i =1; i<content.size(); i++){
interstice+="\t"+content[i];
}
file_output_final_ptr << content[0] << basis << interstice << endl;
}
}
file_output_final_ptr.close();
return EXIT_SUCCESS;
}
| [
"aubin.thomas@igh.cnrs.fr"
] | aubin.thomas@igh.cnrs.fr |
d246d08a5e487db2075b04e1b5a9f0ee15d9fabd | 2b9e18d7f6946e9a4ad8fef53897233e0bb0278f | /tv3d/CTVMaterialFactory.h | 5f2ddfdbd679cf9b52e7a0f7b86f35859dd940df | [] | no_license | ClemensLode/Swords-3D | 2c213f241ae0131f7e740eee9b7a54991a6b813e | 084c943e5d94a57d9cf3f6b0f9016decd6802125 | refs/heads/master | 2021-01-15T09:10:40.827480 | 2018-04-05T13:24:49 | 2018-04-05T13:24:49 | 68,632,409 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,755 | h | #pragma once
#include "tv_types.h"
class EXPORTCLASS CTVMaterialFactory
{
public:
int iMaterialFactoryIndex;
CTVMaterialFactory(void);
~CTVMaterialFactory(void);
// Create materials
int CreateMaterial(const char* matname = NULL);
int CreateLightMaterial(float red, float green, float blue, float alpha, float fAmbientLevel = 0.4f, float fSpecularLevel = 0.3f, char* name = NULL);
int CreateMaterialQuick(float r, float g, float b, float a, const char* matname);
void SetSpecular(int iMaterialIndex, float r, float g, float b, float a);
void SetAmbient(int iMaterialIndex, float r, float g, float b, float a);
void SetDiffuse(int iMaterialIndex, float r, float g, float b, float a);
void SetEmissive(int iMaterialIndex, float r, float g, float b, float a);
void SetPower(int iMaterialIndex, float power);
cTV_COLOR GetSpecular(int iMaterialIndex);
cTV_COLOR GetAmbient(int iMaterialIndex);
cTV_COLOR GetDiffuse(int iMaterialIndex);
cTV_COLOR GetEmissive(int iMaterialIndex);
float GetPower(int iMaterialIndex);
void DeleteAllMaterials();
void DeleteMaterial(int iMaterialIndex);
int GetMaterialByName(const char* matName);
int GetCount();
int GetActiveCount();
bool IsMaterialActive(int iMaterialIndex);
char* GetMaterialName(int iMaterialIndex);
void SetOpacity(int iMaterial, float fAlpha);
float GetOpacity(int iMaterial);
// prt methods
void EnablePRTSubSurface(int iMaterial, bool bEnablePRTSubS);
void SetPRTSubSurfAbsorption(int iMaterial, float fRed, float fGreen, float fBlue);
void SetPRTSubSurfReducedScattering(int iMaterial, float fRed, float fGreen, float fBlue );
void SetPRTSubSurfRefractionIndexRatio(int iMaterial, float fRatio);
int Duplicate(int iMaterial, char* sNewMaterialName = NULL);
};
| [
"contact@lode.de"
] | contact@lode.de |
e436ad21f1daa63e96dc25c90372c32a03d32bb7 | bc592c321b3a861323215bb982fbf134376fb37f | /main.cpp | 8c362265c1ee8af045091bfcce8aad1074afe98d | [] | no_license | LuanLimaFreitas/Ants_Luan | 80bb8b2573a9840ff09511cc627e9bcf7a8cd092 | dff3b670bb14ad8ef817485e1ba9bcf178421940 | refs/heads/master | 2020-07-29T04:30:06.576894 | 2019-09-20T00:39:07 | 2019-09-20T00:39:07 | 209,670,023 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,068 | cpp | #include <cmath>
#include <cstdlib>
#include <cassert>
#include <iostream>
#include <random>
#include <vector>
#include <fstream>
using namespace std;
#include "auxiliary_functions.h"
#include "parameters.h"
#include "network.h"
#include "droplet.h"
#include "ant.h"
float game(Network Net);
/// Aqui fica a musculatura do programa. Uma chamada da função 'game'
/// simula um período determinado de vida de uma colônia de formigas
/// cuja lei de movimento é definida mediante a rede neural 'Net'.
/// Seu retorno é a pontuação da colônia, definida como a quantidade
/// total de feromônio percebido pelas formigas. Tal resultado deve ser
/// interpretado do ponto de vista total da evolução dos sistemas neurais
/// como a pontuação da rede neural.
int main()
{
cout << "Hello World!" << endl;
std::vector<int> s = {2,3,2};
std::vector<std::vector<std::vector<float>>> w = { { {1,0,0},{0,1,0} } , {{1,0},{0,1},{0,0}} };
std::vector<std::vector<float>> b = { {0,0,0} , {0,0} };
Network net(s,w,b);
std::size_t i = 0;
while( i<1 )
{
cout << game(net) << endl;
i++;
}
cout << "over" << endl;
return 0;
}
float game(Network Net)
{
ofstream gaming_info;
gaming_info.open( "gaming_info.txt", ios::out | ios::trunc );
gaming_info << x_1 << endl;
gaming_info << x_2 << endl;
gaming_info << y_1 << endl;
gaming_info << y_2 << endl;
float score = 0;
int i;
/// Step 1.1: Initialize the ants at random positions. Question: Should
/// we initialize them all at the same time or, instead, progressively?
///
std::vector<Ant*> all_ants;
gaming_info << number_of_ants << endl;
for ( i = 0; i<number_of_ants; i++)
{
all_ants.push_back(new Ant());
all_ants[i]->load_at(333,999,Net); // Currently NOT initializing the ants randomly.
gaming_info << all_ants[i]->pos_x << endl;
gaming_info << all_ants[i]->pos_y << endl;
}
/// Step 1.2: Initialize the pheromone landscape.
///
std::vector<Droplet> all_droplets = {};
int last_drop_iter = -999; // '-999' is just a small enough number.
gaming_info << initial_number_of_droplets << endl;
std::vector<std::vector<float>> trail = straight_trail(0.);
for ( i = 0; i<initial_number_of_droplets; i++)
{
float droplet_center_x = trail[0][i];
float droplet_center_y = trail[1][i];
float droplet_origin_time = trail[2][i];
if( droplet_origin_time > last_drop_iter) // We wish to record the greatest 'droplet_origin_time'.
last_drop_iter = droplet_origin_time;
gaming_info << droplet_center_x << endl;
gaming_info << droplet_center_y << endl;
all_droplets.push_back(Droplet(droplet_origin_time,droplet_center_x,droplet_center_y));
}
Droplet::number_of_droplets = initial_number_of_droplets;
/// Step 2: Several cicles of ant updating, pheromone droping and
/// pheromone erasing.
///
float Time = 0;
std::size_t j;
gaming_info << number_of_iterations << endl;
while( Time < number_of_iterations )
{
/// Step 2.1: Check if it's time to leave some droplets
/// - Probably a good time to erase some droplets too!
///
if( Time - last_drop_iter >= drop_every_iter)
{
last_drop_iter = Time;
for( j=0 ; j < all_ants.size(); j++ )
all_droplets.push_back(Droplet(Time,all_ants[j]->pos_x,all_ants[j]->pos_y));
/// Now checking for outdated droplets.
for( j=0; j < all_droplets.size(); j++ ) // Improve this!
{
if (exp(-Evaporation * all_droplets[j].elapsed_time(Time)) * Amount <= .01)
{
all_droplets.erase(all_droplets.begin()+j);
Droplet::number_of_droplets--;
}
}
}
else
{ /// Step 2.2: Update our little anties and record the pheromone they feel. The ants
/// will either drop pheromone or walk. This is meant to avoid undetermined results
/// in the heat equation when 'elapsed time' = 0. Still, it appears to be a reasonable
/// and natural behavior.
for( j=0; j<all_ants.size(); j++ )
{
float some_points = all_ants[j]->update(Time,all_droplets); // Sounds easy, eh?
score += some_points;
}
}
gaming_info << all_ants[0]->pos_x << endl;
gaming_info << all_ants[0]->pos_y << endl;
Time++;
}
// /// Step 3: Now pass some additional information to the 'gaming_info'
// /// file.
// ///
// gaming_info << all_droplets.size() << endl;
// for( i = 0; i < all_droplets.size(); i++)
// {
// gaming_info << all_droplets[i].pos_x << endl;
// gaming_info << all_droplets[i].pos_y << endl;
// }
gaming_info.close();
return score;
}
| [
"noreply@github.com"
] | LuanLimaFreitas.noreply@github.com |
d4e2853933a51241d9fadd00c210fa5701b7c8de | dd8c8da6142fd44b0c2a780c1f6b1d1466e50751 | /ESP8266/Method.cpp | b9961ca13a30757469c4535253d42614a34ec5d3 | [] | no_license | RJSDevel/ESP8266-Emulator | 2dd4f80b5521a0158eb0b9fc34f4dce1a8526d05 | cbd132c70aeccecc05aeb0774f4c41fbd3fedb28 | refs/heads/master | 2022-10-09T06:41:20.715742 | 2020-06-04T10:30:27 | 2020-06-04T10:30:27 | 269,321,031 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 142 | cpp | #include "Method.h"
#include "CPU8266.h"
Method::Method()
{
}
Method::~Method()
{
}
void Method::Execute(Command* cmd, CPU8266* cpu)
{
}
| [
"yagupov.ruslan@gmail.com"
] | yagupov.ruslan@gmail.com |
66df3123559408c03cae194c7a99e125c69d4a8a | fb05adea4788bc1a2a8609a84323df3a624a462e | /ICS_code/信息的存储与表达.cpp | 144b49b33de57b823cde59716a94ab0bfe3b231e | [] | no_license | jy5275/Course_code | 40e976fa6b52ec5bf1d6c4ba4df36d18997bbfb1 | b3078982882da7ec7532eca52f26a037069e7c2f | refs/heads/master | 2021-11-11T11:09:23.432555 | 2021-11-04T05:20:48 | 2021-11-04T05:20:48 | 229,448,459 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,418 | cpp | /* 并查集:不直观,与物理结构相差较大,但能大大提升性能
N个不同的元素分布在若干个互不相交的集合中,需要多次进行以下3种操作:
1.合并a, b两个元素所在的集合 Merge(a, b)
2.查询一个元素在哪个集合
3.查询两个元素是否属于同一集合 Query(a, b) */
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<queue>
#include<vector>
#include<list>
#include<bitset>
#include<string>
#include<cstring>
#include<cmath>
#include<memory>
#include<stdexcept>
#include<time.h>
#include<algorithm>
#include<iomanip>
#include<fstream>
using namespace std;
const int MAX = 1 << 12;
void show_bytes(void *pv, int len) { //只传入首地址与长度,不管基类型
unsigned char *pStart = (unsigned char*)pv;
char *ps = (char *)pv;
for (int i = 0; i < len; i++) //把ps+i(i=0:len-1)字节转为两位16进制码输出
printf("%p 0x%.2x\n", pStart + i, pStart[i]);
printf("\n");
}
void show_int(int x) {
show_bytes(&x, sizeof(int));
}
void show_double(double d) {
show_bytes(&d, sizeof(double));
}
void show_pointer(void *x) {
show_bytes(&x, sizeof(void *));
}
int main() {
int k = (1 << 31) >> 31;
unsigned h = (1 << 31) - 1;
cout << h << endl;
cout << k << endl;
int aa = 15213;
printf("int aa = 15213;\n");
show_bytes(&aa, sizeof(int));
printf("%x\n", aa);
int a = -123, b = 123;
cout << "a in hex is " << hex << a << endl;
cout << "a in dec is " << dec << a << endl;
cout << "b in hex is " << hex << b << endl;
cout << "b in dec is " << dec << b << endl;
unsigned int c = 0xFFFFFFFF;
cout << "Largest unsigned int is " << dec << c << endl;
cout << "Equal to " << pow(2, 32) << endl << endl; //42亿
int d = 0x7FFFFFFF;
cout << "Largest signed int is " << dec << d << endl;
cout << "Equal to " << pow(2, 31) << endl << endl; //21亿
cout << endl;
cout << "sizeof(int):" << sizeof(int) << endl;
cout << "sizeof(unsigned int):" << sizeof(unsigned int) << endl;
cout << "sizeof(short):" << sizeof(short) << endl;
cout << "sizeof(unsigned short):" << sizeof(unsigned short) << endl;
cout << "sizeof(long):" << sizeof(long) << endl;
cout << "sizeof(unsigned long):" << sizeof(unsigned long) << endl;
cout << "sizeof(float):" << sizeof(float) << endl;
cout << "sizeof(double):" << sizeof(double) << endl;
cout << sizeof(int *) << "," << sizeof(char *) << "," << sizeof(void *) << endl;
return 0;
}
| [
"527507046@qq.com"
] | 527507046@qq.com |
0f26e1fa5a0934907d9a27c63163f830c9914f88 | 31ac07ecd9225639bee0d08d00f037bd511e9552 | /externals/OCCTLib/inc/PColPGeom_HArray1OfBSplineCurve.hxx | a2963c8b940c3b8a03287b9477df53e4f0bcd554 | [] | no_license | litao1009/SimpleRoom | 4520e0034e4f90b81b922657b27f201842e68e8e | 287de738c10b86ff8f61b15e3b8afdfedbcb2211 | refs/heads/master | 2021-01-20T19:56:39.507899 | 2016-07-29T08:01:57 | 2016-07-29T08:01:57 | 64,462,604 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,473 | hxx | // This file is generated by WOK (CPPExt).
// Please do not edit this file; modify original file instead.
// The copyright and license terms as defined for the original file apply to
// this header file considered to be the "object code" form of the original source.
#ifndef _PColPGeom_HArray1OfBSplineCurve_HeaderFile
#define _PColPGeom_HArray1OfBSplineCurve_HeaderFile
#ifndef _Standard_Macro_HeaderFile
#include <Standard_Macro.hxx>
#endif
#ifndef _Standard_DefineHandle_HeaderFile
#include <Standard_DefineHandle.hxx>
#endif
#ifndef _Standard_HeaderFile
#include <Standard.hxx>
#endif
#ifndef _Handle_PColPGeom_HArray1OfBSplineCurve_HeaderFile
#include <Handle_PColPGeom_HArray1OfBSplineCurve.hxx>
#endif
#ifndef _Standard_Integer_HeaderFile
#include <Standard_Integer.hxx>
#endif
#ifndef _Handle_PGeom_BSplineCurve_HeaderFile
#include <Handle_PGeom_BSplineCurve.hxx>
#endif
#ifndef _Handle_Standard_Persistent_HeaderFile
#include <Handle_Standard_Persistent.hxx>
#endif
#ifndef _PColPGeom_FieldOfHArray1OfBSplineCurve_HeaderFile
#include <PColPGeom_FieldOfHArray1OfBSplineCurve.hxx>
#endif
#ifndef _Standard_Address_HeaderFile
#include <Standard_Address.hxx>
#endif
#ifndef _Standard_Persistent_HeaderFile
#include <Standard_Persistent.hxx>
#endif
#ifndef _Handle_PColPGeom_VArrayNodeOfFieldOfHArray1OfBSplineCurve_HeaderFile
#include <Handle_PColPGeom_VArrayNodeOfFieldOfHArray1OfBSplineCurve.hxx>
#endif
#ifndef _Standard_OStream_HeaderFile
#include <Standard_OStream.hxx>
#endif
class PGeom_BSplineCurve;
class Standard_Persistent;
class Standard_OutOfRange;
class Standard_RangeError;
class PColPGeom_FieldOfHArray1OfBSplineCurve;
class PColPGeom_VArrayNodeOfFieldOfHArray1OfBSplineCurve;
class PColPGeom_VArrayTNodeOfFieldOfHArray1OfBSplineCurve;
class PColPGeom_HArray1OfBSplineCurve : public Standard_Persistent {
public:
Standard_EXPORT PColPGeom_HArray1OfBSplineCurve(const Standard_Integer Low,const Standard_Integer Up);
Standard_EXPORT PColPGeom_HArray1OfBSplineCurve(const Standard_Integer Low,const Standard_Integer Up,const Handle(PGeom_BSplineCurve)& V);
Standard_Integer Length() const;
Standard_Integer Lower() const;
Standard_EXPORT void SetValue(const Standard_Integer Index,const Handle(PGeom_BSplineCurve)& Value) ;
Standard_Integer Upper() const;
Standard_EXPORT Handle_PGeom_BSplineCurve Value(const Standard_Integer Index) const;
Standard_EXPORT virtual Handle_Standard_Persistent ShallowCopy() const;
Standard_EXPORT virtual void ShallowDump(Standard_OStream& s) const;
PColPGeom_HArray1OfBSplineCurve( )
{
}
PColPGeom_HArray1OfBSplineCurve(const Storage_stCONSTclCOM& a) : Standard_Persistent(a)
{
}
Standard_Integer _CSFDB_GetPColPGeom_HArray1OfBSplineCurveLowerBound() const { return LowerBound; }
void _CSFDB_SetPColPGeom_HArray1OfBSplineCurveLowerBound(const Standard_Integer p) { LowerBound = p; }
Standard_Integer _CSFDB_GetPColPGeom_HArray1OfBSplineCurveUpperBound() const { return UpperBound; }
void _CSFDB_SetPColPGeom_HArray1OfBSplineCurveUpperBound(const Standard_Integer p) { UpperBound = p; }
const PColPGeom_FieldOfHArray1OfBSplineCurve& _CSFDB_GetPColPGeom_HArray1OfBSplineCurveData() const { return Data; }
DEFINE_STANDARD_RTTI(PColPGeom_HArray1OfBSplineCurve)
protected:
private:
Standard_EXPORT PColPGeom_FieldOfHArray1OfBSplineCurve Field() const;
Standard_EXPORT Standard_Address Datas() const;
Standard_Integer LowerBound;
Standard_Integer UpperBound;
PColPGeom_FieldOfHArray1OfBSplineCurve Data;
};
#define Item Handle_PGeom_BSplineCurve
#define Item_hxx <PGeom_BSplineCurve.hxx>
#define PCollection_FieldOfHArray1 PColPGeom_FieldOfHArray1OfBSplineCurve
#define PCollection_FieldOfHArray1_hxx <PColPGeom_FieldOfHArray1OfBSplineCurve.hxx>
#define PCollection_VArrayNodeOfFieldOfHArray1 PColPGeom_VArrayNodeOfFieldOfHArray1OfBSplineCurve
#define PCollection_VArrayNodeOfFieldOfHArray1_hxx <PColPGeom_VArrayNodeOfFieldOfHArray1OfBSplineCurve.hxx>
#define PCollection_VArrayTNodeOfFieldOfHArray1 PColPGeom_VArrayTNodeOfFieldOfHArray1OfBSplineCurve
#define PCollection_VArrayTNodeOfFieldOfHArray1_hxx <PColPGeom_VArrayTNodeOfFieldOfHArray1OfBSplineCurve.hxx>
#define PCollection_VArrayNodeOfFieldOfHArray1 PColPGeom_VArrayNodeOfFieldOfHArray1OfBSplineCurve
#define PCollection_VArrayNodeOfFieldOfHArray1_hxx <PColPGeom_VArrayNodeOfFieldOfHArray1OfBSplineCurve.hxx>
#define PCollection_VArrayTNodeOfFieldOfHArray1 PColPGeom_VArrayTNodeOfFieldOfHArray1OfBSplineCurve
#define PCollection_VArrayTNodeOfFieldOfHArray1_hxx <PColPGeom_VArrayTNodeOfFieldOfHArray1OfBSplineCurve.hxx>
#define Handle_PCollection_VArrayNodeOfFieldOfHArray1 Handle_PColPGeom_VArrayNodeOfFieldOfHArray1OfBSplineCurve
#define PCollection_VArrayNodeOfFieldOfHArray1_Type_() PColPGeom_VArrayNodeOfFieldOfHArray1OfBSplineCurve_Type_()
#define Handle_PCollection_VArrayNodeOfFieldOfHArray1 Handle_PColPGeom_VArrayNodeOfFieldOfHArray1OfBSplineCurve
#define PCollection_VArrayNodeOfFieldOfHArray1_Type_() PColPGeom_VArrayNodeOfFieldOfHArray1OfBSplineCurve_Type_()
#define PCollection_HArray1 PColPGeom_HArray1OfBSplineCurve
#define PCollection_HArray1_hxx <PColPGeom_HArray1OfBSplineCurve.hxx>
#define Handle_PCollection_HArray1 Handle_PColPGeom_HArray1OfBSplineCurve
#define PCollection_HArray1_Type_() PColPGeom_HArray1OfBSplineCurve_Type_()
#include <PCollection_HArray1.lxx>
#undef Item
#undef Item_hxx
#undef PCollection_FieldOfHArray1
#undef PCollection_FieldOfHArray1_hxx
#undef PCollection_VArrayNodeOfFieldOfHArray1
#undef PCollection_VArrayNodeOfFieldOfHArray1_hxx
#undef PCollection_VArrayTNodeOfFieldOfHArray1
#undef PCollection_VArrayTNodeOfFieldOfHArray1_hxx
#undef PCollection_VArrayNodeOfFieldOfHArray1
#undef PCollection_VArrayNodeOfFieldOfHArray1_hxx
#undef PCollection_VArrayTNodeOfFieldOfHArray1
#undef PCollection_VArrayTNodeOfFieldOfHArray1_hxx
#undef Handle_PCollection_VArrayNodeOfFieldOfHArray1
#undef PCollection_VArrayNodeOfFieldOfHArray1_Type_
#undef Handle_PCollection_VArrayNodeOfFieldOfHArray1
#undef PCollection_VArrayNodeOfFieldOfHArray1_Type_
#undef PCollection_HArray1
#undef PCollection_HArray1_hxx
#undef Handle_PCollection_HArray1
#undef PCollection_HArray1_Type_
// other Inline functions and methods (like "C++: function call" methods)
inline void ShallowDump(const Handle_PColPGeom_HArray1OfBSplineCurve& me,Standard_OStream& s) {
me->ShallowDump(s);
}
#endif
| [
"litao1009@gmail.com"
] | litao1009@gmail.com |
da07ca8586afa51f04b21bf5c9667bce14f11877 | 1cece0d71f79fe991ede775181767e1a697ac374 | /tensorflow/compiler/xla/service/hlo_input_output_alias_config.cc | ad58bdb11b5ee69b2e9ea12fbc7e3b6e6a738dcd | [
"Apache-2.0"
] | permissive | microsoft/tensorflow-directml | 18d95a3f9ea0909fde8c1c245973eaa891e11348 | 3800a8e1cdeea062b9dac8584fb6303be7395b06 | refs/heads/directml | 2023-08-24T03:21:52.097089 | 2022-12-21T22:39:00 | 2022-12-21T22:39:00 | 291,217,084 | 459 | 43 | Apache-2.0 | 2022-12-21T22:39:02 | 2020-08-29T06:44:33 | C++ | UTF-8 | C++ | false | false | 9,324 | cc | /* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/compiler/xla/service/hlo_input_output_alias_config.h"
#include "tensorflow/compiler/xla/service/hlo_module.h"
namespace xla {
bool HloInputOutputAliasConfig::OutputHasAlias(
const ShapeIndex& output_index) const {
return alias_.element(output_index).has_value();
}
Status HloInputOutputAliasConfig::SetUpAlias(const ShapeIndex& output_index,
int64 param_number,
const ShapeIndex& param_index,
AliasKind kind) {
TF_RET_CHECK(kind == AliasKind::kUserAlias || kind == AliasKind::kSystemAlias)
<< kind;
TF_RET_CHECK(ShapeUtil::IndexIsValid(alias_.shape(), output_index))
<< "Trying to set up alias at " << output_index.ToString()
<< " which is an invalid index for shape "
<< ShapeUtil::HumanString(alias_.shape());
TF_RET_CHECK(param_number >= 0) << param_number;
TF_RET_CHECK(!OutputHasAlias(output_index))
<< "Output index " << output_index << " already has an alias setup";
// Output can't be aliased with multiple parameters.
TF_RET_CHECK(!alias_.element(output_index)) << absl::StrFormat(
"Trying to set up output alias for param %lld at %s but failed: output "
"index %s is already aliased with param %lld at %s",
param_number, param_index.ToString(), output_index.ToString(),
alias_.element(output_index)->parameter_number,
alias_.element(output_index)->parameter_index.ToString());
(*alias_.mutable_element(output_index)) =
Alias(kind, param_number, param_index);
VLOG(4) << "Set up alias between output index " << output_index.ToString()
<< " and parameter " << param_index << " at index "
<< param_index.ToString();
return Status::OK();
}
HloInputOutputAliasProto HloInputOutputAliasConfig::ToProto() const {
HloInputOutputAliasProto result;
alias_.ForEachElement(
[&](const ShapeIndex& index, const absl::optional<Alias>& data) {
if (data) {
HloInputOutputAliasProto::AliasEntryProto entry;
switch (data->kind) {
case AliasKind::kUserAlias:
entry.set_kind(HloInputOutputAliasProto::USER_ALIAS);
break;
case AliasKind::kSystemAlias:
entry.set_kind(HloInputOutputAliasProto::SYSTEM_ALIAS);
break;
default:
LOG(FATAL) << "Unknown alias kind " << data->kind;
}
for (int64 i : index) {
entry.add_output_shape_index(i);
}
entry.set_parameter_number(data->parameter_number);
for (int64 i : data->parameter_index) {
entry.add_parameter_shape_index(i);
}
result.add_entries()->Swap(&entry);
}
});
return result;
}
StatusOr<HloInputOutputAliasConfig> HloInputOutputAliasConfig::CreateFromProto(
Shape output_shape, const HloInputOutputAliasProto& proto) {
HloInputOutputAliasConfig result(std::move(output_shape));
for (const HloInputOutputAliasProto::AliasEntryProto& entry :
proto.entries()) {
ShapeIndex output_index(entry.output_shape_index().begin(),
entry.output_shape_index().end());
int64 param_number = entry.parameter_number();
ShapeIndex param_index(entry.parameter_shape_index().begin(),
entry.parameter_shape_index().end());
// Handle backward compatibility with existing protos, which only knew of
// system aliases.
AliasKind kind = AliasKind::kSystemAlias;
if (entry.kind() == HloInputOutputAliasProto::USER_ALIAS) {
kind = AliasKind::kUserAlias;
}
TF_RETURN_IF_ERROR(
result.SetUpAlias(output_index, param_number, param_index, kind));
}
return result;
}
string HloInputOutputAliasConfig::ToString() const {
std::vector<string> pieces;
pieces.push_back("HloInputOutputAliasConfig");
ForEachAlias([&](const ShapeIndex& output_index, const Alias& alias) {
const char* kind = alias.kind == AliasKind::kUserAlias ? "USER" : "SYSTEM";
pieces.push_back(absl::StrFormat(
" OutputIndex %s is aliased (kind=%s) with parameter %lld at %s:",
output_index.ToString(), kind, alias.parameter_number,
alias.parameter_index.ToString()));
});
return absl::StrJoin(pieces, "\n");
}
HloInputOutputAliasConfig::AliasKind
HloInputOutputAliasConfig::ParameterAliasKind(
int64 param_number, const ShapeIndex& param_index) const {
AliasKind kind = AliasKind::kNoAlias;
alias_.ForEachElement(
[&](const xla::ShapeIndex&, absl::optional<Alias> alias) {
if (alias && alias->parameter_number == param_number &&
alias->parameter_index == param_index) {
kind = alias->kind;
}
});
return kind;
}
absl::optional<ShapeIndex> HloInputOutputAliasConfig::GetAliasedOutput(
int64 param_number, const ShapeIndex& param_index) const {
absl::optional<ShapeIndex> output;
alias_.ForEachElement(
[&](const xla::ShapeIndex& output_index, absl::optional<Alias> alias) {
if (alias && alias->parameter_number == param_number &&
alias->parameter_index == param_index) {
output = output_index;
}
});
return output;
}
absl::optional<HloInputOutputAliasConfig::Alias>
HloInputOutputAliasConfig::GetAliasedParameter(
const ShapeIndex& output_index) const {
CHECK(ShapeUtil::IndexIsValid(alias_.shape(), output_index));
return alias_.element(output_index);
}
void HloInputOutputAliasConfig::ForEachAlias(AliasFn fn) const {
alias_.ForEachElement(
[&](const ShapeIndex& output_index, absl::optional<Alias> aliased) {
if (aliased) {
fn(output_index, *aliased);
}
});
}
Status HloInputOutputAliasConfig::ForEachAliasWithStatus(
AliasFnWithStatus fn) const {
return alias_.ForEachElementWithStatus(
[&](const ShapeIndex& output_index, absl::optional<Alias> aliased) {
if (aliased) {
TF_RETURN_IF_ERROR(fn(output_index, *aliased));
}
return Status::OK();
});
}
Status HloInputOutputAliasConfig::Verify(
const HloModule& module,
std::function<int64(const Shape&)> size_func) const {
std::vector<ShapeTree<bool>> param_has_seen;
const HloComputation* entry = module.entry_computation();
for (int64 i = 0; i < entry->num_parameters(); ++i) {
HloInstruction* param = entry->parameter_instruction(i);
param_has_seen.emplace_back(param->shape());
}
return ForEachAliasWithStatus([&](const ShapeIndex& output_index,
const Alias& alias) -> Status {
const HloInstruction* root = entry->root_instruction();
TF_RET_CHECK(0 <= alias.parameter_number);
TF_RET_CHECK(entry->num_parameters() > alias.parameter_number);
const Shape& param_shape =
entry->parameter_instruction(alias.parameter_number)->shape();
const Shape& output_shape = root->shape();
TF_RET_CHECK(ShapeUtil::IndexIsValid(param_shape, alias.parameter_index));
TF_RET_CHECK(ShapeUtil::IndexIsValid(output_shape, output_index));
const Shape& param_subshape =
ShapeUtil::GetSubshape(param_shape, alias.parameter_index);
const Shape& output_subshape =
ShapeUtil::GetSubshape(output_shape, output_index);
TF_RET_CHECK(LayoutUtil::IsDenseArray(param_subshape));
TF_RET_CHECK(LayoutUtil::IsDenseArray(output_subshape));
if (size_func(param_subshape) != size_func(output_subshape)) {
return InternalError(
"Expected aliased input %lld at index %s and output at index %s to "
"have the same size. Input sub-shape is %s with size %lld, output "
"sub-shape is %s with size %lld",
alias.parameter_number, alias.parameter_index.ToString(),
output_index.ToString(),
ShapeUtil::HumanStringWithLayout(param_subshape),
size_func(param_subshape),
ShapeUtil::HumanStringWithLayout(output_subshape),
size_func(output_subshape));
}
// Check each alias.parameter_number and alias.parameter_index pair only
// show up once. No input can be aliased with output buffers.
TF_RET_CHECK(param_has_seen[alias.parameter_number].element(
alias.parameter_index) == false);
*(param_has_seen[alias.parameter_number].mutable_element(
alias.parameter_index)) = true;
return Status::OK();
});
}
std::ostream& operator<<(std::ostream& out,
const HloInputOutputAliasConfig& config) {
out << config.ToString();
return out;
}
} // namespace xla
| [
"gardener@tensorflow.org"
] | gardener@tensorflow.org |
623e688b577b1767ba066c60beac6334bbc06ebb | 9f8d6ae0aa44e2a1abd7dd7312cc70bc2c31c25d | /Introductory/palindromeReorder.cpp | e95e8ce7d9b8aa1fb3842eaf872f748c7268365a | [] | no_license | RaniK27/CSES-Solutions | 515c73d955834fc26f71b54fffb9de63ff0815e3 | 6ead7b8b1661bf94394c7ec8cc225c0ed59fd8c8 | refs/heads/master | 2023-08-25T05:51:33.099786 | 2021-10-25T20:01:11 | 2021-10-25T20:01:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,263 | cpp | // Solution to Palindrome reorder question under the CSES Introductary Problem set
// Author: Vishvesh Trivedi (NerdyVisky)
#include <bits/stdc++.h>
#include <algorithm>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
int main(){
string str;
cin>>str;
sort(str.begin(), str.end());
ll n = str.length();
vector<char> strP(n);
ll i = 0;
ll k = 0;
ll flag = 1;
char odd = 'a';
while(i<n-1){
if(str[i]==str[i+1]){
strP[k] = str[i];
strP[n-1-k] = str[i+1];
k++;
i += 2;
}
else{
if(n%2 == 0){
cout<<("NO SOLUTION")<<endl;
return 0;
}else{
if(flag!=0){
odd = str[i];
i++;
flag = 0;
}else{
cout<<("NO SOLUTION")<<endl;
return 0;
}
}
}
}
if((n%2 != 0) && (odd == 'a')){
odd = str[n-1];
flag = 0;
}
if(flag==0){
strP[(n-1)/2] = odd;
}
for(int i = 0; i<n; i++){
cout<<(strP[i]);
}
return 0;
} | [
"noreply@github.com"
] | RaniK27.noreply@github.com |
60c536f427ea68e3cc9aa96fd4e5b13cc3ac45bf | ec3593662ff42d638fcc6d4f769b1e98142ac3e1 | /Classes/MapMindForestScene.h | c9fcc9eb27c3ccfa9945e3b9562e67606ba660df | [] | no_license | ymh3190/Cocos2d_Team_Portfolio | 71e08912304a64c763747c24f38d5a7cefae2577 | 0a3c3df3829f1164d8b47b1d845332ddec67e8f8 | refs/heads/master | 2022-03-29T22:04:45.421253 | 2020-02-01T16:08:09 | 2020-02-01T16:08:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 531 | h | #ifndef __MAP_MINDFOREST_H__
#define __MAP_MINDFOREST_H__
#include "cocos_framework.h"
#include "MapMindForestBg.h"
#include "MapMindForestUI.h"
class MapMindForestScene : public Scene
{
public:
static Scene* createScene();
virtual bool init();
CREATE_FUNC(MapMindForestScene);
void onEnter();
void onExit();
bool onTouchBegan(Touch* touch, Event* event);
private:
EventListenerTouchOneByOne* _listener;
MapMindForestBg* _mapMindForestBg;
MapMindForestUI* _mapMindForestUI;
};
#endif // __MAP_MINDFOREST_H__
| [
"ymh3190@gmail.com"
] | ymh3190@gmail.com |
82f795691bf3354044020b005613c8b4ab5bf20d | f91b194b173ac314aa6f6d17dd5450c5573b0b55 | /src/cryptonotecore/CachedTransaction.h | 44dbf5dcc835e99c428202e7035c95f14961af8b | [
"MIT"
] | permissive | Menutra/catalyst-cli | cd9057d8d4951212b057a3b5844fe24509715eb0 | 27c2833d43a4c80f732f55932c885a03490e0469 | refs/heads/development | 2023-01-03T12:07:35.125808 | 2020-10-14T15:41:03 | 2020-10-14T15:41:03 | 303,084,231 | 0 | 0 | MIT | 2020-10-14T07:35:46 | 2020-10-11T09:22:55 | C++ | UTF-8 | C++ | false | false | 1,177 | h | // Copyright (c) 2012-2017, The CryptoNote developers, The Bytecoin developers
// Copyright (c) 2018-2019, The TurtleCoin Developers
//
// Please see the included LICENSE file for more information.
#pragma once
#include <CryptoNote.h>
#include <boost/optional.hpp>
namespace CryptoNote
{
class CachedTransaction
{
public:
explicit CachedTransaction(Transaction &&transaction);
explicit CachedTransaction(const Transaction &transaction);
explicit CachedTransaction(const BinaryArray &transactionBinaryArray);
const Transaction &getTransaction() const;
const Crypto::Hash &getTransactionHash() const;
const Crypto::Hash &getTransactionPrefixHash() const;
const BinaryArray &getTransactionBinaryArray() const;
uint64_t getTransactionFee() const;
private:
Transaction transaction;
mutable boost::optional<BinaryArray> transactionBinaryArray;
mutable boost::optional<Crypto::Hash> transactionHash;
mutable boost::optional<Crypto::Hash> transactionPrefixHash;
mutable boost::optional<uint64_t> transactionFee;
};
} // namespace CryptoNote
| [
"noreply@github.com"
] | Menutra.noreply@github.com |
686f967086b2d05a522b054dde1fca529c8ee2da | 1266254e5763ec1dbbd861fa2045bcef1edbcec6 | /Modules/Editor/Library/OsgImGuiHandler.h | 2dc687ab5970406541bc0332c1a58db0ee1f40ea | [
"Bitstream-Vera",
"BSL-1.0",
"Apache-2.0",
"LicenseRef-scancode-public-domain"
] | permissive | simquest/opensurgsim | 0a443f8e54b276f4e41ed991b2fcb3d2b0c0b5a7 | bd30629f2fd83f823632293959b7654275552fa9 | refs/heads/master | 2022-02-13T15:05:47.744267 | 2020-11-24T14:27:19 | 2020-11-24T14:27:19 | 24,512,532 | 30 | 11 | Apache-2.0 | 2022-02-03T20:18:01 | 2014-09-26T19:25:40 | C++ | UTF-8 | C++ | false | false | 796 | h | #ifndef OSGIMGUIHANDLER_H
#define OSGIMGUIHANDLER_H
// Source https://github.com/Tordan/imgui-osg
#include <osgViewer/ViewerEventHandlers>
namespace osg {
class Camera;
}
class OsgImGuiHandler : public osgGA::GUIEventHandler
{
public:
OsgImGuiHandler();
bool handle(const osgGA::GUIEventAdapter& ea, osgGA::GUIActionAdapter& aa) override;
protected:
// Put your ImGui code inside this function
virtual void drawUi() = 0;
private:
void init();
void setCameraCallbacks(osg::Camera* camera);
void newFrame(osg::RenderInfo& renderInfo);
void render(osg::RenderInfo& renderInfo);
private:
struct ImGuiNewFrameCallback;
struct ImGuiRenderCallback;
double time_;
bool mousePressed_[3];
float mouseWheel_;
bool initialized_;
};
#endif
| [
"noreply@github.com"
] | simquest.noreply@github.com |
f780605e35e1e672e8183ba7483857952dc2dd0f | 1942a0d16bd48962e72aa21fad8d034fa9521a6c | /aws-cpp-sdk-clouddirectory/include/aws/clouddirectory/model/CreateIndexRequest.h | 038a095550bc59625f8909d2265107df154a62eb | [
"Apache-2.0",
"JSON",
"MIT"
] | permissive | yecol/aws-sdk-cpp | 1aff09a21cfe618e272c2c06d358cfa0fb07cecf | 0b1ea31e593d23b5db49ee39d0a11e5b98ab991e | refs/heads/master | 2021-01-20T02:53:53.557861 | 2018-02-11T11:14:58 | 2018-02-11T11:14:58 | 83,822,910 | 0 | 1 | null | 2017-03-03T17:17:00 | 2017-03-03T17:17:00 | null | UTF-8 | C++ | false | false | 8,340 | h | /*
* Copyright 2010-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file 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 <aws/clouddirectory/CloudDirectory_EXPORTS.h>
#include <aws/clouddirectory/CloudDirectoryRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/clouddirectory/model/ObjectReference.h>
#include <aws/clouddirectory/model/AttributeKey.h>
namespace Aws
{
namespace CloudDirectory
{
namespace Model
{
/**
*/
class AWS_CLOUDDIRECTORY_API CreateIndexRequest : public CloudDirectoryRequest
{
public:
CreateIndexRequest();
Aws::String SerializePayload() const override;
Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
/**
* <p>The ARN of the directory where the index should be created.</p>
*/
inline const Aws::String& GetDirectoryArn() const{ return m_directoryArn; }
/**
* <p>The ARN of the directory where the index should be created.</p>
*/
inline void SetDirectoryArn(const Aws::String& value) { m_directoryArnHasBeenSet = true; m_directoryArn = value; }
/**
* <p>The ARN of the directory where the index should be created.</p>
*/
inline void SetDirectoryArn(Aws::String&& value) { m_directoryArnHasBeenSet = true; m_directoryArn = value; }
/**
* <p>The ARN of the directory where the index should be created.</p>
*/
inline void SetDirectoryArn(const char* value) { m_directoryArnHasBeenSet = true; m_directoryArn.assign(value); }
/**
* <p>The ARN of the directory where the index should be created.</p>
*/
inline CreateIndexRequest& WithDirectoryArn(const Aws::String& value) { SetDirectoryArn(value); return *this;}
/**
* <p>The ARN of the directory where the index should be created.</p>
*/
inline CreateIndexRequest& WithDirectoryArn(Aws::String&& value) { SetDirectoryArn(value); return *this;}
/**
* <p>The ARN of the directory where the index should be created.</p>
*/
inline CreateIndexRequest& WithDirectoryArn(const char* value) { SetDirectoryArn(value); return *this;}
/**
* <p>Specifies the Attributes that should be indexed on. Currently only a single
* attribute is supported.</p>
*/
inline const Aws::Vector<AttributeKey>& GetOrderedIndexedAttributeList() const{ return m_orderedIndexedAttributeList; }
/**
* <p>Specifies the Attributes that should be indexed on. Currently only a single
* attribute is supported.</p>
*/
inline void SetOrderedIndexedAttributeList(const Aws::Vector<AttributeKey>& value) { m_orderedIndexedAttributeListHasBeenSet = true; m_orderedIndexedAttributeList = value; }
/**
* <p>Specifies the Attributes that should be indexed on. Currently only a single
* attribute is supported.</p>
*/
inline void SetOrderedIndexedAttributeList(Aws::Vector<AttributeKey>&& value) { m_orderedIndexedAttributeListHasBeenSet = true; m_orderedIndexedAttributeList = value; }
/**
* <p>Specifies the Attributes that should be indexed on. Currently only a single
* attribute is supported.</p>
*/
inline CreateIndexRequest& WithOrderedIndexedAttributeList(const Aws::Vector<AttributeKey>& value) { SetOrderedIndexedAttributeList(value); return *this;}
/**
* <p>Specifies the Attributes that should be indexed on. Currently only a single
* attribute is supported.</p>
*/
inline CreateIndexRequest& WithOrderedIndexedAttributeList(Aws::Vector<AttributeKey>&& value) { SetOrderedIndexedAttributeList(value); return *this;}
/**
* <p>Specifies the Attributes that should be indexed on. Currently only a single
* attribute is supported.</p>
*/
inline CreateIndexRequest& AddOrderedIndexedAttributeList(const AttributeKey& value) { m_orderedIndexedAttributeListHasBeenSet = true; m_orderedIndexedAttributeList.push_back(value); return *this; }
/**
* <p>Specifies the Attributes that should be indexed on. Currently only a single
* attribute is supported.</p>
*/
inline CreateIndexRequest& AddOrderedIndexedAttributeList(AttributeKey&& value) { m_orderedIndexedAttributeListHasBeenSet = true; m_orderedIndexedAttributeList.push_back(value); return *this; }
/**
* <p>Indicates whether objects with the same indexed attribute value can be added
* to the index.</p>
*/
inline bool GetIsUnique() const{ return m_isUnique; }
/**
* <p>Indicates whether objects with the same indexed attribute value can be added
* to the index.</p>
*/
inline void SetIsUnique(bool value) { m_isUniqueHasBeenSet = true; m_isUnique = value; }
/**
* <p>Indicates whether objects with the same indexed attribute value can be added
* to the index.</p>
*/
inline CreateIndexRequest& WithIsUnique(bool value) { SetIsUnique(value); return *this;}
/**
* <p>A reference to the parent object that contains the index object.</p>
*/
inline const ObjectReference& GetParentReference() const{ return m_parentReference; }
/**
* <p>A reference to the parent object that contains the index object.</p>
*/
inline void SetParentReference(const ObjectReference& value) { m_parentReferenceHasBeenSet = true; m_parentReference = value; }
/**
* <p>A reference to the parent object that contains the index object.</p>
*/
inline void SetParentReference(ObjectReference&& value) { m_parentReferenceHasBeenSet = true; m_parentReference = value; }
/**
* <p>A reference to the parent object that contains the index object.</p>
*/
inline CreateIndexRequest& WithParentReference(const ObjectReference& value) { SetParentReference(value); return *this;}
/**
* <p>A reference to the parent object that contains the index object.</p>
*/
inline CreateIndexRequest& WithParentReference(ObjectReference&& value) { SetParentReference(value); return *this;}
/**
* <p>The name of the link between the parent object and the index object.</p>
*/
inline const Aws::String& GetLinkName() const{ return m_linkName; }
/**
* <p>The name of the link between the parent object and the index object.</p>
*/
inline void SetLinkName(const Aws::String& value) { m_linkNameHasBeenSet = true; m_linkName = value; }
/**
* <p>The name of the link between the parent object and the index object.</p>
*/
inline void SetLinkName(Aws::String&& value) { m_linkNameHasBeenSet = true; m_linkName = value; }
/**
* <p>The name of the link between the parent object and the index object.</p>
*/
inline void SetLinkName(const char* value) { m_linkNameHasBeenSet = true; m_linkName.assign(value); }
/**
* <p>The name of the link between the parent object and the index object.</p>
*/
inline CreateIndexRequest& WithLinkName(const Aws::String& value) { SetLinkName(value); return *this;}
/**
* <p>The name of the link between the parent object and the index object.</p>
*/
inline CreateIndexRequest& WithLinkName(Aws::String&& value) { SetLinkName(value); return *this;}
/**
* <p>The name of the link between the parent object and the index object.</p>
*/
inline CreateIndexRequest& WithLinkName(const char* value) { SetLinkName(value); return *this;}
private:
Aws::String m_directoryArn;
bool m_directoryArnHasBeenSet;
Aws::Vector<AttributeKey> m_orderedIndexedAttributeList;
bool m_orderedIndexedAttributeListHasBeenSet;
bool m_isUnique;
bool m_isUniqueHasBeenSet;
ObjectReference m_parentReference;
bool m_parentReferenceHasBeenSet;
Aws::String m_linkName;
bool m_linkNameHasBeenSet;
};
} // namespace Model
} // namespace CloudDirectory
} // namespace Aws
| [
"henso@amazon.com"
] | henso@amazon.com |
e38578ac6194bbe3d83984fd0fb5fb4e18a46af8 | 70c69365a7a5b86af601fbf071f221c85abef9fc | /tensorflow/compiler/mlir/tensorflow/utils/compile_mlir_util.cc | 1e9a9864ed6921244649ac6d375da9948160b692 | [
"Apache-2.0",
"LicenseRef-scancode-generic-cla",
"BSD-2-Clause"
] | permissive | dyna999/tensorflow | 3ed8f243b8cc8bb30a8c96dbd30e4b27be226f83 | 163c946f6827ce9e3ffa49e56fa65ce520bf6ea5 | refs/heads/master | 2022-03-28T03:00:28.650532 | 2022-03-25T22:47:49 | 2022-03-25T22:51:26 | 97,944,926 | 0 | 0 | Apache-2.0 | 2022-01-07T22:43:29 | 2017-07-21T12:22:03 | C++ | UTF-8 | C++ | false | false | 36,486 | cc | /* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/compiler/mlir/tensorflow/utils/compile_mlir_util.h"
#include "tensorflow/compiler/mlir/mlir_bridge_rollout_policy.h"
#include "absl/types/optional.h"
#include "absl/types/variant.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/raw_ostream.h"
#include "mlir/Dialect/Func/IR/FuncOps.h" // from @llvm-project
#include "mlir/Dialect/Shape/IR/Shape.h" // from @llvm-project
#include "mlir/IR/Attributes.h" // from @llvm-project
#include "mlir/IR/BuiltinOps.h" // from @llvm-project
#include "mlir/IR/BuiltinTypes.h" // from @llvm-project
#include "mlir/IR/Dialect.h" // from @llvm-project
#include "mlir/IR/Location.h" // from @llvm-project
#include "mlir/IR/MLIRContext.h" // from @llvm-project
#include "mlir/IR/OpDefinition.h" // from @llvm-project
#include "mlir/Transforms/Passes.h" // from @llvm-project
#include "tensorflow/compiler/mlir/hlo/include/mlir-hlo/Dialect/mhlo/IR/hlo_ops.h"
#include "tensorflow/compiler/mlir/hlo/include/mlir-hlo/Dialect/mhlo/IR/register.h"
#include "tensorflow/compiler/mlir/hlo/include/mlir-hlo/Dialect/mhlo/transforms/passes.h"
#include "tensorflow/compiler/mlir/tensorflow/dialect_registration.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_executor.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_types.h"
#include "tensorflow/compiler/mlir/tensorflow/transforms/passes.h"
#include "tensorflow/compiler/mlir/tensorflow/transforms/shape_inference.h"
#include "tensorflow/compiler/mlir/tensorflow/translate/import_model.h"
#include "tensorflow/compiler/mlir/tensorflow/translate/mlir_roundtrip_flags.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/bridge_logger.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/convert_tensor.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/convert_type.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/error_util.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/serialize_mlir_module_utils.h"
#include "tensorflow/compiler/mlir/tensorflow/utils/translate_utils.h"
#include "tensorflow/compiler/mlir/xla/mlir_hlo_to_hlo.h"
#include "tensorflow/compiler/mlir/xla/transforms/adjust_layout.h"
#include "tensorflow/compiler/mlir/xla/transforms/passes.h"
#include "tensorflow/compiler/mlir/xla/type_to_shape.h"
#include "tensorflow/compiler/tf2xla/layout_util.h"
#include "tensorflow/compiler/tf2xla/shape_util.h"
#include "tensorflow/compiler/tf2xla/xla_helpers.h"
#include "tensorflow/compiler/xla/service/hlo_sharding.h"
#include "tensorflow/compiler/xla/shape.h"
#include "tensorflow/compiler/xla/xla_data.pb.h"
#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/platform/logging.h"
#include "tensorflow/core/tpu/tpu_defs.h"
namespace tensorflow {
namespace {
constexpr absl::string_view kGroupSizeAttrName =
"tf2xla.collective_info.group_size";
constexpr absl::string_view kGroupKeyAttrName =
"tf2xla.collective_info.group_key";
// Extracts shape from XlaArgument as TensorShape. If shape is a xla::Shape,
// that is converted to a TensorShape.
StatusOr<TensorShape> GetTensorShapeFromXlaArgument(const XlaArgument& arg) {
if (absl::holds_alternative<xla::Shape>(arg.shape)) {
TensorShape arg_shape;
TF_RETURN_IF_ERROR(
XLAShapeToTensorShape(absl::get<xla::Shape>(arg.shape), &arg_shape));
return arg_shape;
} else {
return absl::get<TensorShape>(arg.shape);
}
}
Status MaybeRewriteLayoutWithShardedShape(
mlir::StringAttr sharding,
const XlaHelpers::ShapeRepresentationFn shape_representation_fn,
xla::Shape* shape) {
if (!sharding) return Status::OK();
xla::OpSharding op_sharding;
if (!op_sharding.ParseFromString(sharding.getValue().str()))
return errors::InvalidArgument("failed to parse sharding '",
sharding.getValue().str(), "'");
absl::optional<xla::HloSharding> hlo_sharding;
TF_ASSIGN_OR_RETURN(hlo_sharding, xla::HloSharding::FromProto(op_sharding));
TF_RETURN_IF_ERROR(RewriteLayoutWithShardedShape(
hlo_sharding, /*use_fast_memory=*/false, shape_representation_fn, shape));
return Status::OK();
}
// Converts arg_shapes to xla::Shape's and store into xla_input_shapes.
Status GetXlaInputShapes(
mlir::ModuleOp module, llvm::ArrayRef<TensorOrResourceShape> arg_shapes,
bool use_tuple_args,
const XlaHelpers::ShapeRepresentationFn shape_representation_fn,
std::vector<xla::Shape>* xla_input_shapes) {
xla_input_shapes->clear();
mlir::FuncOp main_func = module.lookupSymbol<mlir::FuncOp>("main");
TF_RET_CHECK(main_func != nullptr) << "No main function found";
mlir::FunctionType func_type = main_func.getFunctionType();
int num_args = func_type.getNumInputs();
xla_input_shapes->reserve(num_args);
std::vector<xla::Shape> individual_arg_shapes;
individual_arg_shapes.reserve(num_args);
for (int i = 0; i < num_args; ++i) {
individual_arg_shapes.emplace_back();
xla::Shape& xla_shape = individual_arg_shapes.back();
DataType dtype;
TF_RETURN_IF_ERROR(ConvertToDataType(func_type.getInput(i), &dtype));
TF_ASSIGN_OR_RETURN(
xla_shape, shape_representation_fn(arg_shapes[i].shape, dtype,
/*use_fast_memory=*/false,
XlaLayoutPreference::kNoPreference));
// Rewrite layout with sharding, if sharding is set.
auto sharding =
main_func.getArgAttrOfType<mlir::StringAttr>(i, "mhlo.sharding");
TF_RETURN_IF_ERROR(MaybeRewriteLayoutWithShardedShape(
sharding, shape_representation_fn, &xla_shape));
}
if (use_tuple_args) {
xla_input_shapes->push_back(
xla::ShapeUtil::MakeTupleShape(individual_arg_shapes));
} else {
*xla_input_shapes = individual_arg_shapes;
}
return Status::OK();
}
// Calculates computation output shape and build OutputDescription for each
// output based on static shapes in MLIR module. If an output is a resource
// write, `resource_updates` is populated insead of `outputs` for that output.
Status GetOutputInfo(
mlir::ModuleOp module, bool use_resource_updates_for_aliases,
const XlaHelpers::ShapeRepresentationFn shape_representation_fn,
xla::Shape* xla_output_shape, std::vector<XlaOutputDescription>* outputs,
std::vector<XlaResourceUpdate>* resource_updates) {
auto shape_representation_fn_no_fast_memory =
[shape_representation_fn](const TensorShape& shape, DataType dtype) {
return shape_representation_fn(shape, dtype, /*use_fast_memory=*/false,
XlaLayoutPreference::kNoPreference);
};
mlir::FuncOp main_func = module.lookupSymbol<mlir::FuncOp>("main");
mlir::FunctionType func_type = main_func.getFunctionType();
outputs->clear();
outputs->reserve(func_type.getNumResults());
resource_updates->clear();
resource_updates->reserve(func_type.getNumResults());
std::vector<xla::Shape> shapes;
shapes.reserve(func_type.getNumResults());
llvm::SmallDenseMap<unsigned, unsigned> output_to_input_alias;
for (unsigned i = 0; i < main_func.getNumArguments(); ++i)
if (auto aliasing_output = main_func.getArgAttrOfType<mlir::IntegerAttr>(
i, "tf.aliasing_output"))
output_to_input_alias[aliasing_output.getInt()] = i;
for (auto type_and_idx : llvm::enumerate(func_type.getResults())) {
TF_ASSIGN_OR_RETURN(
xla::Shape shape,
xla::TypeToShape(type_and_idx.value(),
shape_representation_fn_no_fast_memory));
auto sharding = main_func.getResultAttrOfType<mlir::StringAttr>(
type_and_idx.index(), "mhlo.sharding");
TF_RETURN_IF_ERROR(MaybeRewriteLayoutWithShardedShape(
sharding, shape_representation_fn, &shape));
auto tensor_type = type_and_idx.value().dyn_cast<mlir::RankedTensorType>();
shapes.push_back(shape);
auto it = output_to_input_alias.find(type_and_idx.index());
if (it != output_to_input_alias.end() && use_resource_updates_for_aliases) {
// Add resource write.
resource_updates->emplace_back();
XlaResourceUpdate& resource_update = resource_updates->back();
resource_update.input_index = it->getSecond();
resource_update.modified = true;
TF_RETURN_IF_ERROR(ConvertToDataType(tensor_type, &resource_update.type));
TF_RETURN_IF_ERROR(XLAShapeToTensorShape(shape, &resource_update.shape));
continue;
}
// Construct OutputDescription for result.
outputs->emplace_back();
XlaOutputDescription& out_desc = outputs->back();
TF_RETURN_IF_ERROR(ConvertToDataType(tensor_type, &out_desc.type));
// TODO(ycao): Support constant output.
out_desc.is_constant = false;
TF_RETURN_IF_ERROR(XLAShapeToTensorShape(shape, &out_desc.shape));
// Input_index is only meaningful for resource output. Setting it to
// meaningless value -1 for non resource outputs.
out_desc.input_index =
it != output_to_input_alias.end() ? it->getSecond() : -1;
// MLIR-based TF-Compiler bridge doesn't support tensorlist output yet.
// TODO(ycao): Support tensorlist-type output.
out_desc.is_tensor_list = false;
}
// XLA computation always uses Tuple shape.
*xla_output_shape = xla::ShapeUtil::MakeTupleShape(shapes);
return Status::OK();
}
// Creates a vector that maps from the parameters of the XLA computation to
// their original argument positions.
// MLIR-based TF-Compiler bridge doesn't have constant analysis yet, thus no
// inputs are known constants. Therefore, the input mapping between input to
// computation arguments is a trivial in-order 1-1 mapping.
// TODO(ycao): Support computation with compile-time constant, which requires
// non-trivial input mapping as implemented now.
void GetInputMappingForMlir(int num_inputs, std::vector<int>* input_mapping) {
input_mapping->resize(num_inputs, 0);
std::iota(input_mapping->begin(), input_mapping->end(), 0);
}
static void RegisterDialects(mlir::DialectRegistry& registry) {
mlir::RegisterAllTensorFlowDialects(registry);
mlir::mhlo::registerAllMhloDialects(registry);
}
// Checks if functions can be inlined after TF -> HLO legalization. Currently
// TPU's are supported, to follow the behavior of inlining functions via the
// Graph based bridge in the TPUCompile op kernel.
bool CanInlineFunctionsPostLegalization(llvm::StringRef device_type) {
return device_type == DEVICE_TPU_XLA_JIT;
}
} // namespace
Status RefineShapes(llvm::ArrayRef<TensorOrResourceShape> arg_shapes,
mlir::ModuleOp module) {
auto producer_or = GetTfGraphProducerVersion(module);
if (!producer_or.ok()) return producer_or.status();
int64_t producer_version = producer_or.ValueOrDie();
llvm::SmallVector<int64_t, 16> shape_backing;
llvm::SmallVector<llvm::ArrayRef<int64_t>, 4> arg_shapes_copy;
{
// Convert arg_shapes to a mlir friendly format.
size_t count = 0;
for (const TensorOrResourceShape& tensor_resource_shape : arg_shapes) {
if (tensor_resource_shape.is_resource) continue;
count += tensor_resource_shape.shape.dims();
}
shape_backing.resize(count);
arg_shapes_copy.reserve(arg_shapes.size());
size_t offset = 0;
for (const TensorOrResourceShape& tensor_resource_shape : arg_shapes) {
if (tensor_resource_shape.is_resource) {
arg_shapes_copy.push_back(llvm::ArrayRef<int64_t>());
continue;
}
size_t start = offset;
for (tensorflow::TensorShapeDim dim : tensor_resource_shape.shape) {
shape_backing[offset] = dim.size;
++offset;
}
if (offset == start) {
arg_shapes_copy.push_back(llvm::ArrayRef<int64_t>());
} else {
arg_shapes_copy.push_back(
llvm::ArrayRef<int64_t>(&shape_backing[start], offset - start));
}
}
}
auto main_func = module.lookupSymbol<mlir::FuncOp>("main");
mlir::StatusScopedDiagnosticHandler error_handler(module.getContext());
mlir::LogicalResult result = mlir::TF::InferShapeForFunction(
main_func, arg_shapes_copy, producer_version);
if (failed(result)) {
return error_handler.Combine(
errors::Internal("MLIR Shape refinement failed"));
}
return error_handler.ConsumeStatus();
}
void CreateConvertMlirToXlaHloPipeline(
mlir::OpPassManager& pm, llvm::StringRef device_type, bool prefer_tf2xla,
llvm::MutableArrayRef<std::unique_ptr<mlir::Pass>>
custom_legalization_passes) {
// Note that the region-based control-flow produced here still contains
// function call ops which get inlined by the subsequent inliner pass.
pm.addPass(mlir::TF::CreateTFFunctionalControlFlowToRegions());
pm.addPass(mlir::createInlinerPass());
pm.addNestedPass<mlir::FuncOp>(mlir::TF::CreateDropWhileShapeInvariantPass());
pm.addNestedPass<mlir::FuncOp>(mlir::createCanonicalizerPass());
// The SCCP pass performs constant propagation across the IR, which, for
// example, propagates constant arguments into callee functions.
// TOOD(hinsu): Investigate if we really need SCCP pass before shape inference
// and can do with just one pass after the shape inference.
pm.addPass(mlir::createSCCPPass());
// Guarantee all functions have one use, which enables shape inference.
pm.addPass(mlir::TF::CreateGuaranteeAllFuncsOneUsePass());
// Run shape inference pass before tensorlist decomposition to get buffer
// shape of uninitialized TensorLists.
pm.addPass(mlir::TF::CreateTFShapeInferencePass());
// Run SCCP pass again as the availability of shapes may open up new
// opportunities for constant propagation. Note that the shape inference pass
// doesn't materialize new constants even if those are computed internally for
// the purpose of shape inference. These constants might be required by the
// legalization passes.
pm.addPass(mlir::createSCCPPass());
pm.addPass(mlir::TF::CreateTensorListOpsDecompositionPass());
pm.addPass(mlir::TF::CreateStackOpsDecompositionPass());
pm.addPass(mlir::TF::CreateTensorArrayOpsDecompositionPass());
pm.addNestedPass<mlir::FuncOp>(
mlir::TFDevice::CreateDecomposeResourceOpsPass());
pm.addPass(mlir::TF::CreatePromoteResourcesToArgsPass());
pm.addPass(mlir::createSymbolDCEPass());
pm.addPass(mlir::TF::CreateTFShapeInferencePass());
// TODO(b/171426148): We cannot completely remove region to functional control
// flow conversion from this pipeline yet as it causes some unit tests to
// fail.
pm.addPass(mlir::TF::CreateTFRegionControlFlowToFunctional());
// LegalizeTFControlFlow encapsulates arguments for control flow operations
// with a tuple argument which break the assumption of resource lifting
// inside PromoteResourcesToArgs.
pm.addPass(mlir::mhlo::createLegalizeTFControlFlowPass());
pm.addNestedPass<mlir::FuncOp>(mlir::TF::CreateLowerQuantizedPass());
pm.addPass(mlir::mhlo::CreateLegalizeTfTypesPass());
pm.addNestedPass<mlir::FuncOp>(mlir::mhlo::createLegalizeTFPass(
/*allow_partial_conversion=*/true, /*legalize_chlo=*/true,
/*tf2xla_fallback_device_type=*/device_type, prefer_tf2xla));
for (auto& target_pass : custom_legalization_passes) {
pm.addNestedPass<mlir::FuncOp>(std::move(target_pass));
}
pm.addNestedPass<mlir::FuncOp>(mlir::mhlo::CreateAdjustLayoutPass());
pm.addPass(mlir::mhlo::CreateLegalizeTFCommunicationPass());
pm.addPass(mlir::mhlo::CreateLegalizeTFCollectivePass());
pm.addNestedPass<mlir::FuncOp>(mlir::createCanonicalizerPass());
// Run shape inference pass to propagate shapes through tensor_cast operations
// from static to dynamic shapes. This could be generated if the shape
// inference was originally missing in a TF op but the corresponding HLO op
// had static shape after lowering.
pm.addPass(mlir::TF::CreateTFShapeInferencePass());
// Run LegalizeTFPass again because the previous legalization passes can
// expose more graph pruning and canonicalization opportunities that are
// necessary for the second LegalizeTFPass(allow_partial_conversion=false)
// invocation.
pm.addNestedPass<mlir::FuncOp>(mlir::mhlo::createLegalizeTFPass(
/*allow_partial_conversion=*/false, /*legalize_chlo=*/true,
/*tf2xla_fallback_device_type=*/device_type, prefer_tf2xla));
if (CanInlineFunctionsPostLegalization(device_type))
pm.addPass(mlir::createInlinerPass());
// In order to export to XLA, we must sink constants to control flow regions,
// since XLA uses functional control flow.
pm.addNestedPass<mlir::FuncOp>(
mlir::mhlo::createSinkConstantsToControlFlowPass());
}
Status LegalizeToHlo(mlir::ModuleOp module_op, llvm::StringRef device_type,
bool prefer_tf2xla,
llvm::MutableArrayRef<std::unique_ptr<mlir::Pass>>
custom_legalization_passes) {
mlir::PassManager tf2xla(module_op.getContext());
applyTensorflowAndCLOptions(tf2xla);
CreateConvertMlirToXlaHloPipeline(tf2xla, device_type, prefer_tf2xla,
custom_legalization_passes);
if (VLOG_IS_ON(1))
tensorflow::DumpMlirOpToFile("legalize_hlo_before", module_op);
if (VLOG_IS_ON(2)) {
// Print the whole module after each pass which requires disabling
// multi-threading as well.
module_op.getContext()->disableMultithreading();
tf2xla.enableIRPrinting(std::make_unique<tensorflow::BridgeLoggerConfig>(
/*print_module_scope=*/true));
}
// Make sure we catch any error reported by MLIR and forward it to the TF
// error reporting system. Report a generic error if pass manager failed
// without emitting a diagnostic.
mlir::StatusScopedDiagnosticHandler error_handler(module_op.getContext());
if (failed(tf2xla.run(module_op))) {
return error_handler.Combine(
errors::InvalidArgument("TF to XLA legalization failed: "));
}
if (VLOG_IS_ON(1))
tensorflow::DumpMlirOpToFile("legalize_hlo_after", module_op);
return error_handler.ConsumeStatus();
}
Status BuildHloFromTfInner(mlir::ModuleOp module_op, xla::XlaBuilder& builder,
llvm::ArrayRef<xla::XlaOp> xla_params,
std::vector<xla::XlaOp>& returns,
llvm::StringRef device_type,
llvm::MutableArrayRef<std::unique_ptr<mlir::Pass>>
custom_legalization_passes) {
TF_RETURN_IF_ERROR(LegalizeToHlo(module_op, device_type,
/*prefer_tf2xla=*/false,
custom_legalization_passes));
mlir::Block& block = module_op.lookupSymbol<mlir::FuncOp>("main").front();
return mlir::BuildHloFromMlirHlo(block, builder, xla_params, returns);
}
Status ConvertMLIRToXlaComputation(
mlir::ModuleOp module_op, llvm::StringRef device_type,
xla::XlaComputation* xla_computation, bool use_tuple_args,
bool prefer_tf2xla, bool return_tuple,
const XlaHelpers::ShapeRepresentationFn shape_representation_fn,
llvm::MutableArrayRef<std::unique_ptr<mlir::Pass>>
custom_legalization_passes) {
TF_RETURN_IF_ERROR(LegalizeToHlo(module_op, device_type, prefer_tf2xla,
custom_legalization_passes));
xla::HloProto hlo_proto;
TF_RETURN_IF_ERROR(mlir::ConvertMlirHloToHlo(module_op, &hlo_proto,
use_tuple_args, return_tuple,
shape_representation_fn));
*xla_computation = xla::XlaComputation(hlo_proto.hlo_module());
return Status::OK();
}
Status CompileMlirSetup(
mlir::ModuleOp module_op, llvm::ArrayRef<TensorOrResourceShape> arg_shapes,
XlaHelpers::ShapeRepresentationFn* shape_representation_fn) {
// Use arg_shapes to improve the mlir type information of `main` in module_op.
TF_RETURN_IF_ERROR(RefineShapes(arg_shapes, module_op));
if (VLOG_IS_ON(2))
tensorflow::DumpMlirOpToFile("compile_mlir_shape_refiner", module_op);
if (!*shape_representation_fn)
*shape_representation_fn = IdentityShapeRepresentationFn();
return Status::OK();
}
Status BuildHloFromTf(mlir::ModuleOp module_op, xla::XlaBuilder& builder,
llvm::ArrayRef<xla::XlaOp> xla_params,
std::vector<xla::XlaOp>& returns,
llvm::ArrayRef<TensorOrResourceShape> arg_shapes,
llvm::StringRef device_type,
llvm::MutableArrayRef<std::unique_ptr<mlir::Pass>>
custom_legalization_passes) {
if (VLOG_IS_ON(2))
tensorflow::DumpMlirOpToFile("build_hlo_tf_before", module_op);
XlaHelpers::ShapeRepresentationFn shape_representation_fn;
TF_RETURN_IF_ERROR(
CompileMlirSetup(module_op, arg_shapes, &shape_representation_fn));
// Convert MLIR module to XLA HLO proto contained in XlaComputation.
TF_RETURN_IF_ERROR(BuildHloFromTfInner(module_op, builder, xla_params,
returns, device_type,
custom_legalization_passes));
if (VLOG_IS_ON(2))
tensorflow::DumpMlirOpToFile("build_hlo_tf_after", module_op);
return Status::OK();
}
Status PopulateCollectiveInfo(mlir::ModuleOp module_op,
XlaCompilationResult* compilation_result) {
// The StringRef cast is necessary before cxx14.
mlir::IntegerAttr group_key_attr =
module_op->getAttrOfType<mlir::IntegerAttr>(
mlir::StringRef(kGroupKeyAttrName.data(), kGroupKeyAttrName.size()));
mlir::IntegerAttr group_size_attr =
module_op->getAttrOfType<mlir::IntegerAttr>(mlir::StringRef(
kGroupSizeAttrName.data(), kGroupSizeAttrName.size()));
if (group_key_attr == nullptr && group_size_attr == nullptr) {
// No CollectiveInfo is present.
return Status::OK();
}
DCHECK(group_key_attr != nullptr)
<< "module attribute " << kGroupKeyAttrName
<< " is required for CollectiveInfo but not found.";
DCHECK(group_size_attr != nullptr)
<< "module attribute " << kGroupSizeAttrName
<< " is required for CollectiveInfo but not found.";
int32_t group_key = group_key_attr.getInt();
int32_t group_size = group_size_attr.getInt();
VLOG(2) << "Populating CollectiveInfo: group_key=" << group_key
<< " group_size=" << group_size;
compilation_result->collective_info = {group_key, group_size, 0};
return Status::OK();
}
Status PopulateResultIOInfo(
mlir::ModuleOp module_op, llvm::ArrayRef<TensorOrResourceShape> arg_shapes,
bool use_tuple_args, bool use_resource_updates_for_aliases,
XlaHelpers::ShapeRepresentationFn shape_representation_fn,
XlaCompilationResult* compilation_result) {
// Construct mapping from XlaComputation's arg to input edges of execute
// node.
GetInputMappingForMlir(arg_shapes.size(), &compilation_result->input_mapping);
// Compute all input shapes.
TF_RETURN_IF_ERROR(GetXlaInputShapes(module_op, arg_shapes, use_tuple_args,
shape_representation_fn,
&compilation_result->xla_input_shapes));
// Compute all output descriptions and resource writes
return GetOutputInfo(
module_op, use_resource_updates_for_aliases, shape_representation_fn,
&compilation_result->xla_output_shape, &compilation_result->outputs,
&compilation_result->resource_updates);
}
Status CompileMlirToXlaHlo(
mlir::ModuleOp module_op, llvm::ArrayRef<TensorOrResourceShape> arg_shapes,
llvm::StringRef device_type, bool use_tuple_args, bool analyse_graph,
bool use_return_tuple, bool use_resource_updates_for_aliases,
XlaHelpers::ShapeRepresentationFn shape_representation_fn,
XlaCompilationResult* compilation_result,
llvm::MutableArrayRef<std::unique_ptr<mlir::Pass>>
custom_legalization_passes) {
if (analyse_graph &&
GetMlirBridge2ndPhaseRolloutPolicy(module_op) ==
MlirBridgeRolloutPolicy::kDisabledAfterGraphAnalysis) {
return CompileToHloGraphAnalysisFailedError();
}
TF_RETURN_IF_ERROR(
CompileMlirSetup(module_op, arg_shapes, &shape_representation_fn));
// Convert MLIR module to XLA HLO proto contained in XlaComputation.
compilation_result->computation = std::make_shared<xla::XlaComputation>();
TF_RETURN_IF_ERROR(ConvertMLIRToXlaComputation(
module_op, device_type, compilation_result->computation.get(),
use_tuple_args, analyse_graph, use_return_tuple, shape_representation_fn,
custom_legalization_passes));
TF_RETURN_IF_ERROR(PopulateCollectiveInfo(module_op, compilation_result));
return PopulateResultIOInfo(module_op, arg_shapes, use_tuple_args,
use_resource_updates_for_aliases,
shape_representation_fn, compilation_result);
}
Status CompileSerializedMlirToXlaHlo(
llvm::StringRef mlir_module_string, llvm::ArrayRef<TensorShape> arg_shapes,
llvm::StringRef device_type, bool use_tuple_args, bool analyse_graph,
const XlaHelpers::ShapeRepresentationFn shape_representation_fn,
XlaCompilationResult* compilation_result,
llvm::MutableArrayRef<std::unique_ptr<mlir::Pass>>
custom_legalization_passes) {
mlir::DialectRegistry mlir_registry;
RegisterDialects(mlir_registry);
mlir::MLIRContext mlir_context(mlir_registry);
mlir::OwningOpRef<mlir::ModuleOp> mlir_module;
TF_RETURN_IF_ERROR(
DeserializeMlirModule(mlir_module_string, &mlir_context, &mlir_module));
llvm::SmallVector<TensorOrResourceShape, 4> tensor_or_resource_shapes;
tensor_or_resource_shapes.reserve(arg_shapes.size());
for (const auto& arg_shape : arg_shapes)
tensor_or_resource_shapes.push_back({arg_shape});
return CompileMlirToXlaHlo(
mlir_module.get(), tensor_or_resource_shapes, device_type, use_tuple_args,
analyse_graph, /*use_return_tuple=*/true,
/*use_resource_updates_for_aliases=*/false, shape_representation_fn,
compilation_result, custom_legalization_passes);
}
// Rewrites the given module with specified args. For each of the constant args,
// it gets inlined in the "main' function and the corresponding argument is
// removed from the signature. For resource args, their subtypes are populated.
// Returns the original indices for the other arguments on success.
static StatusOr<std::vector<int>> RewriteWithArgs(
mlir::ModuleOp module_op, llvm::ArrayRef<XlaArgument> args) {
mlir::FuncOp main_fn = module_op.lookupSymbol<mlir::FuncOp>("main");
std::vector<int> params;
bool has_resource_args = false;
auto builder = mlir::OpBuilder(main_fn.getBody());
std::vector<int> args_to_erase;
for (int idx = 0; idx < args.size(); idx++) {
const XlaArgument& xla_arg = args[idx];
mlir::BlockArgument mlir_arg = main_fn.getArgument(idx);
if (xla_arg.kind == XlaArgument::kResource) {
mlir::Type element_type;
if (xla_arg.type == DT_INVALID) {
return errors::Unimplemented(absl::StrCat(
"Argument ", idx,
" is an uninitialized resource variable which is currently"
" unsupported in the MLIR-based TPU bridge"));
}
TF_RETURN_IF_ERROR(ConvertDataType(xla_arg.type, builder, &element_type));
TF_ASSIGN_OR_RETURN(TensorShape arg_shape,
GetTensorShapeFromXlaArgument(xla_arg));
auto resource_shape = arg_shape.dim_sizes();
llvm::SmallVector<int64_t, 4> resource_subtype_shape(
resource_shape.begin(), resource_shape.end());
auto resource_subtype =
mlir::RankedTensorType::get(resource_subtype_shape, element_type);
auto resource_type =
mlir::TF::ResourceType::get({resource_subtype}, builder.getContext());
auto tensor_type = mlir_arg.getType().cast<mlir::TensorType>();
if (tensor_type.hasRank()) {
mlir_arg.setType(
mlir::RankedTensorType::get(tensor_type.getShape(), resource_type));
} else {
mlir_arg.setType(mlir::UnrankedTensorType::get(resource_type));
}
has_resource_args = true;
}
if (xla_arg.kind != XlaArgument::kConstant) {
params.push_back(idx);
continue;
}
TF_ASSIGN_OR_RETURN(auto value_attr,
ConvertTensor(xla_arg.constant_value, &builder));
// TODO(hinsu): Use the actual location of the constant.
auto constant = builder.create<mlir::TF::ConstOp>(
mlir::UnknownLoc::get(module_op.getContext()), value_attr);
mlir_arg.replaceAllUsesWith(constant);
args_to_erase.push_back(idx);
}
if (has_resource_args) {
llvm::SmallVector<mlir::Type, 4> updated_argument_types;
updated_argument_types.reserve(main_fn.getNumArguments());
for (mlir::BlockArgument& arg : main_fn.getArguments())
updated_argument_types.push_back(arg.getType());
main_fn.setType(
mlir::FunctionType::get(main_fn.getContext(), updated_argument_types,
main_fn.getFunctionType().getResults()));
}
for (int idx : llvm::reverse(args_to_erase)) main_fn.eraseArgument(idx);
return params;
}
Status CompileGraphSetup(
mlir::ModuleOp module_op, llvm::ArrayRef<XlaArgument> args,
std::vector<int>* remaining_params,
llvm::SmallVector<TensorOrResourceShape, 4>& arg_shapes) {
TF_ASSIGN_OR_RETURN(*remaining_params, RewriteWithArgs(module_op, args));
arg_shapes.reserve(remaining_params->size());
for (unsigned idx : *remaining_params) {
const auto& arg = args[idx];
TF_ASSIGN_OR_RETURN(TensorShape arg_shape,
GetTensorShapeFromXlaArgument(arg));
arg_shapes.push_back({arg_shape,
/*is_resource=*/arg.kind == XlaArgument::kResource});
}
mlir::PassManager pm(module_op.getContext());
applyTensorflowAndCLOptions(pm);
mlir::TF::StandardPipelineOptions tf_options;
mlir::TF::CreateTFStandardPipeline(pm, tf_options);
if (VLOG_IS_ON(1))
tensorflow::DumpMlirOpToFile("compile_graph_setup_before", module_op);
if (VLOG_IS_ON(2)) {
// Print the whole module after each pass which requires disabling
// multi-threading as well.
module_op.getContext()->disableMultithreading();
pm.enableIRPrinting(std::make_unique<tensorflow::BridgeLoggerConfig>(
/*print_module_scope=*/true));
}
mlir::StatusScopedDiagnosticHandler diag_handler(module_op.getContext());
if (failed(pm.run(module_op))) return diag_handler.ConsumeStatus();
if (VLOG_IS_ON(1))
tensorflow::DumpMlirOpToFile("compile_graph_setup_after", module_op);
return Status::OK();
}
Status BuildHloFromModule(mlir::ModuleOp module_op, xla::XlaBuilder& builder,
llvm::ArrayRef<xla::XlaOp> xla_params,
std::vector<xla::XlaOp>& returns,
llvm::ArrayRef<XlaArgument> args,
llvm::StringRef device_type,
llvm::MutableArrayRef<std::unique_ptr<mlir::Pass>>
custom_legalization_passes) {
std::vector<int> remaining_params;
llvm::SmallVector<TensorOrResourceShape, 4> arg_shapes;
TF_RETURN_IF_ERROR(
CompileGraphSetup(module_op, args, &remaining_params, arg_shapes));
// Passing down only remaining (non-constant) xla_params.
llvm::SmallVector<xla::XlaOp, 2> remaining_xla_params;
for (auto i : remaining_params) remaining_xla_params.push_back(xla_params[i]);
return BuildHloFromTf(module_op, builder, remaining_xla_params, returns,
arg_shapes, device_type, custom_legalization_passes);
}
Status CompileGraphToXlaHlo(
mlir::ModuleOp module_op, llvm::ArrayRef<XlaArgument> args,
llvm::StringRef device_type, bool use_tuple_args, bool analyse_graph,
bool use_return_tuple,
const XlaHelpers::ShapeRepresentationFn shape_representation_fn,
XlaCompilationResult* compilation_result,
llvm::MutableArrayRef<std::unique_ptr<mlir::Pass>>
custom_legalization_passes) {
std::vector<int> remaining_params;
llvm::SmallVector<TensorOrResourceShape, 4> arg_shapes;
TF_RETURN_IF_ERROR(
CompileGraphSetup(module_op, args, &remaining_params, arg_shapes));
auto status = CompileMlirToXlaHlo(
module_op, arg_shapes, device_type, use_tuple_args, analyse_graph,
use_return_tuple,
/*use_resource_updates_for_aliases=*/true, shape_representation_fn,
compilation_result, custom_legalization_passes);
compilation_result->input_mapping = remaining_params;
return status;
}
xla::StatusOr<mlir::OwningOpRef<mlir::ModuleOp>> GraphToModule(
const Graph& graph, llvm::ArrayRef<std::string> control_rets,
const FunctionLibraryDefinition& flib_def, const GraphDebugInfo& debug_info,
mlir::MLIRContext* context) {
mlir::DialectRegistry registry;
RegisterDialects(registry);
context->appendDialectRegistry(registry);
GraphImportConfig config;
config.graph_as_function = true;
config.control_outputs = control_rets;
// Disable shape inference during import as some TensorFlow op fails during
// shape inference with dynamic shaped operands. This in turn causes the
// import to fail. Shape inference during import is going to be removed and
// the shape inference pass is run early in the pass pipeline, shape inference
// during import is not necessary.
config.enable_shape_inference = false;
return ConvertGraphToMlir(graph, debug_info, flib_def, config, context);
}
Status BuildHloFromGraph(
const Graph& graph, xla::XlaBuilder& builder,
mlir::MLIRContext& mlir_context, llvm::ArrayRef<xla::XlaOp> xla_params,
std::vector<xla::XlaOp>& returns, llvm::ArrayRef<XlaArgument> args,
llvm::ArrayRef<std::string> control_rets, llvm::StringRef device_type,
const FunctionLibraryDefinition& flib_def, const GraphDebugInfo& debug_info,
llvm::MutableArrayRef<std::unique_ptr<mlir::Pass>>
custom_legalization_passes) {
TF_ASSIGN_OR_RETURN(
mlir::OwningOpRef<mlir::ModuleOp> module,
GraphToModule(graph, control_rets, flib_def, debug_info, &mlir_context));
return BuildHloFromModule(module.get(), builder, xla_params, returns, args,
device_type, custom_legalization_passes);
}
Status CompileGraphToXlaHlo(
const Graph& graph, llvm::ArrayRef<XlaArgument> args,
llvm::ArrayRef<std::string> control_rets, llvm::StringRef device_type,
bool use_tuple_args, bool analyse_graph,
const FunctionLibraryDefinition& flib_def, const GraphDebugInfo& debug_info,
const XlaHelpers::ShapeRepresentationFn shape_representation_fn,
XlaCompilationResult* compilation_result,
llvm::MutableArrayRef<std::unique_ptr<mlir::Pass>>
custom_legalization_passes) {
mlir::MLIRContext context;
TF_ASSIGN_OR_RETURN(
mlir::OwningOpRef<mlir::ModuleOp> module,
GraphToModule(graph, control_rets, flib_def, debug_info, &context));
return CompileGraphToXlaHlo(
module.get(), args, device_type, use_tuple_args, analyse_graph,
/*use_return_tuple=*/true, shape_representation_fn, compilation_result,
custom_legalization_passes);
}
void RegisterConvertMlirToXlaHloPipelineWithDefaults() {
static mlir::PassPipelineRegistration<> pipeline(
"tf-to-hlo-pipeline",
"Convert TF dialect to HLO dialect (used for compilation in bridge).",
[](mlir::OpPassManager& pm) {
tensorflow::CreateConvertMlirToXlaHloPipeline(
pm, /*device_type=*/"XLA_CPU_JIT", /*prefer_tf2xla=*/false,
/*custom_legalization_passes=*/{});
});
}
} // namespace tensorflow
| [
"gardener@tensorflow.org"
] | gardener@tensorflow.org |
c6b614d366168c056908dd9575d6caa2828d1c33 | 91a882547e393d4c4946a6c2c99186b5f72122dd | /Source/XPSP1/NT/inetsrv/iis/svcs/staxcore/fcache2/utestexe/fcexe.cpp | 04bce3d0d8965e8dc78b16df0cf2590f58a1d2b3 | [] | no_license | IAmAnubhavSaini/cryptoAlgorithm-nt5src | 94f9b46f101b983954ac6e453d0cf8d02aa76fc7 | d9e1cdeec650b9d6d3ce63f9f0abe50dabfaf9e2 | refs/heads/master | 2023-09-02T10:14:14.795579 | 2021-11-20T13:47:06 | 2021-11-20T13:47:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,965 | cpp |
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include "dbgtrace.h"
#include "testdll.h"
//
// Number of files to do initial kick off
//
DWORD g_cCreatePerSecond = 50 ;
//
// Number of times we read existing files per creation of
// a new file !
//
DWORD g_cFindPerSecond = 2 ;
//
// Number of finds done in parallel !
//
DWORD g_cParallelFinds = 10 ;
//
// The directory where we store all of our test files !
//
char g_szDir[MAX_PATH] ;
//
// The filesystem DLL to load !
//
char g_szFileSystemDll [MAX_PATH];
//
// How long to let the Test DLL live !
//
DWORD g_cLifetime = 5 ; // default 10 minutes !
#define INI_KEY_CREATEPERSEC "CreatePerSec"
#define INI_KEY_FINDPERSEC "FindPerSec"
#define INI_KEY_PARALLEL "Parallel"
#define INI_KEY_LIFETIME "Lifetime"
#define INI_KEY_DIR "Dir"
#define INI_KEY_FILE_SYSTEM "FileSystem"
char g_szDefaultSectionName[] = "fcexe";
char *g_szSectionName = g_szDefaultSectionName;
void usage(void) {
/*++
Routine Description :
Print Usage info to command line user !
Arguments :
None.
Return Value :
None.
--*/
printf("usage: c2test.exe [<ini file>] [<ini section name>]\n"
" INI file keys (default section [%s]):\n"
" %s Test Directory - contains files created during test !\n"
" %s Files Created per second Default - %d\n"
" %s Files found per seccond per session Default %d\n"
" %s Parallel Find Sessions - %d\n"
" %s Number of minutes per test - %d\n"
" %s FileSystem DLL to use !\n",
g_szDefaultSectionName,
INI_KEY_DIR,
INI_KEY_CREATEPERSEC,
g_cCreatePerSecond,
INI_KEY_FINDPERSEC,
g_cFindPerSecond,
INI_KEY_PARALLEL,
g_cParallelFinds,
INI_KEY_LIFETIME,
g_cLifetime,
INI_KEY_FILE_SYSTEM
) ;
exit(1);
}
int GetINIDword(
char *szINIFile,
char *szKey,
DWORD dwDefault
) {
/*++
Routine Description :
Helper function which retrieves values from .ini file !
Arguments :
szINIFile - name of the ini file
szKey - name of the key
dwDefault - default value for the parameter
Return Value :
The value retrieved from the .ini file or the default !
--*/
char szBuf[MAX_PATH];
GetPrivateProfileString(g_szSectionName,
szKey,
"default",
szBuf,
MAX_PATH,
szINIFile);
if (strcmp(szBuf, "default") == 0) {
return dwDefault;
} else {
return atoi(szBuf);
}
}
void parsecommandline(
int argc,
char **argv
) {
/*++
Routine Description :
Get the name of the .ini file and
setup our test run !
Arguments :
Command line parameters
Return Value :
None - will exit() if the user has not
properly configured the test !
--*/
if (argc == 0 ) usage();
if (strcmp(argv[0], "/help") == 0) usage(); // show help
char *szINIFile = argv[0];
if (argc == 2) char *g_szSectionName = argv[1];
GetPrivateProfileString( g_szSectionName,
INI_KEY_DIR,
"",
g_szDir,
sizeof( g_szDir ),
szINIFile
) ;
g_cCreatePerSecond = GetINIDword(
szINIFile,
INI_KEY_CREATEPERSEC,
g_cCreatePerSecond
) ;
g_cFindPerSecond = GetINIDword(
szINIFile,
INI_KEY_FINDPERSEC,
g_cFindPerSecond
) ;
g_cParallelFinds = GetINIDword(
szINIFile,
INI_KEY_PARALLEL,
g_cParallelFinds
) ;
g_cLifetime = GetINIDword(
szINIFile,
INI_KEY_LIFETIME,
g_cLifetime
) ;
GetPrivateProfileString( g_szSectionName,
INI_KEY_FILE_SYSTEM,
"",
g_szFileSystemDll,
sizeof( g_szFileSystemDll ),
szINIFile
) ;
if( g_szDir[0] =='\0' || g_szFileSystemDll[0] == '\0' ) {
usage() ;
}
}
int __cdecl
main( int argc, char** argv ) {
parsecommandline( --argc, ++argv ) ;
Sleep( 10 * 100 ) ;
for( int i=0; i<10000; i++ ) {
HINSTANCE hLibrary = LoadLibrary( g_szFileSystemDll ) ;
typedef BOOL (*PFNSTART)( DWORD, DWORD, DWORD, char * ) ;
PFNSTART pStart = (PFNSTART)GetProcAddress( hLibrary, "_StartTest@16" ) ;
typedef void (*PFNSTOP)() ;
PFNSTOP pStop = (PFNSTOP)GetProcAddress( hLibrary, "_StopTest@0" ) ;
if ( pStart( g_cCreatePerSecond,
g_cFindPerSecond,
g_cParallelFinds,
g_szDir
) ) {
Sleep( g_cLifetime * 60 * 1000 ) ;
pStop() ;
Sleep( 5 * 1000 ) ;
}
FreeLibrary( hLibrary ) ;
Sleep( 5 * 1000 ) ;
//
// Clean up the mess we made before continuing !
//
char szBuff[MAX_PATH*2] ;
wsprintf( szBuff, "%s\\*", g_szDir ) ;
WIN32_FIND_DATA finddata ;
HANDLE hFind = FindFirstFile( szBuff, &finddata ) ;
if( hFind != INVALID_HANDLE_VALUE ) {
BOOL f = FALSE ;
do {
if( (finddata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0 ) {
wsprintf( szBuff, "%s\\%s", g_szDir, finddata.cFileName ) ;
_VERIFY( DeleteFile( szBuff ) ) ;
}
f = FindNextFile( hFind, &finddata ) ;
} while(f) ;
FindClose( hFind ) ;
}
}
return 0 ;
}
| [
"support@cryptoalgo.cf"
] | support@cryptoalgo.cf |
38a7426c3e22539a6d774ca32433d9219ad38f76 | ef35fd19145c2df32466093ff51edc343e6b09a4 | /src/Model/Actions/DropWeaponAction.cpp | baf0adcb63775d52583521e2d213cb180d815042 | [] | no_license | SockPuppet8/Alienhack | ed5d8c4bb9031f150532fdd2c7ba7912c97712a1 | b843d42641dae00eb87c283702e56429ea1a7ad2 | refs/heads/master | 2020-04-02T19:19:52.934817 | 2018-11-02T14:22:29 | 2018-11-02T14:22:29 | 154,730,646 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 869 | cpp | #include "DropWeaponAction.hpp"
#include "../AHGameModel.hpp"
//#include "../IGameEvents.hpp"
namespace AlienHack
{
using namespace RL_shared;
using namespace boost;
void DropWeaponAction::advance( GameTimeCoordinate t, AGameModel& in_model )
{
AHGameModel& model( dynamic_cast<AHGameModel&>(in_model) );
shared_ptr<IGameEvents> game_events( model.gameEventsObserver() );
GameTimeCoordinate old_time( m_time_remaining );
m_time_remaining = (std::max)((GameTimeCoordinate)0, m_time_remaining-t);
RL_shared::GameTimeCoordinate half_time( m_time_full / 2 );
if ((old_time >= half_time) && (m_time_remaining < half_time))
{
shared_ptr< PlayerCharacter > player( m_player.lock() );
if (player)
{
player->dropWeapon(model, m_slot);
}
}
}
boost::shared_ptr< RL_shared::Actor > DropWeaponAction::actor(void) const
{
return m_player.lock();
}
}
| [
"sckpuppet8@googlemail.com"
] | sckpuppet8@googlemail.com |
49ef5de20d0678cf63c24e62013daa75b0da3a64 | 8dfc324dcea5fb8bdb304c307935338122531f7f | /solution/Binary_search/2805.cpp | 3dcf405d0a3d23773243608290092acb90c3672f | [] | no_license | inpyeong/baekjoon | 407444f8f5bdf1e9df94d71f84455ee37dd00dc1 | 55465c62c5eb64305cb106dd7d7767d452d72c31 | refs/heads/master | 2022-12-05T18:53:05.000807 | 2020-08-25T16:15:10 | 2020-08-25T16:15:10 | 263,879,092 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 674 | cpp | //#include <cstdio>
//int a[1000000];
//int n, m;
//
//bool check(long long x) {
// long long cnt = 0;
// for (int i = 0; i < n; i++) {
// if (a[i] > x) {
// cnt += (a[i] - x);
// }
// }
// return cnt >= m;
//}
//
//int main() {
// scanf("%d %d", &n, &m);
// int max = 0;
// for (int i = 0; i < n; i++) {
// scanf("%d", &a[i]);
// if (max < a[i]) {
// max = a[i];
// }
// }
// long long ans = 0;
// long long l = 1;
// long long r = max;
// while (l <= r) {
// long long mid = (l + r) / 2;
// if (check(mid)) {
// if (ans < mid) {
// ans = mid;
// }
// l = mid + 1;
// }
// else {
// r = mid - 1;
// }
// }
// printf("%lld\n", ans);
// return 0;
//} | [
"jinipyung@gmail.com"
] | jinipyung@gmail.com |
ae348961a20249527424340d9b21e0a4e3a19dad | b77d1308d6dc47bc1b6640c75afdb6021f169051 | /ContinuesSquenceWithSum/ContinuesSquenceWithSum.cpp | 1fee29fbfd3ce401fc5eaf5020d0cd403f13cb9e | [] | no_license | fredzs/Coding_Interview | fb037c31cc45f914ec6a004d2c51fd21403150cc | 5c346c4596cdb070197f2143262a58a8e95e7ea0 | refs/heads/master | 2021-01-20T20:56:52.479670 | 2015-05-10T09:57:02 | 2015-05-10T09:57:02 | 35,365,544 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,313 | cpp | // ContinuesSquenceWithSum.cpp : Defines the entry point for the console application.
//
// 《剑指Offer——名企面试官精讲典型编程题》代码
// 著作权所有者：何海涛
#include "stdafx.h"
void PrintContinuousSequence(int small, int big);
void FindContinuousSequence(int sum)
{
if(sum < 3) return;
int small = 1;
int big = 2;
int middle = (1 + sum) / 2;
int curSum = small + big;
while(small < middle) {
if(curSum == sum)
PrintContinuousSequence(small, big);
while(curSum > sum && small < middle) {
curSum -= small;
small ++;
if(curSum == sum)
PrintContinuousSequence(small, big);
}
big ++;
curSum += big;
}
}
void PrintContinuousSequence(int small, int big)
{
for(int i = small; i <= big; ++ i)
printf("%d ", i);
printf("\n");
}
// ====================测试代码====================
void Test(char* testName, int sum)
{
if(testName != NULL)
printf("%s for %d begins: \n", testName, sum);
FindContinuousSequence(sum);
}
int _tmain(int argc, _TCHAR* argv[])
{
Test("test1", 1);
Test("test2", 3);
Test("test3", 4);
Test("test4", 9);
Test("test5", 15);
Test("test6", 100);
return 0;
}
| [
"fred_zs@163.com"
] | fred_zs@163.com |
c5ec76d4c824e943375fd42a4f4fb4089392bd92 | bb11425396c4c429b80f28fc3b60bbb41781e7a8 | /tutorials/Vertex.h | 3ddde37d799c937cccf054abc96706f74a4f8be6 | [] | no_license | errorex/graphicsOpenGL | 5efacd0869097e6eeef534ec68dc544976dd03e2 | 7bf5cf79ccd9c69b49ad078a1802acdcb17dd918 | refs/heads/master | 2021-01-01T18:20:00.094891 | 2017-10-12T22:14:25 | 2017-10-12T22:14:25 | 98,307,844 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 125 | h | #pragma once
#include <glm/glm.hpp>
using namespace glm;
class Vertex {
public:
glm::vec3 position;
glm::vec3 color;
};
| [
"errorex@gmail.com"
] | errorex@gmail.com |
a94b30601e82dc7386615d80cbae6f6c2655ec5e | 705dd8f1a74422569471bb7f5684479055ab1e53 | /flexc++/ranges/operatorinsert.cc | 339dd87e62d344f18b1d2e3b0ad694744d1f1e26 | [] | no_license | jeanpaul/flexcpp-old | b93a933e607a14db45f54b8fddd9cabcbe6d018f | 788d28b2e6acaaa3929886df3450a9a3bb2da29b | refs/heads/master | 2020-04-11T09:10:06.694570 | 2015-09-07T17:45:39 | 2015-09-07T17:45:39 | 156,622 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 900 | cc | #include "ranges.ih"
ostream &operator<<(ostream &out, Ranges const &rangesObj)
{
out << "Nsubsets: " << rangesObj.d_subsets << '\n';
size_t *ranges = rangesObj.d_ranges;
size_t *begin = ranges;
size_t *end = ranges + rangesObj.d_size;
size_t range = 0;
while (begin != end)
{
size_t *last = find_if(begin, end,
bind2nd(not_equal_to<size_t>(), *begin));
out << setw(2) << range++ << ": ";
Ranges::outChar(out, begin - ranges);
if (begin != last - 1)
{
out << " - ";
Ranges::outChar(out, last - ranges - 1);
}
out << '\n';
begin = last;
}
if (size_t bol = rangesObj.rangeOfBOL())
out << "BOL: " << bol << '\n';
if (size_t eof = rangesObj.rangeOfEOF())
out << "EOF: " << eof << '\n';
return out;
}
| [
"f.b.brokken@rug.nl"
] | f.b.brokken@rug.nl |
d036403647d72c9284a5b61581f1d446c9abf36b | d2b44ef264d38abe27ec31f871bd9aa7ed27828c | /devel/include/ardrone_autonomy/navdata_video_stream.h | f5f841e2381763744c7272b9be7575c05ca2f857 | [] | no_license | pavankumarbn/DroneGUIROS | 7c7ce7b904a9d75dd239a3570e01f3129faa085c | 745320d73035bc50ac4fea2699e22586e10be800 | refs/heads/master | 2022-03-20T20:20:22.887073 | 2019-11-27T06:49:18 | 2019-11-27T06:49:18 | 107,343,328 | 5 | 6 | null | null | null | null | UTF-8 | C++ | false | false | 10,433 | h | // Generated by gencpp from file ardrone_autonomy/navdata_video_stream.msg
// DO NOT EDIT!
#ifndef ARDRONE_AUTONOMY_MESSAGE_NAVDATA_VIDEO_STREAM_H
#define ARDRONE_AUTONOMY_MESSAGE_NAVDATA_VIDEO_STREAM_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 ardrone_autonomy
{
template <class ContainerAllocator>
struct navdata_video_stream_
{
typedef navdata_video_stream_<ContainerAllocator> Type;
navdata_video_stream_()
: header()
, drone_time(0.0)
, tag(0)
, size(0)
, quant(0)
, frame_size(0)
, frame_number(0)
, atcmd_ref_seq(0)
, atcmd_mean_ref_gap(0)
, atcmd_var_ref_gap(0.0)
, atcmd_ref_quality(0)
, desired_bitrate(0)
, data2(0)
, data3(0)
, data4(0)
, data5(0)
, fifo_queue_level(0) {
}
navdata_video_stream_(const ContainerAllocator& _alloc)
: header(_alloc)
, drone_time(0.0)
, tag(0)
, size(0)
, quant(0)
, frame_size(0)
, frame_number(0)
, atcmd_ref_seq(0)
, atcmd_mean_ref_gap(0)
, atcmd_var_ref_gap(0.0)
, atcmd_ref_quality(0)
, desired_bitrate(0)
, data2(0)
, data3(0)
, data4(0)
, data5(0)
, fifo_queue_level(0) {
(void)_alloc;
}
typedef ::std_msgs::Header_<ContainerAllocator> _header_type;
_header_type header;
typedef double _drone_time_type;
_drone_time_type drone_time;
typedef uint16_t _tag_type;
_tag_type tag;
typedef uint16_t _size_type;
_size_type size;
typedef uint8_t _quant_type;
_quant_type quant;
typedef uint32_t _frame_size_type;
_frame_size_type frame_size;
typedef uint32_t _frame_number_type;
_frame_number_type frame_number;
typedef uint32_t _atcmd_ref_seq_type;
_atcmd_ref_seq_type atcmd_ref_seq;
typedef uint32_t _atcmd_mean_ref_gap_type;
_atcmd_mean_ref_gap_type atcmd_mean_ref_gap;
typedef float _atcmd_var_ref_gap_type;
_atcmd_var_ref_gap_type atcmd_var_ref_gap;
typedef uint32_t _atcmd_ref_quality_type;
_atcmd_ref_quality_type atcmd_ref_quality;
typedef uint32_t _desired_bitrate_type;
_desired_bitrate_type desired_bitrate;
typedef int32_t _data2_type;
_data2_type data2;
typedef int32_t _data3_type;
_data3_type data3;
typedef int32_t _data4_type;
_data4_type data4;
typedef int32_t _data5_type;
_data5_type data5;
typedef uint32_t _fifo_queue_level_type;
_fifo_queue_level_type fifo_queue_level;
typedef boost::shared_ptr< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> const> ConstPtr;
}; // struct navdata_video_stream_
typedef ::ardrone_autonomy::navdata_video_stream_<std::allocator<void> > navdata_video_stream;
typedef boost::shared_ptr< ::ardrone_autonomy::navdata_video_stream > navdata_video_streamPtr;
typedef boost::shared_ptr< ::ardrone_autonomy::navdata_video_stream const> navdata_video_streamConstPtr;
// constants requiring out of line definition
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> >::stream(s, "", v);
return s;
}
} // namespace ardrone_autonomy
namespace ros
{
namespace message_traits
{
// BOOLTRAITS {'IsFixedSize': False, 'IsMessage': True, 'HasHeader': True}
// {'std_msgs': ['/opt/ros/indigo/share/std_msgs/cmake/../msg'], 'ardrone_autonomy': ['/home/velab/catkin_ws1/src/ardrone_autonomy/msg'], 'geometry_msgs': ['/opt/ros/indigo/share/geometry_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< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> >
: FalseType
{ };
template <class ContainerAllocator>
struct IsFixedSize< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> const>
: FalseType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct IsMessage< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> const>
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> >
: TrueType
{ };
template <class ContainerAllocator>
struct HasHeader< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> const>
: TrueType
{ };
template<class ContainerAllocator>
struct MD5Sum< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> >
{
static const char* value()
{
return "caf560356d435eb563ce5b9e8278da00";
}
static const char* value(const ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator>&) { return value(); }
static const uint64_t static_value1 = 0xcaf560356d435eb5ULL;
static const uint64_t static_value2 = 0x63ce5b9e8278da00ULL;
};
template<class ContainerAllocator>
struct DataType< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> >
{
static const char* value()
{
return "ardrone_autonomy/navdata_video_stream";
}
static const char* value(const ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator>&) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> >
{
static const char* value()
{
return "Header header\n\
float64 drone_time\n\
uint16 tag\n\
uint16 size\n\
uint8 quant\n\
uint32 frame_size\n\
uint32 frame_number\n\
uint32 atcmd_ref_seq\n\
uint32 atcmd_mean_ref_gap\n\
float32 atcmd_var_ref_gap\n\
uint32 atcmd_ref_quality\n\
uint32 desired_bitrate\n\
int32 data2\n\
int32 data3\n\
int32 data4\n\
int32 data5\n\
uint32 fifo_queue_level\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 ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator>&) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.drone_time);
stream.next(m.tag);
stream.next(m.size);
stream.next(m.quant);
stream.next(m.frame_size);
stream.next(m.frame_number);
stream.next(m.atcmd_ref_seq);
stream.next(m.atcmd_mean_ref_gap);
stream.next(m.atcmd_var_ref_gap);
stream.next(m.atcmd_ref_quality);
stream.next(m.desired_bitrate);
stream.next(m.data2);
stream.next(m.data3);
stream.next(m.data4);
stream.next(m.data5);
stream.next(m.fifo_queue_level);
}
ROS_DECLARE_ALLINONE_SERIALIZER
}; // struct navdata_video_stream_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::ardrone_autonomy::navdata_video_stream_<ContainerAllocator>& v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "drone_time: ";
Printer<double>::stream(s, indent + " ", v.drone_time);
s << indent << "tag: ";
Printer<uint16_t>::stream(s, indent + " ", v.tag);
s << indent << "size: ";
Printer<uint16_t>::stream(s, indent + " ", v.size);
s << indent << "quant: ";
Printer<uint8_t>::stream(s, indent + " ", v.quant);
s << indent << "frame_size: ";
Printer<uint32_t>::stream(s, indent + " ", v.frame_size);
s << indent << "frame_number: ";
Printer<uint32_t>::stream(s, indent + " ", v.frame_number);
s << indent << "atcmd_ref_seq: ";
Printer<uint32_t>::stream(s, indent + " ", v.atcmd_ref_seq);
s << indent << "atcmd_mean_ref_gap: ";
Printer<uint32_t>::stream(s, indent + " ", v.atcmd_mean_ref_gap);
s << indent << "atcmd_var_ref_gap: ";
Printer<float>::stream(s, indent + " ", v.atcmd_var_ref_gap);
s << indent << "atcmd_ref_quality: ";
Printer<uint32_t>::stream(s, indent + " ", v.atcmd_ref_quality);
s << indent << "desired_bitrate: ";
Printer<uint32_t>::stream(s, indent + " ", v.desired_bitrate);
s << indent << "data2: ";
Printer<int32_t>::stream(s, indent + " ", v.data2);
s << indent << "data3: ";
Printer<int32_t>::stream(s, indent + " ", v.data3);
s << indent << "data4: ";
Printer<int32_t>::stream(s, indent + " ", v.data4);
s << indent << "data5: ";
Printer<int32_t>::stream(s, indent + " ", v.data5);
s << indent << "fifo_queue_level: ";
Printer<uint32_t>::stream(s, indent + " ", v.fifo_queue_level);
}
};
} // namespace message_operations
} // namespace ros
#endif // ARDRONE_AUTONOMY_MESSAGE_NAVDATA_VIDEO_STREAM_H
| [
"pavanbn8@gmail.com"
] | pavanbn8@gmail.com |
59886c67a0e5c95d6a5ead51f72e8dc91a7f9822 | 288ac0ee3af255c4b2beebc8db7a86f03895b0e2 | /7.代码练习/1.noip入门组/4.数组/150矩阵旋转.cpp | a40f155f16ce941efea184c48c0f0ac5660eb3d4 | [] | no_license | TheIslland/Code_learn | a2895b1e0943f9f00289b44a8278e5fb488de4a3 | ca7c67f6715e16084b0c57e804b838e8dace4a50 | refs/heads/master | 2022-11-27T08:11:57.892536 | 2020-08-09T13:16:49 | 2020-08-09T13:16:49 | 278,763,338 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 778 | cpp | /*************************************************************************
> File Name: 150矩阵旋转.cpp
> Author: TheIslland
> Mail: voidland@163.com, 861436930@qq.com
> Created Time: Sun Nov 3 22:16:53 2019
************************************************************************/
#include <iostream>
using namespace std;
int main() {
int matrix[205][205] = {0};
int ans[205][205] = {0};
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> matrix[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans[j][n - i - 1] = matrix[i][j];
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cout << ans[i][j] << (j < n - 1 ? " " : "");
}
cout << endl;
}
return 0;
}
| [
"86143690@qq.com"
] | 86143690@qq.com |
1364098ab866cbf7df3ac3b6c7fe792b1260391d | 06094d91c69401972f8e5cc5625a5f4336e9e958 | /node_modules/nodegit/src/filter_source.cc | 9d854a2de2a48bfe036b745cd82ad9f4a806e255 | [
"MIT",
"LicenseRef-scancode-generic-cla"
] | permissive | sanchit11/fconverternew | baab89d2e1740e636cbaeb89cfaaf233e2783b19 | 50a3a3d12023009d750957188ff9edc3fdd4a291 | refs/heads/master | 2023-03-26T02:52:24.217645 | 2021-03-26T05:42:09 | 2021-03-26T05:42:09 | 351,674,050 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,744 | cc | // This is a generated file, modify: generate/templates/templates/class_content.cc
#include <nan.h>
#include <string.h>
extern "C" {
#include <git2.h>
#include <git2/sys/filter.h>
}
#include "../include/nodegit.h"
#include "../include/lock_master.h"
#include "../include/functions/copy.h"
#include "../include/filter_source.h"
#include "nodegit_wrapper.cc"
#include "../include/async_libgit2_queue_worker.h"
#include "../include/repository.h"
#include "../include/oid.h"
#include <iostream>
using namespace std;
using namespace v8;
using namespace node;
GitFilterSource::~GitFilterSource() {
// this will cause an error if you have a non-self-freeing object that also needs
// to save values. Since the object that will eventually free the object has no
// way of knowing to free these values.
}
void GitFilterSource::InitializeComponent(v8::Local<v8::Object> target) {
Nan::HandleScope scope;
v8::Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(JSNewFunction);
tpl->InstanceTemplate()->SetInternalFieldCount(1);
tpl->SetClassName(Nan::New("FilterSource").ToLocalChecked());
Nan::SetPrototypeMethod(tpl, "repo", Repo);
Nan::SetPrototypeMethod(tpl, "path", Path);
Nan::SetPrototypeMethod(tpl, "filemode", Filemode);
Nan::SetPrototypeMethod(tpl, "id", Id);
Nan::SetPrototypeMethod(tpl, "mode", Mode);
Nan::SetPrototypeMethod(tpl, "flags", Flags);
InitializeTemplate(tpl);
v8::Local<Function> _constructor_template = Nan::GetFunction(tpl).ToLocalChecked();
constructor_template.Reset(_constructor_template);
Nan::Set(target, Nan::New("FilterSource").ToLocalChecked(), _constructor_template);
}
/*
* @return Repository result */
NAN_METHOD(GitFilterSource::Repo) {
Nan::EscapableHandleScope scope;
giterr_clear();
{ // lock master scope start
LockMaster lockMaster(
/*asyncAction: */false
,
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
git_repository * result = git_filter_source_repo(
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
// null checks on pointers
if (!result) {
return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
}
v8::Local<v8::Value> to;
// start convert_to_v8 block
if (result != NULL) {
// GitRepository result
to = GitRepository::New(
result,
true
);
}
else {
to = Nan::Null();
}
// end convert_to_v8 block
return info.GetReturnValue().Set(scope.Escape(to));
}
}
/*
* @return String result */
NAN_METHOD(GitFilterSource::Path) {
Nan::EscapableHandleScope scope;
giterr_clear();
{ // lock master scope start
LockMaster lockMaster(
/*asyncAction: */false
,
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
const char * result = git_filter_source_path(
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
// null checks on pointers
if (!result) {
return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
}
v8::Local<v8::Value> to;
// start convert_to_v8 block
if (result){
to = Nan::New<v8::String>(result).ToLocalChecked();
}
else {
to = Nan::Null();
}
// end convert_to_v8 block
return info.GetReturnValue().Set(scope.Escape(to));
}
}
/*
* @return Number result */
NAN_METHOD(GitFilterSource::Filemode) {
Nan::EscapableHandleScope scope;
giterr_clear();
{ // lock master scope start
LockMaster lockMaster(
/*asyncAction: */false
,
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
uint16_t result = git_filter_source_filemode(
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
v8::Local<v8::Value> to;
// start convert_to_v8 block
to = Nan::New<Number>( result);
// end convert_to_v8 block
return info.GetReturnValue().Set(scope.Escape(to));
}
}
/*
* @return Oid result */
NAN_METHOD(GitFilterSource::Id) {
Nan::EscapableHandleScope scope;
giterr_clear();
{ // lock master scope start
LockMaster lockMaster(
/*asyncAction: */false
,
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
const git_oid * result = git_filter_source_id(
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
// null checks on pointers
if (!result) {
return info.GetReturnValue().Set(scope.Escape(Nan::Undefined()));
}
v8::Local<v8::Value> to;
// start convert_to_v8 block
if (result != NULL) {
v8::Local<v8::Array> owners = Nan::New<Array>(0);
Nan::Set(owners, owners->Length(), info.This());
// GitOid result
to = GitOid::New(
result,
true
, owners
);
}
else {
to = Nan::Null();
}
// end convert_to_v8 block
return info.GetReturnValue().Set(scope.Escape(to));
}
}
/*
* @return Number result */
NAN_METHOD(GitFilterSource::Mode) {
Nan::EscapableHandleScope scope;
giterr_clear();
{ // lock master scope start
LockMaster lockMaster(
/*asyncAction: */false
,
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
git_filter_mode_t result = git_filter_source_mode(
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
v8::Local<v8::Value> to;
// start convert_to_v8 block
to = Nan::New<Number>( result);
// end convert_to_v8 block
return info.GetReturnValue().Set(scope.Escape(to));
}
}
/*
* @return Number result */
NAN_METHOD(GitFilterSource::Flags) {
Nan::EscapableHandleScope scope;
giterr_clear();
{ // lock master scope start
LockMaster lockMaster(
/*asyncAction: */false
,
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
uint32_t result = git_filter_source_flags(
Nan::ObjectWrap::Unwrap<GitFilterSource>(info.This())->GetValue()
);
v8::Local<v8::Value> to;
// start convert_to_v8 block
to = Nan::New<Number>( result);
// end convert_to_v8 block
return info.GetReturnValue().Set(scope.Escape(to));
}
}
// force base class template instantiation, to make sure we get all the
// methods, statics, etc.
template class NodeGitWrapper<GitFilterSourceTraits>;
| [
"sanchit.astekar@gmail.com"
] | sanchit.astekar@gmail.com |
273d6df27ff6867c45e723e1b8945858ba0c022d | 03f037d0f6371856ede958f0c9d02771d5402baf | /graphics/VTK-7.0.0/Common/Core/Testing/Cxx/TestArrayUniqueValueDetection.cxx | 96479c10414185178012f4ad4b883ac64a9caf4f | [
"BSD-3-Clause"
] | permissive | hlzz/dotfiles | b22dc2dc5a9086353ed6dfeee884f7f0a9ddb1eb | 0591f71230c919c827ba569099eb3b75897e163e | refs/heads/master | 2021-01-10T10:06:31.018179 | 2016-09-27T08:13:18 | 2016-09-27T08:13:18 | 55,040,954 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,529 | cxx | #include "vtkAbstractArray.h"
#include "vtkDoubleArray.h"
#include "vtkIntArray.h"
#include "vtkNew.h"
#include "vtkStringArray.h"
#include "vtkVariantArray.h"
static double testTuplesDouble[] = {
// A simple test where every component *and* the
// tuples as a whole behave discretely.
0., 0., 1.,
1., 0., 3.,
0., 2., 7.,
0., 0., 9.,
1., 0., 1.,
0., 2., 8.,
};
// Bounds on the number of unique values that should be identified.
// For larger data, the number may not be precise
// as we sample subsets of the data.
static int numUniqueDouble[] = {
2, 2,
2, 2,
5, 5,
6, 6,
};
static int testTuplesInt[] = {
/*
These next tuples repeat 16 coordinate values but are frequently not
identical in both components to other tuples. Thus the components
should have 16 discrete values reported, but the vectors as
a whole should not since there are 43 distinct tuples.
Furthermore, the array is sampled as opposed to exhastively enumerated
and so only 15 unique values are detected for component 1.
*/
16, 1,
8, 14,
10, 3,
11, 4,
2, 13,
7, 12,
6, 5,
15, 9,
15, 6,
9, 7,
11, 16,
1, 5,
2, 3,
13, 12,
4, 8,
14, 10,
4, 14,
11, 9,
7, 3,
8, 2,
12, 13,
1, 6,
15, 10,
16, 5,
4, 10,
12, 3,
5, 8,
13, 1,
14, 11,
2, 6,
15, 9,
7, 16,
1, 2,
5, 3,
16, 13,
15, 9,
11, 12,
7, 14,
8, 10,
4, 6,
8, 13,
16, 14,
15, 2,
11, 1,
3, 10,
4, 6,
7, 12,
5, 9,
};
static int numUniqueInt[] = {
1, 16,
1, 16,
0, 0,
};
static int testTuplesInt2[] = {
// There are no repeats in this set.
1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31, 32, 33,
};
static int numUniqueInt2[] = {
0, 0,
};
static vtkStdString testTuplesString[] = {
/*
To test the log(N) sampling strategy, we must
have a large number of entries in the array.
The 4 words marked "not detected" below are placed to leave them
intentionally undetected on at least one platform.
The vtkObject ModificationTime counter is used as a
seed for the random number generator and its count
will vary across platforms and compile-time options,
so we accept anywhere from 4 to 8 values being detected
when subsampling. This data is used twice: once forcing all
tuples to be sampled and once using subsampling.
*/
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Skeenie", "Beeny", "Piny", "Po", "Po", // not detected.
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
"Eeny", "Meeny", "Miny", "Mo", "Miny",
};
static int numUniqueStringComplete[2] = {
8, 8,
};
static int numUniqueStringSubset[2] = {
4, 8,
};
static bool CheckUniques(
vtkAbstractArray* arr, int* uniqueSizeBds,
double uncertainty, double minProminence)
{
bool ok = true;
if (!arr)
{
return ok;
}
cout << arr->GetName() << endl;
int nc = arr->GetNumberOfComponents();
vtkNew<vtkVariantArray> uniques;
for (int c = 0; c < nc; ++c)
{
arr->GetProminentComponentValues(
c, uniques.GetPointer(), uncertainty, minProminence);
int numUniques = static_cast<int>(uniques->GetNumberOfTuples());
cout << " comp " << c << " (" << numUniques << "): ";
for (int n = 0; n <= uniques->GetMaxId(); ++n)
{
cout
<< (n > 0 ? ", " : " ")
<< uniques->GetVariantValue(n).ToString().c_str();
}
cout << endl;
if (
uniqueSizeBds[2 * c] > numUniques ||
uniqueSizeBds[2 * c + 1] < numUniques)
{
cout
<< " ** ERROR: Expected between " << uniqueSizeBds[2 * c]
<< " and " << uniqueSizeBds[2 * c + 1] << " values\n";
ok = false;
}
}
if (nc > 1)
{
arr->GetProminentComponentValues(
-1, uniques.GetPointer(), uncertainty, minProminence);
int numUniques = static_cast<int>(uniques->GetNumberOfTuples());
cout << " tuples (" << numUniques << "): ";
for (int n = 0; n <= uniques->GetMaxId(); ++n)
{
cout
<< (n > 0 && n % nc == 0 ? ", " : " ")
<< uniques->GetVariantValue(n).ToString().c_str();
}
cout << endl;
if (
uniqueSizeBds[2 * nc] > numUniques ||
uniqueSizeBds[2 * nc + 1] < numUniques)
{
cout
<< " ** ERROR: Expected between " << uniqueSizeBds[2 * nc]
<< " and " << uniqueSizeBds[2 * nc + 1] << " values\n";
ok = false;
}
}
return ok;
}
int TestArrayUniqueValueDetection(int vtkNotUsed(argc), char* vtkNotUsed(argv)[])
{
bool ok = true;
vtkNew<vtkDoubleArray> darr;
vtkNew<vtkIntArray> iarr;
vtkNew<vtkStringArray> sarr;
darr->SetNumberOfComponents(3);
darr->SetArray(testTuplesDouble,
sizeof(testTuplesDouble)/sizeof(testTuplesDouble[0]), 1);
darr->SetName("Some3DPoints - Show off distinct tuple detection");
ok &= CheckUniques(darr.GetPointer(), numUniqueDouble, 0., 0.);
iarr->SetNumberOfComponents(2);
iarr->SetArray(testTuplesInt,
sizeof(testTuplesInt)/sizeof(testTuplesInt[0]), 1);
iarr->SetName("Some2DPoints - Show off tuple non-detection");
ok &= CheckUniques(iarr.GetPointer(), numUniqueInt, 0., 0.);
iarr->SetNumberOfComponents(1);
iarr->SetArray(testTuplesInt2,
sizeof(testTuplesInt2)/sizeof(testTuplesInt2[0]), 1);
//iarr->Modified(); // required since we have changed the tuples?
iarr->SetName("Some1DPoints - Show off component non-detection");
ok &= CheckUniques(iarr.GetPointer(), numUniqueInt2, 0., 0.);
sarr->SetNumberOfComponents(1);
sarr->SetArray(testTuplesString,
sizeof(testTuplesString)/sizeof(testTuplesString[0]), 1);
sarr->SetName("SomeNonWords - Show off string value detection");
ok &= CheckUniques(sarr.GetPointer(), numUniqueStringComplete, 0.0, 0.0);
sarr->Modified(); // Verify that modifying the array causes a re-compute
sarr->SetName("SomeNonWords - Show off non-exhaustive search");
ok &= CheckUniques(sarr.GetPointer(), numUniqueStringSubset, 0.5, 0.1);
return ok ? 0 : 1;
}
| [
"shentianweipku@gmail.com"
] | shentianweipku@gmail.com |
ff60857b4e67787726e417d93228d5cfe7b12f0b | 4e2e7db1f9fe5b640d014434c9069b5e14b5174a | /Jarawi and The Interview.cpp | db0deaf64d0b48244904e6adf6820ff4770d9de2 | [] | no_license | shaulshaul/competitive-programming | 9270dbe9d19ab616c3f9d87139c8e6f0e5b42139 | 455133d7c5f2909934250885d2c9dcb8c3037e0c | refs/heads/master | 2023-01-07T23:35:57.361200 | 2020-11-15T21:25:59 | 2020-11-15T21:25:59 | 299,413,709 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 958 | cpp | #include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q, val;
string s, p;
cin >> s;
cin >> q;
int trie[26][1000000+1];
int counter[26] = {0};
int n = s.length();
for (int i=0; i < n; i++){
trie[s[i] - 'a'][counter[s[i] - 'a']] = i;
counter[s[i] - 'a'] += 1;
}
for (int i=0; i< q; i++){
cin >> p;
n = p.length();
int c = 1e8;
int le;
//int ccounter[26] = {0};
int *idxptr = nullptr;
int x;
for (x=n - 1; x>=0; x--){
le = p[x] - 'a';
idxptr = upper_bound(trie[le], trie[le] + counter[le], c-1);
if (idxptr == trie[le]){
break;
}
c = *(--idxptr);
}
cout << n - x - 1 << "\n";
}
return 0;
}
| [
"shaul.rosner@gmail.com"
] | shaul.rosner@gmail.com |
99870d7bd9e798df76404ff0b8c4bc1e2e9bf31e | 5c889580a529ef345457c1f980ea5feb6eb34958 | /src/ZkGame/Config/PlayerAction.cpp | e18ffc10704469f621b2bf26bcf62ac63ab87510 | [] | no_license | pawloKoder/zoldak | 4751b568443832db51a49ad8659c9aad48db9ef2 | 040c8acf7fab668693a87e93deb406edb9523f76 | refs/heads/master | 2021-01-22T21:28:22.383729 | 2014-12-11T16:31:25 | 2014-12-11T16:32:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 518 | cpp | #include <map>
#include "PlayerAction.h"
using namespace Zk::Game;
const char * Zk::Game::playerActionToName(PlayerAction pa)
{
static const std::map<PlayerAction, const char*> playerActionName {
{ PlayerAction::GoLeft, "Walk left" },
{ PlayerAction::GoRight, "Walk right" },
{ PlayerAction::Jump, "Jump" },
{ PlayerAction::ThrowGrenade, "Throw grenade" },
{ PlayerAction::Shoot, "Shoot" }
};
auto it = playerActionName.find(pa);
return (it != playerActionName.end()) ? it->second : "???";
}
| [
"piodul@op.pl"
] | piodul@op.pl |
1609b7d639d9df420571edb9c7733edb60bb4399 | 1f4607c53da78944692c355d660e16c6762fd01e | /src/NormalizedGradient/NormalizedGradientUInt8/NormalizedGradientUInt8.cpp | c59765fde8124683759fcf35df949d767effcdf6 | [] | no_license | ckobylko/HIPAccBenchmark | b1445964e3ecb5cb0be5ab6281686fb3b7ca5500 | 822da3463055c2ef523c0f713cbf70b7966f1c27 | refs/heads/master | 2020-04-07T13:11:43.046859 | 2015-07-29T15:05:46 | 2015-07-29T15:05:46 | 21,165,004 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,484 | cpp | #include "../NormalizedGradientDefines.h"
#include "NormalizedGradientUInt8Handlers.h"
void NormalizedGradient::_RunUInt8()
{
const size_t cszIters = static_cast< size_t >( TEST_RUN_COUNT );
printf("\n Running \"_RunUInt8()\" - Image-Size = %4d x %4d\n", ciImageWidth, ciImageHeight);
HandlerList lstHandlers;
AppendHandlerList( lstHandlers, NormalizedGradientUInt8_GetScalarHandlers() );
AppendHandlerList( lstHandlers, NormalizedGradientUInt8_GetSSEHandlers() );
AppendHandlerList( lstHandlers, NormalizedGradientUInt8_GetAVXHandlers() );
CREATE_IMAGE( InputImageType1, spInputImage1 );
CREATE_IMAGE( InputImageType2, spInputImage2 );
CREATE_IMAGE( OutputImageType, spOutputImage1 );
CREATE_IMAGE( OutputImageType, spOutputImage2 );
// Generate gradient images (by 3x3 Sobel filter)
{
MAKE_IMAGE_TYPE( TestImageType, double, ciImageWidth, ciImageHeight );
CREATE_IMAGE( TestImageType, spTestImage );
ImageIO::LoadTestImage( *spTestImage );
for (int iY = 1; iY < TestImageType::GetHeight() - 1; ++iY)
{
for (int iX = 1; iX < TestImageType::GetWidth() - 1; ++iX)
{
double dGradX = 0.;
double dGradY = 0.;
for (int iOff = -1; iOff <= 1; ++iOff)
{
const double cdMultiplier = (iOff == 0) ? 2. : 1.;
dGradX += ( spTestImage->Data[ iY + iOff ][ iX + 1 ] - spTestImage->Data[ iY + iOff ][ iX - 1 ] ) * cdMultiplier;
dGradY += ( spTestImage->Data[ iY + 1 ][ iX + iOff ] - spTestImage->Data[ iY - 1 ][ iX + iOff ] ) * cdMultiplier;
}
spInputImage1->Data[ iY ][ iX ] = static_cast< InputPixelType_1 >( dGradX / 8. );
spInputImage2->Data[ iY ][ iX ] = static_cast< InputPixelType_2 >( dGradY / 8. );
}
}
}
for (auto itHandler : lstHandlers)
{
printf( "\n Launch handler \"%10s\" -> ", itHandler->GetName().c_str() );
double dTime = omp_get_wtime();
for (size_t szIter = static_cast<size_t>(0); szIter < cszIters; ++szIter)
{
_mm256_zeroall();
itHandler->Launch( spOutputImage1, spOutputImage2, spInputImage1, spInputImage2 );
}
dTime = omp_get_wtime() - dTime;
dTime = (dTime * 1000.) / static_cast< double >( cszIters );
printf( "%10.6f ms", dTime );
}
#ifdef CONFIG_CHECK_OUTPUT
NORMALIZED_GRADIENT_CHECK_OUTPUT( UInt8 );
#endif
printf("\n");
}
| [
"ckobylko@users.noreply.github.com"
] | ckobylko@users.noreply.github.com |
cd42794ca43fbcf861d7cf27e3a5905d0b00373b | f48f598536152808a94d7053174ba1086103b562 | /unidad 2.cpp | c378e324410b064eefacc89b749db687efda8632 | [] | no_license | Fundamentos-Prog-Electronica-18-2/ejercicios-clase-8-DorisAlejandra | 4c9acffe6a54025a4d36d5e26918243f692cf979 | 1793754c81e2ef2ede72b4d1a84a9d215e7a12b4 | refs/heads/master | 2020-04-07T17:05:38.086172 | 2018-11-21T16:39:01 | 2018-11-21T16:39:01 | 158,556,317 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 251 | cpp | #include <iostream>
#include<string>
using namespace std;
int main (){
string nombre;
cout<< "ejemplo de uso de cadena string "<<endl;
cout << "ingrese su nombre porfvor"<<endl;
cin>> nombre;
cout<< "el nombre ingresado es:"<<nombre<<endl;
}
| [
"alejita13102015@gmail.com"
] | alejita13102015@gmail.com |
25390b2553da8f6425fafbdd96e326a1d0c62c3f | 8af50772544313eca16d5f91dac5189e46fd0bb0 | /Tests/CDC_Template_Tests.h | 1b35755e0050f717ea1cfd6993025e2effdb76ea | [] | no_license | jjzhang166/CDC_MySQL | 463fc12a6ae7c3190bc2d846cbb8779cf997d545 | cd5b2147483ac1f71007ebbb85cabcdec548d5a3 | refs/heads/master | 2021-06-25T05:40:03.836099 | 2017-02-26T09:41:53 | 2017-02-26T09:41:53 | 103,227,273 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 590 | h |
#ifndef CDC_Template_Tests_INCLUDED
#define CDC_Template_Tests_INCLUDED
#include "CppUnit/TestCase.h"
#include "CDC_Template.h"
#include "CDC_Host.h"
class CDC_Template_Tests: public CppUnit::TestCase
{
public:
CDC_Template_Tests(const std::string& name);
~CDC_Template_Tests();
void setUp();
void tearDown();
void testJsonAdd();
void testJsonDel();
void testJsonUpdate();
void testJsonFind();
void testJsonFindCount();
static CppUnit::Test* suite();
private:
CDC_Template* _pObj;
CDC_Host* _pCDC_HostObj;
private:
void dependsFuc();
};
#endif // SQLiteTest_INCLUDED
| [
"stallion5632@163.com"
] | stallion5632@163.com |
54b1ab53d43927e8ba0dd118bdcac8b315bba582 | e3e7d8cfd55c30ca41eebf3fff9875a413265b9e | /Introduction-cses/coin_piles.cpp | 51b5fbbb95c5c3c34a6443d3ca1b6a544c563b48 | [] | no_license | Ritik008/CSES-Problem-Set | 9d187d905d7732114bf65927250529036e84f710 | d3c0e9ef4765afb5052c5c81511f14edcc5fae55 | refs/heads/main | 2023-06-17T10:17:42.486293 | 2021-07-15T15:38:03 | 2021-07-15T15:38:03 | 374,360,537 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 404 | cpp | #include<bits/stdc++.h>
#define int long long int
#define endl "\n"
using namespace std;
int32_t main() {
int t;
cin >> t;
while(t--) {
int a, b;
cin >> a >> b;
int m = min(a, b);
int diff = abs(a - b);
m -= diff;
if(m == 0 || (m > 0 && m % 3 == 0)) {
cout << "YES" << endl;
}else {
cout << "NO" << endl;
}
}
return 0;
}
| [
"noreply@github.com"
] | Ritik008.noreply@github.com |
343e24df7826de5f642375a8b4083f051d647191 | 16340827bf2dc2cde2260d0cf23bc8d17a96909f | /include/graphics/tcOptionsView2.h | d6c15abc3183fc733b6da81f9b5841605164ab67 | [
"BSD-3-Clause"
] | permissive | quakex/gcblue | f6a323fbc9e185e780a272c40445382a44c570a6 | 433ebf1b4c2f2d4448777c46e3b67f0a16be05e0 | refs/heads/master | 2021-01-11T04:56:44.138810 | 2015-08-02T15:03:36 | 2015-08-02T15:03:36 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,075 | h | /**
** @file tcOptionsView2.h
*/
/*
** Copyright (c) 2014, GCBLUE 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.
*/
#ifndef _OPTIONSVIEW2_H_
#define _OPTIONSVIEW2_H_
#if _MSC_VER > 1000
#pragma once
#endif
#include "wx/wx.h"
#include <boost/shared_ptr.hpp>
#include "tcOptions.h"
#include "tcXmlWindow.h"
#include "tcTabbedWindow.h"
class tcTexture2D;
class tcOptions;
class tcSound;
/// View and GUI for user options data
class tcOptionsView2 : public tcXmlWindow, public tcTabbedWindow
{
// placement info for GUI buttons, text, etc.
struct tsButtonInfo
{
int buttonX;
int buttonY;
int textX;
int textY;
int optionIdx;
int valueIdx;
bool isSlider; ///< a hack to add sliders
tcRect thumbRect; ///< rect of slider "thumb"
};
public:
void Init();
void Draw();
void DrawButton(int x, int y, int abOn);
void DrawSlider(int x, int y, tcRect thumbRect, float value, bool interacting);
void OnLButtonDown(wxMouseEvent& event);
void OnLButtonUp(wxMouseEvent& event);
void OnLeaveWindow(wxMouseEvent& event);
void OnMouseMove(wxMouseEvent& event);
bool OnLButtonDownSlider(const wxPoint& pos);
void OnSize(wxSizeEvent& event);
virtual void SetActive(bool abActive);
bool ButtonContainingPoint(wxPoint point, int& rnOption, int& rnValue);
tcOptionsView2(wxWindow* parent,
const wxPoint& pos, const wxSize& size,
const wxString& name = "OptionsView");
tcOptionsView2(tc3DWindow2* parent,
const wxPoint& pos, const wxSize& size,
const wxString& name);
virtual ~tcOptionsView2();
private:
tcOptions *mpOptions;
struct ControlGroup
{
std::string groupName;
std::vector<tc3DWindow2*> controls;
std::vector<tc3DWindow2*> labels;
};
std::vector<ControlGroup> controlGroups;
boost::shared_ptr<tcTexture2D> mpiButtonOn;
boost::shared_ptr<tcTexture2D> mpiButtonOff;
float fontSize; ///< font size of options choice text
int mnButtonWidth;
int mnButtonHeight;
std::vector<tsButtonInfo> buttonInfo;
int mnXStart;
int mnYStart;
std::string lastTab;
// section to support dragging slider bar
const float sliderBarWidth;
bool sliderDragActive;
size_t sliderIdx; ///< index in buttonInfo of slider being dragged
wxPoint buttonDownPoint;
float sliderDragValue;
std::string buttonDownTab; ///< to detect if tab has been changed in middle of drag
void OnControlUpdate(wxCommandEvent& event);
void CloseAllLists();
void UpdateButtonInfo();
DECLARE_EVENT_TABLE()
};
#endif // _OPTIONSVIEW_H_
| [
"dewitt@gcblue.com"
] | dewitt@gcblue.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.