blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 4 201 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 7 100 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 260
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 11.4k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 17
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 80
values | src_encoding stringclasses 28
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 8 9.86M | extension stringclasses 52
values | content stringlengths 8 9.86M | authors listlengths 1 1 | author stringlengths 0 119 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ece3e837f6319c35a87fb4c371f8f1ff74d7d105 | 0606146ac3b7c3132d8b86d2a7b574d330062c72 | /Engine/Source/Engine/DeferredShading/SsaoCompositorLogic.cpp | 754b6da09bf4f5112077315ea4f5e0ce970b5a43 | [] | no_license | summerbreezeex/SolidBlack | ff6c3a3f4a3391d24a428f14620e7c3590a14cb5 | 5c7bac43443ef234b657ef9b80a3935aaf40e71f | refs/heads/master | 2016-09-06T04:14:12.965044 | 2012-04-30T00:00:26 | 2012-04-30T00:00:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 235 | cpp | #include "Engine/DeferredShading/SsaoListener.h"
#include "SsaoCompositorLogic.h"
Ogre::CompositorInstance::Listener* SsaoCompositorLogic::createListener(Ogre::CompositorInstance* instance) {
return new SsaoListener(instance);
}
| [
"colin.james.hill@gmail.com"
] | colin.james.hill@gmail.com |
a462468e05d536b30c373495f3469769c951938c | 1d928c3f90d4a0a9a3919a804597aa0a4aab19a3 | /c++/libtorrent/2016/8/dht_storage.cpp | b7cc6eb6026e2061d1291edba7836d3afe5d6afb | [] | no_license | rosoareslv/SED99 | d8b2ff5811e7f0ffc59be066a5a0349a92cbb845 | a062c118f12b93172e31e8ca115ce3f871b64461 | refs/heads/main | 2023-02-22T21:59:02.703005 | 2021-01-28T19:40:51 | 2021-01-28T19:40:51 | 306,497,459 | 1 | 1 | null | 2020-11-24T20:56:18 | 2020-10-23T01:18:07 | null | UTF-8 | C++ | false | false | 16,216 | cpp | /*
Copyright (c) 2012-2016, Arvid Norberg, Alden Torres
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 the author 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 "libtorrent/kademlia/dht_storage.hpp"
#include <tuple>
#include <algorithm>
#include <utility>
#include <map>
#include <set>
#include <string>
#include <libtorrent/socket_io.hpp>
#include <libtorrent/aux_/time.hpp>
#include <libtorrent/config.hpp>
#include <libtorrent/time.hpp>
#include <libtorrent/socket.hpp>
#include <libtorrent/sha1_hash.hpp>
#include <libtorrent/bloom_filter.hpp>
#include <libtorrent/address.hpp>
#include <libtorrent/session_settings.hpp>
#include <libtorrent/performance_counters.hpp>
#include <libtorrent/random.hpp>
#include <libtorrent/kademlia/item.hpp>
#include <libtorrent/kademlia/node_id.hpp>
namespace libtorrent {
namespace dht {
namespace
{
using detail::write_endpoint;
// this is the entry for every peer
// the timestamp is there to make it possible
// to remove stale peers
struct peer_entry
{
time_point added;
tcp::endpoint addr;
bool seed;
};
// internal
bool operator<(peer_entry const& lhs, peer_entry const& rhs)
{
return lhs.addr.address() == rhs.addr.address()
? lhs.addr.port() < rhs.addr.port()
: lhs.addr.address() < rhs.addr.address();
}
// this is a group. It contains a set of group members
struct torrent_entry
{
std::string name;
std::set<peer_entry> peers;
};
// TODO: 2 make this configurable in dht_settings
enum { announce_interval = 30 };
struct dht_immutable_item
{
// the actual value
std::unique_ptr<char[]> value;
// this counts the number of IPs we have seen
// announcing this item, this is used to determine
// popularity if we reach the limit of items to store
bloom_filter<128> ips;
// the last time we heard about this
time_point last_seen;
// number of IPs in the bloom filter
int num_announcers = 0;
// size of malloced space pointed to by value
int size = 0;
};
struct dht_mutable_item : dht_immutable_item
{
signature sig;
sequence_number seq;
public_key key;
std::string salt;
};
void touch_item(dht_immutable_item* f, address const& addr)
{
f->last_seen = aux::time_now();
// maybe increase num_announcers if we haven't seen this IP before
sha1_hash iphash;
hash_address(addr, iphash);
if (!f->ips.find(iphash))
{
f->ips.set(iphash);
++f->num_announcers;
}
}
// return true of the first argument is a better candidate for removal, i.e.
// less important to keep
struct immutable_item_comparator
{
explicit immutable_item_comparator(std::vector<node_id> const& node_ids) : m_node_ids(node_ids) {}
immutable_item_comparator(immutable_item_comparator const&) = default;
template <typename Item>
bool operator()(std::pair<node_id const, Item> const& lhs
, std::pair<node_id const, Item> const& rhs) const
{
int const l_distance = min_distance_exp(lhs.first, m_node_ids);
int const r_distance = min_distance_exp(rhs.first, m_node_ids);
// this is a score taking the popularity (number of announcers) and the
// fit, in terms of distance from ideal storing node, into account.
// each additional 5 announcers is worth one extra bit in the distance.
// that is, an item with 10 announcers is allowed to be twice as far
// from another item with 5 announcers, from our node ID. Twice as far
// because it gets one more bit.
return lhs.second.num_announcers / 5 - l_distance < rhs.second.num_announcers / 5 - r_distance;
}
private:
// explicitly disallow assignment, to silence msvc warning
immutable_item_comparator& operator=(immutable_item_comparator const&);
std::vector<node_id> const& m_node_ids;
};
// picks the least important one (i.e. the one
// the fewest peers are announcing, and farthest
// from our node IDs)
template<class Item>
typename std::map<node_id, Item>::const_iterator pick_least_important_item(
std::vector<node_id> const& node_ids, std::map<node_id, Item> const& table)
{
return std::min_element(table.begin(), table.end()
, immutable_item_comparator(node_ids));
}
class dht_default_storage final : public dht_storage_interface, boost::noncopyable
{
using table_t = std::map<node_id, torrent_entry>;
using dht_immutable_table_t = std::map<node_id, dht_immutable_item>;
using dht_mutable_table_t = std::map<node_id, dht_mutable_item>;
public:
explicit dht_default_storage(dht_settings const& settings)
: m_settings(settings)
{
m_counters.reset();
}
~dht_default_storage() override = default;
#ifndef TORRENT_NO_DEPRECATE
size_t num_torrents() const override { return m_map.size(); }
size_t num_peers() const override
{
size_t ret = 0;
for (auto const& t : m_map)
ret += t.second.peers.size();
return ret;
}
#endif
void update_node_ids(std::vector<node_id> const& ids) override
{
m_node_ids = ids;
}
bool get_peers(sha1_hash const& info_hash
, bool const noseed, bool const scrape
, entry& peers) const override
{
table_t::const_iterator i = m_map.lower_bound(info_hash);
if (i == m_map.end()) return false;
if (i->first != info_hash) return false;
torrent_entry const& v = i->second;
if (!v.name.empty()) peers["n"] = v.name;
if (scrape)
{
bloom_filter<256> downloaders;
bloom_filter<256> seeds;
for (std::set<peer_entry>::const_iterator peer_it = v.peers.begin()
, end(v.peers.end()); peer_it != end; ++peer_it)
{
sha1_hash iphash;
hash_address(peer_it->addr.address(), iphash);
if (peer_it->seed) seeds.set(iphash);
else downloaders.set(iphash);
}
peers["BFpe"] = downloaders.to_string();
peers["BFsd"] = seeds.to_string();
}
else
{
int max = m_settings.max_peers_reply;
// if these are IPv6 peers their addresses are 4x the size of IPv4
// so reduce the max peers 4 fold to compensate
// max_peers_reply should probably be specified in bytes
if (!v.peers.empty() && v.peers.begin()->addr.protocol() == tcp::v6())
max /= 4;
// we're picking "to_pick" from a list of "num" at random.
int const to_pick = (std::min)(int(v.peers.size()), max);
std::set<peer_entry>::const_iterator iter = v.peers.begin();
entry::list_type& pe = peers["values"].list();
for (int t = 0, m = 0; m < to_pick && iter != v.peers.end(); ++iter)
{
// if the node asking for peers is a seed, skip seeds from the
// peer list
if (noseed && iter->seed) continue;
++t;
std::string* str;
if (t <= to_pick)
{
pe.push_back(entry());
str = &pe.back().string();
}
else
{
// maybe replace an item we've already picked
if (random(t-1) >= to_pick) continue;
str = &pe[random(to_pick - 1)].string();
}
str->resize(18);
std::string::iterator out = str->begin();
write_endpoint(iter->addr, out);
str->resize(out - str->begin());
++m;
}
}
return true;
}
void announce_peer(sha1_hash const& info_hash
, tcp::endpoint const& endp
, string_view name, bool const seed) override
{
table_t::iterator ti = m_map.find(info_hash);
torrent_entry* v;
if (ti == m_map.end())
{
// we don't have this torrent, add it
// do we need to remove another one first?
if (!m_map.empty() && int(m_map.size()) >= m_settings.max_torrents)
{
// we need to remove some. Remove the ones with the
// fewest peers
int num_peers = int(m_map.begin()->second.peers.size());
table_t::iterator candidate = m_map.begin();
for (table_t::iterator i = m_map.begin()
, end(m_map.end()); i != end; ++i)
{
if (int(i->second.peers.size()) > num_peers) continue;
if (i->first == info_hash) continue;
num_peers = int(i->second.peers.size());
candidate = i;
}
m_map.erase(candidate);
m_counters.peers -= num_peers;
m_counters.torrents -= 1;
}
m_counters.torrents += 1;
v = &m_map[info_hash];
}
else
{
v = &ti->second;
}
// the peer announces a torrent name, and we don't have a name
// for this torrent. Store it.
if (!name.empty() && v->name.empty())
{
v->name = name.substr(0, 100).to_string();
}
peer_entry peer;
peer.addr = endp;
peer.added = aux::time_now();
peer.seed = seed;
std::set<peer_entry>::iterator i = v->peers.find(peer);
if (i != v->peers.end())
{
v->peers.erase(i++);
m_counters.peers -= 1;
}
else if (v->peers.size() >= m_settings.max_peers)
{
// when we're at capacity, there's a 50/50 chance of dropping the
// announcing peer or an existing peer
if (random(1)) return;
i = v->peers.lower_bound(peer);
if (i == v->peers.end()) --i;
v->peers.erase(i++);
m_counters.peers -= 1;
}
v->peers.insert(i, peer);
m_counters.peers += 1;
}
bool get_immutable_item(sha1_hash const& target
, entry& item) const override
{
dht_immutable_table_t::const_iterator i = m_immutable_table.find(target);
if (i == m_immutable_table.end()) return false;
item["v"] = bdecode(i->second.value.get()
, i->second.value.get() + i->second.size);
return true;
}
void put_immutable_item(sha1_hash const& target
, span<char const> buf
, address const& addr) override
{
TORRENT_ASSERT(!m_node_ids.empty());
dht_immutable_table_t::iterator i = m_immutable_table.find(target);
if (i == m_immutable_table.end())
{
// make sure we don't add too many items
if (int(m_immutable_table.size()) >= m_settings.max_dht_items)
{
auto j = pick_least_important_item(m_node_ids
, m_immutable_table);
TORRENT_ASSERT(j != m_immutable_table.end());
m_immutable_table.erase(j);
m_counters.immutable_data -= 1;
}
dht_immutable_item to_add;
to_add.value.reset(new char[buf.size()]);
to_add.size = int(buf.size());
memcpy(to_add.value.get(), buf.data(), buf.size());
std::tie(i, std::ignore) = m_immutable_table.insert(
std::make_pair(target, std::move(to_add)));
m_counters.immutable_data += 1;
}
// std::fprintf(stderr, "added immutable item (%d)\n", int(m_immutable_table.size()));
touch_item(&i->second, addr);
}
bool get_mutable_item_seq(sha1_hash const& target
, sequence_number& seq) const override
{
dht_mutable_table_t::const_iterator i = m_mutable_table.find(target);
if (i == m_mutable_table.end()) return false;
seq = i->second.seq;
return true;
}
bool get_mutable_item(sha1_hash const& target
, sequence_number seq, bool force_fill
, entry& item) const override
{
dht_mutable_table_t::const_iterator i = m_mutable_table.find(target);
if (i == m_mutable_table.end()) return false;
dht_mutable_item const& f = i->second;
item["seq"] = f.seq.value;
if (force_fill || (sequence_number(0) <= seq && seq < f.seq))
{
item["v"] = bdecode(f.value.get(), f.value.get() + f.size);
item["sig"] = f.sig.bytes;
item["k"] = f.key.bytes;
}
return true;
}
void put_mutable_item(sha1_hash const& target
, span<char const> buf
, signature const& sig
, sequence_number seq
, public_key const& pk
, span<char const> salt
, address const& addr) override
{
TORRENT_ASSERT(!m_node_ids.empty());
dht_mutable_table_t::iterator i = m_mutable_table.find(target);
if (i == m_mutable_table.end())
{
// this is the case where we don't have an item in this slot
// make sure we don't add too many items
if (int(m_mutable_table.size()) >= m_settings.max_dht_items)
{
auto j = pick_least_important_item(m_node_ids
, m_mutable_table);
TORRENT_ASSERT(j != m_mutable_table.end());
m_mutable_table.erase(j);
m_counters.mutable_data -= 1;
}
dht_mutable_item to_add;
to_add.value.reset(new char[buf.size()]);
to_add.size = int(buf.size());
to_add.seq = seq;
to_add.salt.assign(salt.data(), salt.size());
to_add.sig = sig;
to_add.key = pk;
memcpy(to_add.value.get(), buf.data(), buf.size());
std::tie(i, std::ignore) = m_mutable_table.insert(
std::make_pair(target, std::move(to_add)));
m_counters.mutable_data += 1;
}
else
{
// this is the case where we already
dht_mutable_item& item = i->second;
if (item.seq < seq)
{
if (item.size != buf.size())
{
item.value.reset(new char[buf.size()]);
item.size = int(buf.size());
}
item.seq = seq;
item.sig = sig;
memcpy(item.value.get(), buf.data(), buf.size());
}
}
touch_item(&i->second, addr);
}
void tick() override
{
time_point now(aux::time_now());
// look through all peers and see if any have timed out
for (table_t::iterator i = m_map.begin(), end(m_map.end()); i != end;)
{
torrent_entry& t = i->second;
purge_peers(t.peers);
if (!t.peers.empty())
{
++i;
continue;
}
// if there are no more peers, remove the entry altogether
m_map.erase(i++);
m_counters.torrents -= 1;// peers is decreased by purge_peers
}
if (0 == m_settings.item_lifetime) return;
time_duration lifetime = seconds(m_settings.item_lifetime);
// item lifetime must >= 120 minutes.
if (lifetime < minutes(120)) lifetime = minutes(120);
for (dht_immutable_table_t::iterator i = m_immutable_table.begin();
i != m_immutable_table.end();)
{
if (i->second.last_seen + lifetime > now)
{
++i;
continue;
}
m_immutable_table.erase(i++);
m_counters.immutable_data -= 1;
}
for (dht_mutable_table_t::iterator i = m_mutable_table.begin();
i != m_mutable_table.end();)
{
if (i->second.last_seen + lifetime > now)
{
++i;
continue;
}
m_mutable_table.erase(i++);
m_counters.mutable_data -= 1;
}
}
dht_storage_counters counters() const override
{
return m_counters;
}
private:
dht_settings const& m_settings;
dht_storage_counters m_counters;
std::vector<node_id> m_node_ids;
table_t m_map;
dht_immutable_table_t m_immutable_table;
dht_mutable_table_t m_mutable_table;
void purge_peers(std::set<peer_entry>& peers)
{
for (std::set<peer_entry>::iterator i = peers.begin()
, end(peers.end()); i != end;)
{
// the peer has timed out
if (i->added + minutes(int(announce_interval * 3 / 2)) < aux::time_now())
{
peers.erase(i++);
m_counters.peers -= 1;
}
else
++i;
}
}
};
}
void dht_storage_counters::reset()
{
torrents = 0;
peers = 0;
immutable_data = 0;
mutable_data = 0;
}
std::unique_ptr<dht_storage_interface> dht_default_storage_constructor(
dht_settings const& settings)
{
return std::unique_ptr<dht_default_storage>(new dht_default_storage(settings));
}
} } // namespace libtorrent::dht
| [
"rodrigosoaresilva@gmail.com"
] | rodrigosoaresilva@gmail.com |
40837dbebc76009343067fd39463cf8d0db3cd5e | 6e72bfb69388f3be8af7e2887c56de30ff2a0ba1 | /appinventor/Pods/geos/geos/src/io/Writer.cpp | 707b46c1db01b7011cbce2a181873021bc299b80 | [
"LGPL-2.1-only",
"Apache-2.0"
] | permissive | bobanss/appinventor-sources | 4a0fbc1867ffb2696cb19ff27ff68f0296236883 | 719e7244bf676675b95339871f16e54521a9a47f | refs/heads/master | 2023-07-06T10:30:09.141453 | 2023-06-18T01:07:42 | 2023-06-18T01:07:42 | 208,414,643 | 0 | 0 | Apache-2.0 | 2019-09-14T08:57:27 | 2019-09-14T08:57:27 | null | UTF-8 | C++ | false | false | 1,074 | cpp | /**********************************************************************
*
* GEOS - Geometry Engine Open Source
* http://geos.osgeo.org
*
* Copyright (C) 2005-2006 Refractions Research Inc.
* Copyright (C) 2001-2002 Vivid Solutions Inc.
*
* This is free software; you can redistribute and/or modify it under
* the terms of the GNU Lesser General Public Licence as published
* by the Free Software Foundation.
* See the COPYING file for more information.
*
**********************************************************************
*
* Last port: ORIGINAL WORK to be used like java.io.Writer
*
**********************************************************************/
#include <geos/io/Writer.h>
#include <string>
using namespace std;
namespace geos {
namespace io { // geos.io
Writer::Writer()
{
}
void
Writer::reserve(std::size_t capacity)
{
str.reserve(capacity);
}
Writer::~Writer()
{
}
void
Writer::write(const std::string& txt)
{
str.append(txt);
}
const std::string&
Writer::toString()
{
return str;
}
} // namespace geos.io
} // namespace geos
| [
"ewpatton@mit.edu"
] | ewpatton@mit.edu |
8124e921dc2bd7c79f99bcdfb1fada444bb60a4f | c98b6679b5c021cf228c65fc1eebd7d9aebb6654 | /src/wallet.h | 0ab5704a329d4a84636a4b2ef237b7912b58550c | [
"MIT"
] | permissive | 15831944/soypay | c0dee69165bd2b902257ba3202f243317cedf2af | 13deb7c036958179d926f0eb62856adfde52054e | refs/heads/master | 2023-03-16T15:25:40.296995 | 2014-10-23T03:35:45 | 2014-10-23T03:36:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 18,173 | h | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2013 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_WALLET_H
#define BITCOIN_WALLET_H
#include "core.h"
#include "crypter.h"
#include "key.h"
#include "keystore.h"
#include "main.h"
#include "ui_interface.h"
#include "util.h"
#include "walletdb.h"
#include <algorithm>
#include <map>
#include <set>
#include <stdexcept>
#include <stdint.h>
#include <string>
#include <utility>
#include <vector>
#include <memory>
// Settings
extern int64_t nTransactionFee;
extern bool bSpendZeroConfChange;
// -paytxfee default
static const int64_t DEFAULT_TRANSACTION_FEE = 0;
// -paytxfee will warn if called with a higher fee than this amount (in satoshis) per KB
static const int nHighTransactionFeeWarning = 0.01 * COIN;
class CAccountingEntry;
class CCoinControl;
class CReserveKey;
class CScript;
//class CRegID;
/** (client) version numbers for particular wallet features */
enum WalletFeature {
FEATURE_BASE = 10500, // the earliest version new wallets supports (only useful for getinfo's clientversion output)
FEATURE_WALLETCRYPT = 40000, // wallet encryption
FEATURE_COMPRPUBKEY = 60000, // compressed public keys
FEATURE_LATEST = 60000
};
/** A key pool entry */
class CKeyPool {
public:
int64_t nTime;
CPubKey vchPubKey;
CKeyPool() {
nTime = GetTime();
}
CKeyPool(const CPubKey& vchPubKeyIn) {
nTime = GetTime();
vchPubKey = vchPubKeyIn;
}
IMPLEMENT_SERIALIZE
(
if (!(nType & SER_GETHASH))
READWRITE(nVersion);
READWRITE(nTime);
READWRITE(vchPubKey);
)
};
/** Address book data */
class CAddressBookData {
public:
string name;
string purpose;
CAddressBookData() {
purpose = "unknown";
}
typedef map<string, string> StringMap;
StringMap destdata;
};
/** A CWallet is an extension of a keystore, which also maintains a set of transactions and balances,
* and provides the ability to create new transactions.
*/
class CWallet: public CCryptoKeyStore, public CWalletInterface {
private:
CWalletDB *pwalletdbEncryption;
// the current wallet version: clients below this version are not able to load the wallet
int nWalletVersion;
// the maximum wallet format version: memory-only variable that specifies to what version this wallet may be upgraded
int nWalletMaxVersion;
int64_t nNextResend;
int64_t nLastResend;
public:
/// Main wallet lock.
/// This lock protects all the fields added by CWallet
/// except for:
/// fFileBacked (immutable after instantiation)
/// strWalletFile (immutable after instantiation)
mutable CCriticalSection cs_wallet;
bool fFileBacked;
string strWalletFile;
set<int64_t> setKeyPool;
map<CKeyID, CKeyMetadata> mapKeyMetadata;
map<CKeyID, CRegID> mapKeyRegID;
map<uint256, CRegID> mapScriptRegID;
typedef map<unsigned int, CMasterKey> MasterKeyMap;
MasterKeyMap mapMasterKeys;
unsigned int nMasterKeyMaxID;
CWallet() {
SetNull();
}
CWallet(string strWalletFileIn) {
SetNull();
strWalletFile = strWalletFileIn;
fFileBacked = true;
}
void SetNull() {
nWalletVersion = FEATURE_BASE;
nWalletMaxVersion = FEATURE_BASE;
fFileBacked = false;
nMasterKeyMaxID = 0;
pwalletdbEncryption = NULL;
nOrderPosNext = 0;
nNextResend = 0;
nLastResend = 0;
nTimeFirstKey = 0;
}
map<uint256, CAccountTx> mapWalletTx;
int64_t nOrderPosNext;
map<uint256, int> mapRequestCount;
map<CTxDestination, CAddressBookData> mapAddressBook;
CPubKey vchDefaultKey;
int64_t nTimeFirstKey;
const CAccountTx* GetAccountTx(const uint256& hash) const;
bool GetTx(const uint256& hash,std::shared_ptr<CBaseTransaction> &tx) const;
// check whether we are allowed to upgrade (or already support) to the named feature
bool CanSupportFeature(enum WalletFeature wf) {
AssertLockHeld(cs_wallet);
return nWalletMaxVersion >= wf;
}
// keystore implementation
// Generate a new key
CPubKey GenerateNewKey();
// Adds a key to the store, and saves it to disk.
bool AddKeyPubKey(const CKey& key, const CPubKey &pubkey);
// Adds a key to the store, without saving it to disk (used by LoadWallet)
bool LoadKey(const CKey& key, const CPubKey &pubkey) {
return CCryptoKeyStore::AddKeyPubKey(key, pubkey);
}
// Load metadata (used by LoadWallet)
bool LoadKeyMetadata(const CPubKey &pubkey, const CKeyMetadata &metadata);
bool LoadMinVersion(int nVersion) {
AssertLockHeld(cs_wallet);
nWalletVersion = nVersion;
nWalletMaxVersion = max(nWalletMaxVersion, nVersion);
return true;
}
// Adds an encrypted key to the store, and saves it to disk.
bool AddCryptedKey(const CPubKey &vchPubKey, const vector<unsigned char> &vchCryptedSecret);
// Adds an encrypted key to the store, without saving it to disk (used by LoadWallet)
bool LoadCryptedKey(const CPubKey &vchPubKey, const vector<unsigned char> &vchCryptedSecret);
bool AddCScript(const CScript& redeemScript);
bool LoadCScript(const CScript& redeemScript) {
return CCryptoKeyStore::AddCScript(redeemScript);
}
/// Adds a destination data tuple to the store, and saves it to disk
bool AddDestData(const CTxDestination &dest, const string &key, const string &value);
/// Erases a destination data tuple in the store and on disk
bool EraseDestData(const CTxDestination &dest, const string &key);
/// Adds a destination data tuple to the store, without saving it to disk
bool LoadDestData(const CTxDestination &dest, const string &key, const string &value);
/// Look up a destination data tuple in the store, return true if found false otherwise
bool GetDestData(const CTxDestination &dest, const string &key, string *value) const;
bool Unlock(const SecureString& strWalletPassphrase);
bool ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase);
bool EncryptWallet(const SecureString& strWalletPassphrase);
void GetKeyBirthTimes(map<CKeyID, int64_t> &mapKeyBirth) const;
/** Increment the next transaction order id
@return next transaction order id
*/
int64_t IncOrderPosNext(CWalletDB *pwalletdb = NULL);
bool AddToWallet(const CAccountTx& accTx);
// void SyncTransaction(const CBaseTransaction *pTx, const CBlock* pblock, const bool bConnect = true);
void SyncTransaction(const uint256 &hash, const CBaseTransaction *pTx, const CBlock* pblock);
void EraseFromWallet(const uint256 &hash);
int ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false);
void ReacceptWalletTransactions();
void ResendWalletTransactions();
bool NewKeyPool();
bool TopUpKeyPool(unsigned int kpSize = 0);
int64_t AddReserveKey(const CKeyPool& keypool);
void ReserveKeyFromKeyPool(int64_t& nIndex, CKeyPool& keypool);
void KeepKey(int64_t nIndex);
void ReturnKey(int64_t nIndex);
bool GetKeyFromPool(CPubKey &key);
int64_t GetOldestKeyPoolTime();
void GetAllReserveKeys(set<CKeyID>& setAddress) const;
set<set<CTxDestination> > GetAddressGroupings();
map<CTxDestination, int64_t> GetAddressBalances();
set<CTxDestination> GetAccountAddresses(string strAccount) const;
bool IsMine(const CBaseTransaction*pTx) {
vector<CKeyID> vaddr;
if (!pTx->GetAddress(vaddr, *pAccountViewTip)) {
return false;
}
for (auto &keyid : vaddr) {
if (HaveKey(keyid)) {
return true;
}
}
return false;
}
bool GetRegID(const CKeyID &keyID, CRegID ®ID) {
if (mapKeyRegID.count(keyID)) {
regID = mapKeyRegID[keyID];
return true;
}
return false;
}
void SetBestChain(const CBlockLocator& loc);
void DelInvalidRegID();
DBErrors LoadWallet(bool& fFirstRunRet);
DBErrors ZapWalletTx();
bool SetAddressBook(const CTxDestination& address, const string& strName, const string& purpose);
bool DelAddressBook(const CTxDestination& address);
void UpdatedTransaction(const uint256 &hashTx);
void Inventory(const uint256 &hash) {
{
LOCK(cs_wallet);
map<uint256, int>::iterator mi = mapRequestCount.find(hash);
if (mi != mapRequestCount.end())
(*mi).second++;
}
}
unsigned int GetKeyPoolSize() {
AssertLockHeld(cs_wallet); // setKeyPool
return setKeyPool.size();
}
bool SetDefaultKey(const CPubKey &vchPubKey);
// signify that a particular wallet feature is now used. this may change nWalletVersion and nWalletMaxVersion if those are lower
bool SetMinVersion(enum WalletFeature, CWalletDB* pwalletdbIn = NULL, bool fExplicit = false);
// change which version we're allowed to upgrade to (note that this does not immediately imply upgrading to that format)
bool SetMaxVersion(int nVersion);
// get the current wallet format (the oldest client version guaranteed to understand this wallet)
int GetVersion() {
LOCK(cs_wallet);
return nWalletVersion;
}
bool CommitTransaction(CBaseTransaction *pTx);
/** Address book entry changed.
* @note called with lock cs_wallet held.
*/
boost::signals2::signal<
void(CWallet *wallet, const CTxDestination &address, const string &label, bool isMine,
const string &purpose, ChangeType status)> NotifyAddressBookChanged;
/** Wallet transaction added, removed or updated.
* @note called with lock cs_wallet held.
*/
boost::signals2::signal<void(CWallet *wallet, const uint256 &hashTx, ChangeType status)> NotifyTransactionChanged;
/** Show progress e.g. for rescan */
boost::signals2::signal<void(const string &title, int nProgress)> ShowProgress;
};
/** A key allocated from the key pool. */
class CReserveKey {
protected:
CWallet* pwallet;
int64_t nIndex;
CPubKey vchPubKey;
public:
CReserveKey(CWallet* pwalletIn) {
nIndex = -1;
pwallet = pwalletIn;
}
~CReserveKey() {
ReturnKey();
}
void ReturnKey();
bool GetReservedKey(CPubKey &pubkey);
void KeepKey();
};
typedef map<string, string> mapValue_t;
static void ReadOrderPos(int64_t& nOrderPos, mapValue_t& mapValue) {
if (!mapValue.count("n")) {
nOrderPos = -1; // TODO: calculate elsewhere
return;
}
nOrderPos = atoi64(mapValue["n"].c_str());
}
static void WriteOrderPos(const int64_t& nOrderPos, mapValue_t& mapValue) {
if (nOrderPos == -1)
return;
mapValue["n"] = i64tostr(nOrderPos);
}
/** Private key that includes an expiration date in case it never gets used. */
class CWalletKey {
public:
CPrivKey vchPrivKey;
int64_t nTimeCreated;
int64_t nTimeExpires;
string strComment;
//// todo: add something to note what created it (user, getnewaddress, change)
//// maybe should have a map<string, string> property map
CWalletKey(int64_t nExpires = 0) {
nTimeCreated = (nExpires ? GetTime() : 0);
nTimeExpires = nExpires;
}
IMPLEMENT_SERIALIZE
(
if (!(nType & SER_GETHASH))
READWRITE(nVersion);
READWRITE(vchPrivKey);
READWRITE(nTimeCreated);
READWRITE(nTimeExpires);
READWRITE(strComment);
)
};
/** Account information.
* Stored in wallet with key "acc"+string account name.
*/
class CAccount {
public:
CPubKey vchPubKey;
CAccount() {
SetNull();
}
void SetNull() {
vchPubKey = CPubKey();
}
IMPLEMENT_SERIALIZE
(
if (!(nType & SER_GETHASH))
READWRITE(nVersion);
READWRITE(vchPubKey);
)
};
/** Internal transfers.
* Database key is acentry<account><counter>.
*/
class CAccountingEntry {
public:
string strAccount;
int64_t nCreditDebit;
int64_t nTime;
string strOtherAccount;
string strComment;
mapValue_t mapValue;
int64_t nOrderPos; // position in ordered transaction list
uint64_t nEntryNo;
CAccountingEntry() {
SetNull();
}
void SetNull() {
nCreditDebit = 0;
nTime = 0;
strAccount.clear();
strOtherAccount.clear();
strComment.clear();
nOrderPos = -1;
}
IMPLEMENT_SERIALIZE
(
CAccountingEntry& me = *const_cast<CAccountingEntry*>(this);
if (!(nType & SER_GETHASH))
READWRITE(nVersion);
// Note: strAccount is serialized as part of the key, not here.
READWRITE(nCreditDebit);
READWRITE(nTime);
READWRITE(strOtherAccount);
if (!fRead)
{
WriteOrderPos(nOrderPos, me.mapValue);
if (!(mapValue.empty() && _ssExtra.empty()))
{
CDataStream ss(nType, nVersion);
ss.insert(ss.begin(), '\0');
ss << mapValue;
ss.insert(ss.end(), _ssExtra.begin(), _ssExtra.end());
me.strComment.append(ss.str());
}
}
READWRITE(strComment);
size_t nSepPos = strComment.find("\0", 0, 1);
if (fRead)
{
me.mapValue.clear();
if (string::npos != nSepPos)
{
CDataStream ss(vector<char>(strComment.begin() + nSepPos + 1, strComment.end()), nType, nVersion);
ss >> me.mapValue;
me._ssExtra = vector<char>(ss.begin(), ss.end());
}
ReadOrderPos(me.nOrderPos, me.mapValue);
}
if (string::npos != nSepPos)
me.strComment.erase(nSepPos);
me.mapValue.erase("n");
)
private:
vector<char> _ssExtra;
};
class CAccountTx {
private:
CWallet* pWallet;
public:
uint256 blockHash;
map<const uint256, std::shared_ptr<CBaseTransaction> > mapAccountTx;
public:
CAccountTx(CWallet* pwallet = NULL, uint256 hash = uint256(0)) {
pWallet = pwallet;
blockHash = hash;
mapAccountTx.clear();
}
~CAccountTx() {
}
void BindWallet(CWallet* pwallet) {
if (pWallet == NULL) {
assert(pwallet != NULL);
pWallet = pwallet;
}
}
bool AddTx(const uint256 &hash, const CBaseTransaction*pTx) {
switch (pTx->nTxType) {
case NORMAL_TX:
mapAccountTx[hash] = make_shared<CTransaction>(pTx);
break;
case REG_ACCT_TX:
mapAccountTx[hash] = make_shared<CRegisterAccountTx>(pTx);
break;
case APPEAL_TX:
mapAccountTx[hash] = make_shared<CAppealTransaction>(pTx);
break;
case SECURE_TX:
mapAccountTx[hash] = make_shared<CSecureTransaction>(pTx);
break;
case FREEZE_TX:
mapAccountTx[hash] = make_shared<CFreezeTransaction>(pTx);
break;
case REWARD_TX:
mapAccountTx[hash] = make_shared<CRewardTransaction>(pTx);
break;
case REG_SCRIPT_TX:
mapAccountTx[hash] = make_shared<CRegistScriptTx>(pTx);
default:
return false;
break;
}
return true;
}
bool HaveTx(const uint256 &hash) {
if (mapAccountTx.end() != mapAccountTx.find(hash)) {
return true;
}
return false;
}
bool DelTx(const uint256 &hash) {
return mapAccountTx.erase(hash);
}
size_t GetTxSize() {
return mapAccountTx.size();
}
bool AcceptToMemoryPool() {
vector<uint256> vhash;
for (auto& item : mapAccountTx) {
const uint256& txid = item.first;
CValidationState state;
if (item.second->nTxType != REWARD_TX) {
if (!::AcceptToMemoryPool(mempool, state, const_cast<CBaseTransaction*>(item.second.get()), false, NULL,
false)) {
vhash.push_back(item.first);
}
}
else
{
vhash.push_back(item.first);
}
}
for (auto hash : vhash){
mapAccountTx.erase(hash);
}
return true;
}
void RelayWalletTransaction() {
for (auto& item : mapAccountTx) {
if (item.second->nTxType != REWARD_TX) {
::RelayTransaction(const_cast<CBaseTransaction*>(item.second.get()), item.first);
}
}
}
bool WriteToDisk() {
return CWalletDB(pWallet->strWalletFile).WriteAccountTx(blockHash, *this);
}
unsigned int GetSerializeSize(int nType, int nVersion) const {
return 0;
}
template<typename Stream>
void Serialize(Stream& s, int nType, int nVersion) const {
CSerActionSerialize ser_action;
unsigned int nSerSize = 0;
READWRITE(blockHash);
for (const auto& item : mapAccountTx) {
READWRITE(item.second->nTxType);
READWRITE(item.first);
switch (item.second->nTxType) {
case NORMAL_TX:
READWRITE(*((CTransaction* )item.second.get()));
break;
case REG_ACCT_TX:
READWRITE(*((CRegisterAccountTx* )item.second.get()));
break;
case APPEAL_TX:
READWRITE(*((CAppealTransaction* )item.second.get()));
break;
case SECURE_TX:
READWRITE(*((CSecureTransaction* )item.second.get()));
break;
case FREEZE_TX:
READWRITE(*((CFreezeTransaction* )item.second.get()));
break;
case REWARD_TX:
READWRITE(*((CRewardTransaction* )item.second.get()));
break;
case REG_SCRIPT_TX:
READWRITE(*((CRegistScriptTx* )item.second.get()));
break;
default:
break;
}
}
unsigned char txtype = NULL_TX;
READWRITE(txtype);
}
template<typename Stream>
void Unserialize(Stream& s, int nType, int nVersion) {
CSerActionUnserialize ser_action;
unsigned int nSerSize = 0;
READWRITE(blockHash);
unsigned char txtype = 0;
uint256 hash;
READWRITE(txtype);
while (txtype != NULL_TX) {
READWRITE(hash);
switch (txtype) {
case NORMAL_TX:
{
CTransaction tx;
READWRITE(tx);
AddTx(hash, (CBaseTransaction*) &tx);
}
break;
case REG_ACCT_TX:
{
CRegisterAccountTx tx;
READWRITE(tx);
AddTx(hash, (CBaseTransaction*) &tx);
}
break;
case APPEAL_TX: {
CAppealTransaction tx;
READWRITE(tx);
AddTx(hash, (CBaseTransaction*) &tx);
}
break;
case SECURE_TX:
{
CSecureTransaction tx;
READWRITE(tx);
AddTx(hash, (CBaseTransaction*) &tx);
}
break;
case FREEZE_TX:
{
CFreezeTransaction tx;
READWRITE(tx);
AddTx(hash, (CBaseTransaction*) &tx);
}
break;
case REWARD_TX:
{
CRewardTransaction tx;
READWRITE(tx);
AddTx(hash, (CBaseTransaction*) &tx);
}
break;
case REG_SCRIPT_TX:
{
CRegistScriptTx tx;
READWRITE(tx);
AddTx(hash, (CBaseTransaction*) &tx);
}
break;
default:
break;
}
READWRITE(txtype);
}
}
};
#endif
| [
"240401736@QQ.COM"
] | 240401736@QQ.COM |
b2604a481b8d90d9b041a1044259b7cb03f9dfa7 | 0a15cb3f5c67a607f315cb5860eca9a450f87b34 | /hardware/xmegaduino/variants/sfe/serial_init.cpp | 89d04d180f42b150aebf40809b81e4960659a62b | [] | no_license | intelligent-lighting-institute/lithne-ide | 8af3ff095eba66a37d04391c4141d3b1dac284cd | e31910b2f3b1f5f50d63aa018fb3f681ecc84574 | refs/heads/master | 2021-01-22T05:01:28.515231 | 2013-07-16T11:08:51 | 2013-07-16T11:08:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,586 | cpp | /*
serial_init.cpp - Initialize serial ports for Arduino
Part of Arduino - http://www.arduino.cc/
Copyright (c) 2011 Karl Backstroem
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General
Public License along with this library; if not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330,
Boston, MA 02111-1307 USA
*/
// Preinstantiate Objects //////////////////////////////////////////////////////
#define SERIAL_DEFINE(name, usart_port, port_nr) \
ring_buffer name##rx_buffer = { { 0 }, 0, 0 }; \
ISR(USART##usart_port##port_nr##_RXC_vect) \
{ \
unsigned char c = USART##usart_port##port_nr.DATA; \
store_char(c, &name##rx_buffer); \
} \
HardwareSerial name (&name##rx_buffer, &USART##usart_port##port_nr, &PORT##usart_port, (port_nr ? PIN6_bm : PIN2_bm), (port_nr ? PIN7_bm : PIN3_bm));
SERIAL_DEFINE(Serial, C, 0);
SERIAL_DEFINE(Serial1, C, 1);
SERIAL_DEFINE(Serial2, D, 0);
SERIAL_DEFINE(Serial3, D, 1);
SERIAL_DEFINE(Serial4, E, 0);
SERIAL_DEFINE(Serial5, E, 1);
SERIAL_DEFINE(Serial6, F, 0);
SERIAL_DEFINE(Serial7, F, 1);
| [
"elcojacobs@gmail.com"
] | elcojacobs@gmail.com |
dfcb9e22f6de1f82bc6dcd45133047ddf9507b81 | a077fe6ab6eeec48522396d95c204453cc7525b2 | /Source/Event/Listener.cpp | 274423cf4f1747ea539d40f1c4e859538499104a | [
"MIT"
] | permissive | youZhuang/Dorothy-SSR | f406964122a14d45b4e63baa141afe27c5761fda | 700bc497cf69e3bb3a873096d5fc3d293a489863 | refs/heads/master | 2023-03-31T09:41:52.904792 | 2021-03-22T15:08:59 | 2021-03-22T15:08:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,000 | cpp | /* Copyright (c) 2021 Jin Li, http://www.luvfight.me
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 "Const/Header.h"
#include "Event/Event.h"
#include "Event/Listener.h"
NS_DOROTHY_BEGIN
bool Listener::init()
{
if (!Object::init()) return false;
Listener::setEnabled(true);
return true;
}
void Listener::setEnabled( bool enable )
{
if (enable)
{
Event::reg(this);
}
else
{
Event::unreg(this);
}
}
bool Listener::isEnabled() const
{
return _enabled;
}
void Listener::setHandler( const EventHandler& handler )
{
_handler = handler;
}
const EventHandler& Listener::getHandler() const
{
return _handler;
}
void Listener::clearHandler()
{
_handler.Clear();
}
void Listener::handle( Event* e )
{
if (_handler)
{
_handler(e);
}
}
Listener::Listener( const string& name, const EventHandler& handler ):
_name(name),
_handler(handler),
_enabled(false)
{ }
const string& Listener::getName() const
{
return _name;
}
Listener::~Listener()
{
Listener::setEnabled(false);
}
NS_DOROTHY_END
| [
"dragon-fly@qq.com"
] | dragon-fly@qq.com |
dc52d8abcc0b17cea74eb33250a3b9060c3fa232 | 069832c21c56ced036d4f6143d9b2b9017d5a918 | /cpp/P101.cpp | b113efb5bb41bf0b0b0cfecdcc580b68ccdcc25f | [] | no_license | Traeyee/leetcode | 1f3c3ac5cb6ba2531454ba012cb5cb2fccedb076 | 9c2cfc12375e09650c9a48bcfd170dbfca0dcc9c | refs/heads/master | 2022-05-07T04:01:06.163792 | 2022-03-08T01:44:03 | 2022-03-08T01:44:03 | 235,553,066 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,223 | cpp | /**
* @author cuiyiwork@foxmail.com
* @time 2021-11-17 19:37
* @brief
*/
#include <algorithm>
#include <climits>
#include <iostream>
#include <queue>
#include <random>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode() : val(0), left(nullptr), right(nullptr) {}
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
TreeNode(int x, TreeNode *left, TreeNode *right)
: val(x), left(left), right(right) {}
};
class Solution {
public:
bool isSymmetric(TreeNode *left, TreeNode *right) {
if (nullptr == left && nullptr == right) {
return true;
}
if (nullptr == left || nullptr == right) {
return false;
}
if (left->val != right->val) {
return false;
}
return isSymmetric(left->left, right->right) && isSymmetric(left->right, right->left);
}
bool isSymmetric(TreeNode *root) {
if (!root) {
return true;
}
return isSymmetric(root->left, root->right);
}
};
| [
"dz-00048@163.com"
] | dz-00048@163.com |
14a845b5e54fbd83be2fd79b521ad08dddee914e | 4851256b3d2f07e61ea6ae5d2bc13281fd257c7f | /src/webnn_native/ops/Clamp.h | 62402aeae0589e8c1e55ed7c321dcf04124e92fc | [
"BSD-3-Clause",
"MIT",
"Apache-2.0",
"Unlicense",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | MarkGHX/webnn-native | 61b0ba4a8b7b0161b19093e548d76e0d4cac7805 | e8738a47319b7ffe67206cd9093b241e31b87f89 | refs/heads/main | 2023-07-02T20:05:00.827471 | 2021-07-27T00:08:28 | 2021-07-27T00:08:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,339 | h | // Copyright 2021 The WebNN-native Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef WEBNN_NATIVE_OPS_CLAMP_H_
#define WEBNN_NATIVE_OPS_CLAMP_H_
#include "webnn_native/Graph.h"
#include "webnn_native/Operand.h"
#include "webnn_native/ops/Constant.h"
namespace webnn_native { namespace op {
class Clamp final : public OperandBase {
public:
Clamp(GraphBuilderBase* builder, OperandBase* input, ClampOptions const* options);
~Clamp() override = default;
MaybeError AddToGraph(GraphBase* graph) const override {
return graph->AddClamp(this);
}
ClampOptions const* GetOptions() const {
return &mOptions;
}
private:
ClampOptions mOptions;
};
}} // namespace webnn_native::op
#endif // WEBNN_NATIVE_OPS_CLAMP_H_ | [
"junwei.fu@intel.com"
] | junwei.fu@intel.com |
ee3d1cf80abf149e6b42fa06aa670f8814d840b5 | f0923ceb7f73de7d9d01e0a28140629f7d38764d | /src/client/Interface/DLGs/CharacterDLG.h | d847e9a5e617c39ef2bf9555c1c750a8cade835b | [] | no_license | uvbs/rose-137 | 95b1ca3ecf5ff4dc80a4a371c35c4090df8fde5a | 78d886fc63b095e962727b35e6b31774ce16c576 | refs/heads/master | 2020-03-18T09:45:22.464847 | 2018-04-02T22:20:48 | 2018-04-02T22:20:48 | 134,579,008 | 1 | 0 | null | 2018-05-23T14:07:39 | 2018-05-23T14:07:39 | null | UHC | C++ | false | false | 2,190 | h |
#ifndef _CHARACTER_DLG_H
#define _CHARACTER_DLG_H
#include "tgamectrl/TDialog.h"
#include "Common/CItem.h"
#include "Common/DataType.h"
/**
* 캐릭터 정보를 보여주기 위한 다이얼로그
*
* @Warning 현재(2005/9/12) 대만(New)버젼에는 조합 정보를 보여주지 않는다( XML에서 탭버튼을 없애서 탭을 이동할수 없도록 되어 있다 )
* @Author 최종진
* @Date 2005/9/12
*/
class CCharacterDLG : public CTDialog
{
public:
CCharacterDLG( int iType );
virtual ~CCharacterDLG();
virtual void Draw();
virtual unsigned int Process(UINT uiMsg,WPARAM wParam,LPARAM lParam);
virtual void Update( POINT ptMouse );
virtual bool IsVision();
virtual bool Create( const char* IDD );
virtual void Show();
enum{
IID_BTN_CLOSE = 10,
IID_BTN_DIALOG2ICON,
IID_TABBEDPANE = 20,
IID_TAB_BASICINFO = 21,
IID_TAB_BASICINFO_BG,
IID_TAB_BASICINFO_BTN,
IID_GUAGE_STAMINA = 24,
IID_TAB_ABILITY = 31,
IID_TAB_ABILITY_BG,
IID_TAB_ABILITY_BTN,
IID_BTN_UP_STR,
IID_BTN_UP_DEX,
IID_BTN_UP_INT,
IID_BTN_UP_CON,
IID_BTN_UP_CHARM,
IID_BTN_UP_SENSE,
IID_TAB_UNION = 41,
IID_TAB_UNION_BG,
IID_TAB_UNION_BTN,
IID_TXT_REQ_STR = 100,
IID_TXT_REQ_DEX,
IID_TXT_REQ_INT,
IID_TXT_REQ_CON,
IID_TXT_REQ_CRM,
IID_TXT_REQ_SEN,
};
protected:
enum{
IID_TABABLITY = 0,
IID_TABUNION = 1,
IID_TABBASIC = 2
};
enum{
BASIC_INFO,
ABILITY_INFO,
UNION_INFO
};
bool On_LButtonUP( unsigned iProcID, WPARAM wParam, LPARAM lParam );
bool On_LButtonDN( unsigned iProcID, WPARAM wParam, LPARAM lParam );
void DrawBasicInfo(); /// 기본정보 Draw
void DrawAbilityInfo(); /// 능력치 Draw
void DrawUnionInfo(); /// 조합정보 Draw
void DrawBasicInfo2(); /// 기본정보 Draw
void DrawAbilityInfo2(); /// 능력치 Draw
void DrawUnionInfo2(); /// 조합정보 Draw
void SetInterfacePos_After();
private:
int m_iTab; /// 탭구분
int m_iGuageBlueGID; /// 마나 게이지의 그래픽 ID
int m_iGuageYellowGID; /// 스테미나 게이지의 그래픽 ID
int m_iGuageRedGID; /// 체력 게이지의 그래픽 ID
};
#endif
| [
"ralphminderhoud@gmail.com"
] | ralphminderhoud@gmail.com |
3759f6f8d041cda9d6c9a8edbd4abcc35866b729 | 7c105b8d2c2dcf781292d47b0f464430e3028905 | /problemset/PAT/Advanced Level/1127_liu.cpp | 2d31f08475fef199ea4a63390eacf229560306b4 | [] | no_license | jiafeimao-gjf/BasicKnowledgeofCS | e0b751452c647aa068283a56640a06b58421a15f | 49e4d80a7f1a0e9924b491f5e7dbe8ff6c84c02f | refs/heads/master | 2023-07-06T14:07:40.552273 | 2023-07-02T04:59:28 | 2023-07-02T04:59:28 | 181,401,725 | 2 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,715 | cpp | #include <iostream>
#include <vector>
#include <queue>
using namespace std;
vector<int> in,post;//中序遍历和后序遍历序列
vector<int> result[35];//存储每一层的从左至右的序列
int n,tree[35][2],root;
struct node{//记录对应节点的深度
int index,depth;
};
void dfs(int &index,int inLeft,int inRight,int postLeft,int postRight){//递归建树
if(inLeft > inRight) return;
index = postRight;//后序的根在右侧
int i = inLeft;//为什么从0开始？而不是从inLeft
while(in[i] != post[postRight]) i++;
dfs(tree[index][0],inLeft,i - 1,postLeft,postLeft + (i - inLeft) - 1);//左子树递归
dfs(tree[index][1],i + 1,inRight,postLeft + (i - inLeft),postRight - 1);
}
void bfs(){//层序遍历
queue<node> q;
q.push(node{root, 0});
while(!q.empty()){
node temp = q.front(); //获得队首元素
q.pop();
result[temp.depth].push_back(post[temp.index]);//按从左至右的顺序存储对应层次的节点
if(tree[temp.index][0] != 0)//左子树非空，入队
q.push(node{tree[temp.index][0],temp.depth + 1});
if(tree[temp.index][1] != 0)//右子树非空，入队
q.push(node{tree[temp.index][1],temp.depth + 1});
}
}
int main(){
cin>>n;
in.resize(n + 1);post.resize(n + 1);
for(int i = 1;i <= n; i++) cin >> in[i];
for(int i = 1;i <= n; i++) cin >> post[i];
dfs(root,1,n,1,n);
bfs();
printf("%d",result[0][0]);//第一层只有一个根节点
for(int i = 1;i < 35; i++){
if(i % 2 == 1){//奇数层从左至右
for(int j = 0;j < result[i].size(); j++){
printf(" %d",result[i][j]);
}
}else{//偶数层从右至左
for(int j = result[i].size() - 1;j >= 0; j--){
printf(" %d",result[i][j]);
}
}
}
return 0;
}
| [
"1056615746@qq.com"
] | 1056615746@qq.com |
9ab6a0acf3f10c990abecb4336f573b800666a64 | efb8e56bc080a7345730def3215e3cdd5ba15022 | /labos1/AbstractMatrix.h | 406560662b421e49ddd765882112f546d76f92b7 | [] | no_license | msantl/IRG | 6926c61a375d5e008a80119a270384778c73a92b | d8547c84a2a5bad61478f9a714d44f86d313f475 | refs/heads/master | 2021-01-22T02:34:06.827273 | 2013-06-11T18:54:55 | 2013-06-11T18:54:55 | 8,833,042 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 574 | h | #ifndef ABSTRACTMATRIX_H
#define ABSTRACTMATRIX_H
#include "IRG.h"
#include "IMatrix.h"
#include "IVector.h"
#include <string>
class AbstractMatrix : virtual public IMatrix {
public:
AbstractMatrix();
IMatrix* nTranspose(bool);
IMatrix* add(IMatrix*);
IMatrix* nAdd(IMatrix*);
IMatrix* sub(IMatrix*);
IMatrix* nSub(IMatrix*);
IMatrix* nMultiply(IMatrix*);
double determinant();
IMatrix* subMatrix(int, int, bool);
IMatrix* nInvert();
double* toArray();
std::string toString();
IVector* toVector(bool);
};
#endif
| [
"msantl.ck@gmail.com"
] | msantl.ck@gmail.com |
7c6a4fb1ce7f45407812c847f55a2627d04446eb | dde05d28d2bf8cabbf8100e9d06df2bdaccd836b | /ReferenceVariables/Swap_Val_Ref_Ptr.cpp | 42e7565cc57ce1f6123faadfadfa758b9023c239 | [] | no_license | omkarlanghe/c_Plus_Plus | f548e6a841b8b4540157073b7b560439157233ac | a068d8307d2d2f6efc2199e782b1f00a2ab4b15c | refs/heads/master | 2021-07-14T08:29:18.054815 | 2021-06-19T12:53:02 | 2021-06-19T12:53:02 | 141,000,577 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 654 | cpp | #include<iostream>
int SwapByValue(int a, int b)
{
int temp = a;
a = b;
b = temp;
}
int SwapByPointers(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
int SwapByReference(int &a, int &b)
{
int temp = a;
a = b;
b = temp;
}
int main()
{
int a = 10, b = 20;
std::cout<<"Before Swapping"<<std::endl;
std::cout<<"a = "<<a<<" : "<<"b = "<<b<<std::endl;
std::cout<<"After Swapping"<<std::endl;
SwapByValue(a,b);
std::cout<<"a = "<<a<<" : "<<"b = "<<b<<std::endl;
SwapByPointers(&a,&b);
std::cout<<"a = "<<a<<" : "<<"b = "<<b<<std::endl;
SwapByReference(a,b);
std::cout<<"a = "<<a<<" : "<<"b = "<<b<<std::endl;
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
6dd0626745a1d7d7397166022ae41a520cd68e9d | 184180d341d2928ab7c5a626d94f2a9863726c65 | /issuestests/SpatialEpi/inst/testfiles/return_death_moves/return_death_moves_DeepState_TestHarness.cpp | b7de2d2e6ec2a37f0de91aa8e1764f4c0948a246 | [] | no_license | akhikolla/RcppDeepStateTest | f102ddf03a22b0fc05e02239d53405c8977cbc2b | 97e73fe4f8cb0f8e5415f52a2474c8bc322bbbe5 | refs/heads/master | 2023-03-03T12:19:31.725234 | 2021-02-12T21:50:12 | 2021-02-12T21:50:12 | 254,214,504 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 775 | cpp | #include <fstream>
#include <RInside.h>
#include <iostream>
#include <RcppDeepState.h>
#include <qs.h>
#include <DeepState.hpp>
NumericMatrix return_death_moves(NumericVector theta);
TEST(SpatialEpi_deepstate_test,return_death_moves_test){
RInside R;
std::cout << "input starts" << std::endl;
NumericVector theta = RcppDeepState_NumericVector();
qs::c_qsave(theta,"/home/akhila/R/x86_64-pc-linux-gnu-library/3.6/RcppDeepState/extdata/issuestests/SpatialEpi/inst/testfiles/return_death_moves/inputs/theta.qs",
"high", "zstd", 1, 15, true, 1);
std::cout << "theta values: "<< theta << std::endl;
std::cout << "input ends" << std::endl;
try{
return_death_moves(theta);
}
catch(Rcpp::exception& e){
std::cout<<"Exception Handled"<<std::endl;
}
}
| [
"akhilakollasrinu424jf@gmail.com"
] | akhilakollasrinu424jf@gmail.com |
84151dd97d91c41010f804a09c682b2e97403a1e | 0d4b2b82792c277187655ad5af6f95acd5c87c1e | /Problems/800/1385B.cpp | 684aca14030b5e2aeb3345a23d575dec30b08f43 | [] | no_license | OfficialMartian/codeforces | 6cde8a74571316aff62456d33837a6bbcb32f29c | dd647cbd24a42ec3778f2df6a307542acb66d5bd | refs/heads/master | 2023-08-20T03:37:21.599786 | 2021-10-31T15:51:30 | 2021-10-31T15:51:30 | 377,887,760 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 557 | cpp | typedef long long int ll;
#define push_back pb
#include <bits/stdc++.h>
using namespace std;
int main()
{
int t;
cin >> t;
while (t--)
{
int n, temp;
vector<int> V;
map<int, int> a;
cin >> n;
for (int i = 0; i < 2 * n; ++i)
{
cin >> temp;
if (a[temp] == 0)
{
a[temp]++;
V.pb(temp);
}
}
for (int i = 0; i < V.size(); ++i)
cout << V[i] << " ";
cout << endl;
}
return 0;
} | [
"caraj0503@gmail.com"
] | caraj0503@gmail.com |
b3d93950a3f4338c90f0e2ce82a4df5d5251c5d8 | c708d04689d7baad2a9077ee76cfb1ed1e955f25 | /runtime/dart_isolate.h | de006125f03be138435e98d9bb278855d25a2c4b | [
"BSD-3-Clause"
] | permissive | Piinks/engine | 0cdc62979169a5425e398adeffea96d46591da1d | 04b04518565ef18b3197a63a1a3407f84527b9a3 | refs/heads/master | 2023-08-22T14:26:29.627064 | 2021-03-15T21:28:01 | 2021-03-15T21:28:01 | 348,140,618 | 1 | 0 | BSD-3-Clause | 2021-03-15T22:29:08 | 2021-03-15T22:29:08 | null | UTF-8 | C++ | false | false | 26,834 | h | // Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef FLUTTER_RUNTIME_DART_ISOLATE_H_
#define FLUTTER_RUNTIME_DART_ISOLATE_H_
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <unordered_set>
#include "flutter/common/task_runners.h"
#include "flutter/fml/compiler_specific.h"
#include "flutter/fml/macros.h"
#include "flutter/fml/mapping.h"
#include "flutter/lib/ui/hint_freed_delegate.h"
#include "flutter/lib/ui/io_manager.h"
#include "flutter/lib/ui/snapshot_delegate.h"
#include "flutter/lib/ui/ui_dart_state.h"
#include "flutter/lib/ui/window/platform_configuration.h"
#include "flutter/runtime/dart_snapshot.h"
#include "third_party/dart/runtime/include/dart_api.h"
#include "third_party/tonic/dart_state.h"
namespace flutter {
class DartVM;
class DartIsolateGroupData;
class IsolateConfiguration;
//------------------------------------------------------------------------------
/// @brief Represents an instance of a live isolate. An isolate is a
/// separate Dart execution context. Different Dart isolates don't
/// share memory and can be scheduled concurrently by the Dart VM on
/// one of the Dart VM managed worker pool threads.
///
/// The entire lifecycle of a Dart isolate is controlled by the Dart
/// VM. Because of this, the engine never holds a strong pointer to
/// the Dart VM for extended periods of time. This allows the VM (or
/// the isolates themselves) to terminate Dart execution without
/// consulting the engine.
///
/// The isolate that the engine creates to act as the host for the
/// Flutter application code with UI bindings is called the root
/// isolate.
///
/// The root isolate is special in the following ways:
/// * The root isolate forms a new isolate group. Child isolates are
/// added to their parents groups. When the root isolate dies, all
/// isolates in its group are terminated.
/// * Only root isolates get UI bindings.
/// * Root isolates execute their code on engine managed threads.
/// All other isolates run their Dart code on Dart VM managed
/// thread pool workers that the engine has no control over.
/// * Since the engine does not know the thread on which non-root
/// isolates are run, the engine has no opportunity to get a
/// reference to non-root isolates. Such isolates can only be
/// terminated if they terminate themselves or their isolate group
/// is torn down.
///
class DartIsolate : public UIDartState {
public:
class Flags {
public:
Flags();
explicit Flags(const Dart_IsolateFlags* flags);
~Flags();
void SetNullSafetyEnabled(bool enabled);
Dart_IsolateFlags Get() const;
private:
Dart_IsolateFlags flags_;
};
//----------------------------------------------------------------------------
/// @brief The engine represents all dart isolates as being in one of the
/// known phases. By invoking various methods on the Dart isolate,
/// the engine transition the Dart isolate from one phase to the
/// next. The Dart isolate will only move from one phase to the
/// next in the order specified in the `DartIsolate::Phase` enum.
/// That is, once the isolate has moved out of a particular phase,
/// it can never transition back to that phase in the future.
/// There is no error recovery mechanism and callers that find
/// their isolates in an undesirable phase must discard the
/// isolate and start over.
///
enum class Phase {
//--------------------------------------------------------------------------
/// The initial phase of all Dart isolates. This is an internal phase and
/// callers can never get a reference to a Dart isolate in this phase.
///
Unknown,
//--------------------------------------------------------------------------
/// The Dart isolate has been created but none of the library tag or message
/// handers have been set yet. The is an internal phase and callers can
/// never get a reference to a Dart isolate in this phase.
///
Uninitialized,
//--------------------------------------------------------------------------
/// The Dart isolate has been been fully initialized but none of the
/// libraries referenced by that isolate have been loaded yet. This is an
/// internal phase and callers can never get a reference to a Dart isolate
/// in this phase.
///
Initialized,
//--------------------------------------------------------------------------
/// The isolate has been fully initialized and is waiting for the caller to
/// associate isolate snapshots with the same. The isolate will only be
/// ready to execute Dart code once one of the `Prepare` calls are
/// successfully made.
///
LibrariesSetup,
//--------------------------------------------------------------------------
/// The isolate is fully ready to start running Dart code. Callers can
/// transition the isolate to the next state by calling the `Run` or
/// `RunFromLibrary` methods.
///
Ready,
//--------------------------------------------------------------------------
/// The isolate is currently running Dart code.
///
Running,
//--------------------------------------------------------------------------
/// The isolate is no longer running Dart code and is in the middle of being
/// collected. This is in internal phase and callers can never get a
/// reference to a Dart isolate in this phase.
///
Shutdown,
};
//----------------------------------------------------------------------------
/// @brief Creates an instance of a root isolate and returns a weak
/// pointer to the same. The isolate instance may only be used
/// safely on the engine thread on which it was created. In the
/// shell, this is the UI thread and task runner. Using the
/// isolate on any other thread is user error.
///
/// The isolate that the engine creates to act as the host for the
/// Flutter application code with UI bindings is called the root
/// isolate.
///
/// The root isolate is special in the following ways:
/// * The root isolate forms a new isolate group. Child isolates
/// are added to their parents groups. When the root isolate
/// dies, all isolates in its group are terminated.
/// * Only root isolates get UI bindings.
/// * Root isolates execute their code on engine managed threads.
/// All other isolates run their Dart code on Dart VM managed
/// thread pool workers that the engine has no control over.
/// * Since the engine does not know the thread on which non-root
/// isolates are run, the engine has no opportunity to get a
/// reference to non-root isolates. Such isolates can only be
/// terminated if they terminate themselves or their isolate
/// group is torn down.
///
/// @param[in] settings The settings used to create the
/// isolate.
/// @param[in] isolate_snapshot The isolate snapshot. This is
/// usually obtained from the
/// DartVMData associated with the
/// running Dart VM instance.
/// @param[in] task_runners The task runners used by the
/// isolate. Via UI bindings, the
/// isolate will use the IO task
/// runner to scheduled texture
/// decompression jobs and post tasks
/// back to the UI task runner.
/// @param[in] window The weak pointer to the window
/// associated with this root isolate.
/// @param[in] io_manager The i/o manager.
/// @param[in] unref_queue The Skia unref queue.
/// @param[in] image_decoder The image decoder.
/// @param[in] advisory_script_uri The advisory script uri. This is
/// only used in instrumentation.
/// @param[in] advisory_script_entrypoint The advisory script entrypoint.
/// This is only used in
/// instrumentation. Notably, this is
/// NOT the main entrypoint of Dart
/// code in the isolate. That is
/// specified when making one of the
/// `Run` calls.
/// @param[in] flags The Dart isolate flags for this
/// isolate instance.
/// @param[in] isolate_create_callback The isolate create callback. This
/// will be called when the before the
/// main Dart entrypoint is invoked in
/// the root isolate. The isolate is
/// already in the running state at
/// this point and an isolate scope is
/// current. This callback is made for
/// all isolate launches (including
/// the children of the root isolate).
/// @param[in] isolate_shutdown_callback The isolate shutdown callback.
/// This will be called before the
/// isolate is about to transition
/// into the Shutdown phase. The
/// isolate is still running at this
/// point and an isolate scope is
/// current. This callback is made
/// for all isolate shutdowns
/// (including the children of the
/// root isolate).
/// @param[in] spawning_isolate The isolate that is spawning the
/// new isolate. See also
/// DartIsolate::SpawnIsolate.
/// @return A weak pointer to the root Dart isolate. The caller must
/// ensure that the isolate is not referenced for long periods of
/// time as it prevents isolate collection when the isolate
/// terminates itself. The caller may also only use the isolate on
/// the thread on which the isolate was created.
///
static std::weak_ptr<DartIsolate> CreateRunningRootIsolate(
const Settings& settings,
fml::RefPtr<const DartSnapshot> isolate_snapshot,
TaskRunners task_runners,
std::unique_ptr<PlatformConfiguration> platform_configuration,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::WeakPtr<HintFreedDelegate> hint_freed_delegate,
fml::WeakPtr<IOManager> io_manager,
fml::RefPtr<SkiaUnrefQueue> skia_unref_queue,
fml::WeakPtr<ImageDecoder> image_decoder,
std::string advisory_script_uri,
std::string advisory_script_entrypoint,
Flags flags,
const fml::closure& isolate_create_callback,
const fml::closure& isolate_shutdown_callback,
std::optional<std::string> dart_entrypoint,
std::optional<std::string> dart_entrypoint_library,
std::unique_ptr<IsolateConfiguration> isolate_configration,
std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
const DartIsolate* spawning_isolate = nullptr);
//----------------------------------------------------------------------------
/// @brief Creates a running DartIsolate who shares as many resources as
/// possible with the caller DartIsolate. This allows them to
/// occupy less memory together and to be created faster.
/// @details Shared components will be destroyed when the last live
/// DartIsolate is destroyed. SpawnIsolate can only be used to
/// create DartIsolates whose executable code is shared with the
/// calling DartIsolate.
/// @attention Only certain setups can take advantage of the most savings
/// currently, AOT specifically.
/// @return A weak pointer to a new running DartIsolate. The caller must
/// ensure that the isolate is not referenced for long periods of
/// time as it prevents isolate collection when the isolate
/// terminates itself. The caller may also only use the isolate on
/// the thread on which the isolate was created.
std::weak_ptr<DartIsolate> SpawnIsolate(
const Settings& settings,
std::unique_ptr<PlatformConfiguration> platform_configuration,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::WeakPtr<HintFreedDelegate> hint_freed_delegate,
std::string advisory_script_uri,
std::string advisory_script_entrypoint,
Flags flags,
const fml::closure& isolate_create_callback,
const fml::closure& isolate_shutdown_callback,
std::optional<std::string> dart_entrypoint,
std::optional<std::string> dart_entrypoint_library,
std::unique_ptr<IsolateConfiguration> isolate_configration) const;
// |UIDartState|
~DartIsolate() override;
//----------------------------------------------------------------------------
/// @brief The current phase of the isolate. The engine represents all
/// dart isolates as being in one of the known phases. By invoking
/// various methods on the Dart isolate, the engine transitions
/// the Dart isolate from one phase to the next. The Dart isolate
/// will only move from one phase to the next in the order
/// specified in the `DartIsolate::Phase` enum. That is, the once
/// the isolate has moved out of a particular phase, it can never
/// transition back to that phase in the future. There is no error
/// recovery mechanism and callers that find their isolates in an
/// undesirable phase must discard the isolate and start over.
///
/// @return The current isolate phase.
///
Phase GetPhase() const;
//----------------------------------------------------------------------------
/// @brief Returns the ID for an isolate which is used to query the
/// service protocol.
///
/// @return The service identifier for this isolate.
///
std::string GetServiceId();
//----------------------------------------------------------------------------
/// @brief Prepare the isolate for running for a precompiled code bundle.
/// The Dart VM must be configured for running precompiled code.
///
/// The isolate must already be in the `Phase::LibrariesSetup`
/// phase. After a successful call to this method, the isolate
/// will transition to the `Phase::Ready` phase.
///
/// @return Whether the isolate was prepared and the described phase
/// transition made.
///
[[nodiscard]] bool PrepareForRunningFromPrecompiledCode();
//----------------------------------------------------------------------------
/// @brief Prepare the isolate for running for a a list of kernel files.
///
/// The Dart VM must be configured for running from kernel
/// snapshots.
///
/// The isolate must already be in the `Phase::LibrariesSetup`
/// phase. This call can be made multiple times. After a series of
/// successful calls to this method, the caller can specify the
/// last kernel file mapping by specifying `last_piece` to `true`.
/// On success, the isolate will transition to the `Phase::Ready`
/// phase.
///
/// @param[in] kernel The kernel mapping.
/// @param[in] last_piece Indicates if this is the last kernel mapping
/// expected. After this point, the isolate will
/// attempt a transition to the `Phase::Ready` phase.
///
/// @return If the kernel mapping supplied was successfully used to
/// prepare the isolate.
///
[[nodiscard]] bool PrepareForRunningFromKernel(
std::shared_ptr<const fml::Mapping> kernel,
bool last_piece = true);
//----------------------------------------------------------------------------
/// @brief Prepare the isolate for running for a a list of kernel files.
///
/// The Dart VM must be configured for running from kernel
/// snapshots.
///
/// The isolate must already be in the `Phase::LibrariesSetup`
/// phase. After a successful call to this method, the isolate
/// will transition to the `Phase::Ready` phase.
///
/// @param[in] kernels The kernels
///
/// @return If the kernel mappings supplied were successfully used to
/// prepare the isolate.
///
[[nodiscard]] bool PrepareForRunningFromKernels(
std::vector<std::shared_ptr<const fml::Mapping>> kernels);
//----------------------------------------------------------------------------
/// @brief Prepare the isolate for running for a a list of kernel files.
///
/// The Dart VM must be configured for running from kernel
/// snapshots.
///
/// The isolate must already be in the `Phase::LibrariesSetup`
/// phase. After a successful call to this method, the isolate
/// will transition to the `Phase::Ready` phase.
///
/// @param[in] kernels The kernels
///
/// @return If the kernel mappings supplied were successfully used to
/// prepare the isolate.
///
[[nodiscard]] bool PrepareForRunningFromKernels(
std::vector<std::unique_ptr<const fml::Mapping>> kernels);
//----------------------------------------------------------------------------
/// @brief Transition the root isolate to the `Phase::Running` phase and
/// invoke the main entrypoint (the "main" method) in the
/// specified library. The isolate must already be in the
/// `Phase::Ready` phase.
///
/// @param[in] library_name The name of the library in which to invoke the
/// supplied entrypoint.
/// @param[in] entrypoint The entrypoint in `library_name`
/// @param[in] args A list of string arguments to the entrypoint.
///
/// @return If the isolate successfully transitioned to the running phase
/// and the main entrypoint was invoked.
///
[[nodiscard]] bool RunFromLibrary(std::optional<std::string> library_name,
std::optional<std::string> entrypoint,
const std::vector<std::string>& args);
//----------------------------------------------------------------------------
/// @brief Transition the isolate to the `Phase::Shutdown` phase. The
/// only thing left to do is to collect the isolate.
///
/// @return If the isolate succesfully transitioned to the shutdown phase.
///
[[nodiscard]] bool Shutdown();
//----------------------------------------------------------------------------
/// @brief Registers a callback that will be invoked in isolate scope
/// just before the isolate transitions to the `Phase::Shutdown`
/// phase.
///
/// @param[in] closure The callback to invoke on isolate shutdown.
///
void AddIsolateShutdownCallback(const fml::closure& closure);
//----------------------------------------------------------------------------
/// @brief A weak pointer to the Dart isolate instance. This instance may
/// only be used on the task runner that created the root isolate.
///
/// @return The weak isolate pointer.
///
std::weak_ptr<DartIsolate> GetWeakIsolatePtr();
//----------------------------------------------------------------------------
/// @brief The task runner on which the Dart code for the root isolate is
/// running. For the root isolate, this is the UI task runner for
/// the shell that owns the root isolate.
///
/// @return The message handling task runner.
///
fml::RefPtr<fml::TaskRunner> GetMessageHandlingTaskRunner() const;
bool LoadLoadingUnit(
intptr_t loading_unit_id,
std::unique_ptr<const fml::Mapping> snapshot_data,
std::unique_ptr<const fml::Mapping> snapshot_instructions);
void LoadLoadingUnitError(intptr_t loading_unit_id,
const std::string error_message,
bool transient);
private:
friend class IsolateConfiguration;
class AutoFireClosure {
public:
AutoFireClosure(const fml::closure& closure);
~AutoFireClosure();
private:
fml::closure closure_;
FML_DISALLOW_COPY_AND_ASSIGN(AutoFireClosure);
};
friend class DartVM;
Phase phase_ = Phase::Unknown;
std::vector<std::shared_ptr<const fml::Mapping>> kernel_buffers_;
std::vector<std::unique_ptr<AutoFireClosure>> shutdown_callbacks_;
std::unordered_set<fml::RefPtr<DartSnapshot>> loading_unit_snapshots_;
fml::RefPtr<fml::TaskRunner> message_handling_task_runner_;
const bool may_insecurely_connect_to_all_domains_;
std::string domain_network_policy_;
static std::weak_ptr<DartIsolate> CreateRootIsolate(
const Settings& settings,
fml::RefPtr<const DartSnapshot> isolate_snapshot,
TaskRunners task_runners,
std::unique_ptr<PlatformConfiguration> platform_configuration,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::WeakPtr<HintFreedDelegate> hint_freed_delegate,
fml::WeakPtr<IOManager> io_manager,
fml::RefPtr<SkiaUnrefQueue> skia_unref_queue,
fml::WeakPtr<ImageDecoder> image_decoder,
std::string advisory_script_uri,
std::string advisory_script_entrypoint,
Flags flags,
const fml::closure& isolate_create_callback,
const fml::closure& isolate_shutdown_callback,
std::shared_ptr<VolatilePathTracker> volatile_path_tracker,
const DartIsolate* spawning_isolate = nullptr);
DartIsolate(const Settings& settings,
TaskRunners task_runners,
fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
fml::WeakPtr<HintFreedDelegate> hint_freed_delegate,
fml::WeakPtr<IOManager> io_manager,
fml::RefPtr<SkiaUnrefQueue> unref_queue,
fml::WeakPtr<ImageDecoder> image_decoder,
std::string advisory_script_uri,
std::string advisory_script_entrypoint,
bool is_root_isolate,
std::shared_ptr<VolatilePathTracker> volatile_path_tracker);
[[nodiscard]] bool Initialize(Dart_Isolate isolate);
void SetMessageHandlingTaskRunner(fml::RefPtr<fml::TaskRunner> runner);
bool LoadKernel(std::shared_ptr<const fml::Mapping> mapping, bool last_piece);
[[nodiscard]] bool LoadLibraries();
bool UpdateThreadPoolNames() const;
[[nodiscard]] bool MarkIsolateRunnable();
void OnShutdownCallback();
DartIsolateGroupData& GetIsolateGroupData();
const DartIsolateGroupData& GetIsolateGroupData() const;
// |Dart_IsolateGroupCreateCallback|
static Dart_Isolate DartIsolateGroupCreateCallback(
const char* advisory_script_uri,
const char* advisory_script_entrypoint,
const char* package_root,
const char* package_config,
Dart_IsolateFlags* flags,
std::shared_ptr<DartIsolate>* parent_isolate_group,
char** error);
// |Dart_IsolateInitializeCallback|
static bool DartIsolateInitializeCallback(void** child_callback_data,
char** error);
static Dart_Isolate DartCreateAndStartServiceIsolate(
const char* package_root,
const char* package_config,
Dart_IsolateFlags* flags,
char** error);
typedef std::function<Dart_Isolate(std::shared_ptr<DartIsolateGroupData>*,
std::shared_ptr<DartIsolate>*,
Dart_IsolateFlags*,
char**)>
IsolateMaker;
static Dart_Isolate CreateDartIsolateGroup(
std::unique_ptr<std::shared_ptr<DartIsolateGroupData>> isolate_group_data,
std::unique_ptr<std::shared_ptr<DartIsolate>> isolate_data,
Dart_IsolateFlags* flags,
char** error,
const IsolateMaker& make_isolate);
static bool InitializeIsolate(std::shared_ptr<DartIsolate> embedder_isolate,
Dart_Isolate isolate,
char** error);
// |Dart_IsolateShutdownCallback|
static void DartIsolateShutdownCallback(
std::shared_ptr<DartIsolateGroupData>* isolate_group_data,
std::shared_ptr<DartIsolate>* isolate_data);
// |Dart_IsolateCleanupCallback|
static void DartIsolateCleanupCallback(
std::shared_ptr<DartIsolateGroupData>* isolate_group_data,
std::shared_ptr<DartIsolate>* isolate_data);
// |Dart_IsolateGroupCleanupCallback|
static void DartIsolateGroupCleanupCallback(
std::shared_ptr<DartIsolateGroupData>* isolate_group_data);
// |Dart_DeferredLoadHandler|
static Dart_Handle OnDartLoadLibrary(intptr_t loading_unit_id);
FML_DISALLOW_COPY_AND_ASSIGN(DartIsolate);
};
} // namespace flutter
#endif // FLUTTER_RUNTIME_DART_ISOLATE_H_
| [
"noreply@github.com"
] | noreply@github.com |
f45887da491916ca07da22b7c497e972f34fe13a | 0e50b99f81332789e304690094a0a903692c9cbb | /test/user_define_classes/UserDefineClasses.hpp | 5fbd7c351cf7cf3c3e1a98d83dc1db19fef189f9 | [
"MIT"
] | permissive | sev7ncm/easyrpc | 0f93447a9294fc63597b6568dd3708554b07ea4c | cdb11698393a6ffd852091929cba2c862b7d84f3 | refs/heads/master | 2020-12-30T19:23:39.732425 | 2016-09-14T14:30:02 | 2016-09-14T14:30:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,015 | hpp | #ifndef _PROTOCOLDEFINE_H
#define _PROTOCOLDEFINE_H
#ifdef ENABLE_BOOST_SERIALIZATION
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/set.hpp>
#include <boost/serialization/deque.hpp>
#include <boost/serialization/stack.hpp>
#include <boost/serialization/array.hpp>
#include <boost/serialization/bitset.hpp>
#include <boost/serialization/hash_map.hpp>
#include <boost/serialization/hash_set.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/unique_ptr.hpp>
#include <boost/serialization/unordered_map.hpp>
#include <boost/serialization/unordered_set.hpp>
#include <boost/serialization/boost_unordered_map.hpp>
#include <boost/serialization/boost_unordered_set.hpp>
#include <boost/serialization/version.hpp>
#include <boost/serialization/split_member.hpp>
#endif
#ifdef ENABLE_MSGPACK
#include <msgpack.hpp>
#endif
#ifdef ENABLE_JSON
#include <kapok/Kapok.hpp>
#endif
struct PersonInfoReq
{
int cardId;
std::string name;
#ifdef ENABLE_BOOST_SERIALIZATION
template<class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & cardId;
ar & name;
}
#endif
#ifdef ENABLE_MSGPACK
MSGPACK_DEFINE(cardId, name);
#endif
#ifdef ENABLE_JSON
META(cardId, name);
#endif
};
struct PersonInfoRes
{
int cardId;
std::string name;
int age;
std::string national;
#ifdef ENABLE_BOOST_SERIALIZATION
template<class Archive>
void serialize(Archive& ar, const unsigned int)
{
ar & cardId;
ar & name;
ar & age;
ar & national;
}
#endif
#ifdef ENABLE_MSGPACK
MSGPACK_DEFINE(cardId, name, age, national);
#endif
#ifdef ENABLE_JSON
META(cardId, name, age, national);
#endif
};
#endif
| [
"787280310@qq.com"
] | 787280310@qq.com |
2883ff2ddb1e393e1065cccf52e16c043e6c9742 | 2ee1d15161fe97b708302773b12b80e7c7584fc7 | /2-szintaktikus-elemzo/parse.cc | bf934ebc6abc00c052ef4853dc399c3469432679 | [] | no_license | lcsoka/fordprog-bead | 60c85b0164a88fabdf19627f2622dfd37bd28fcd | cbd9ff1fb34e8e065c4dfa16f1ac93c3ae8e9452 | refs/heads/master | 2022-01-21T07:21:45.747292 | 2019-04-28T13:59:30 | 2019-04-28T13:59:30 | 171,715,286 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 49,215 | cc | // Generated by Bisonc++ V5.02.00 on Fri, 19 Apr 2019 21:07:57 +0200
// $insert class.ih
#include "Parser.ih"
// The FIRST element of SR arrays shown below uses `d_type', defining the
// state's type, and `d_lastIdx' containing the last element's index. If
// d_lastIdx contains the REQ_TOKEN bitflag (see below) then the state needs
// a token: if in this state d_token__ is _UNDETERMINED_, nextToken() will be
// called
// The LAST element of SR arrays uses `d_token' containing the last retrieved
// token to speed up the (linear) seach. Except for the first element of SR
// arrays, the field `d_action' is used to determine what to do next. If
// positive, it represents the next state (used with SHIFT); if zero, it
// indicates `ACCEPT', if negative, -d_action represents the number of the
// rule to reduce to.
// `lookup()' tries to find d_token__ in the current SR array. If it fails, and
// there is no default reduction UNEXPECTED_TOKEN__ is thrown, which is then
// caught by the error-recovery function.
// The error-recovery function will pop elements off the stack until a state
// having bit flag ERR_ITEM is found. This state has a transition on _error_
// which is applied. In this _error_ state, while the current token is not a
// proper continuation, new tokens are obtained by nextToken(). If such a
// token is found, error recovery is successful and the token is
// handled according to the error state's SR table and parsing continues.
// During error recovery semantic actions are ignored.
// A state flagged with the DEF_RED flag will perform a default
// reduction if no other continuations are available for the current token.
// The ACCEPT STATE never shows a default reduction: when it is reached the
// parser returns ACCEPT(). During the grammar
// analysis phase a default reduction may have been defined, but it is
// removed during the state-definition phase.
// So:
// s_x[] =
// {
// [_field_1_] [_field_2_]
//
// First element: {state-type, idx of last element},
// Other elements: {required token, action to perform},
// ( < 0: reduce,
// 0: ACCEPT,
// > 0: next state)
// Last element: {set to d_token__, action to perform}
// }
// When the --thread-safe option is specified, all static data are defined as
// const. If --thread-safe is not provided, the state-tables are not defined
// as const, since the lookup() function below will modify them
namespace // anonymous
{
char const author[] = "Frank B. Brokken (f.b.brokken@rug.nl)";
enum ReservedTokens
{
PARSE_ACCEPT = 0, // `ACCEPT' TRANSITION
_UNDETERMINED_ = -2,
_EOF_ = -1,
_error_ = 256
};
enum StateType // modify statetype/data.cc when this enum changes
{
NORMAL,
ERR_ITEM,
REQ_TOKEN,
ERR_REQ, // ERR_ITEM | REQ_TOKEN
DEF_RED, // state having default reduction
ERR_DEF, // ERR_ITEM | DEF_RED
REQ_DEF, // REQ_TOKEN | DEF_RED
ERR_REQ_DEF // ERR_ITEM | REQ_TOKEN | DEF_RED
};
struct PI__ // Production Info
{
size_t d_nonTerm; // identification number of this production's
// non-terminal
size_t d_size; // number of elements in this production
};
struct SR__ // Shift Reduce info, see its description above
{
union
{
int _field_1_; // initializer, allowing initializations
// of the SR s_[] arrays
int d_type;
int d_token;
};
union
{
int _field_2_;
int d_lastIdx; // if negative, the state uses SHIFT
int d_action; // may be negative (reduce),
// postive (shift), or 0 (accept)
size_t d_errorState; // used with Error states
};
};
// $insert staticdata
enum // size to expand the state-stack with when
{ // full
STACK_EXPANSION__ = 10
};
// Productions Info Records:
PI__ const s_productionInfo[] =
{
{0, 0}, // not used: reduction values are negative
{292, 1}, // 1: start -> program
{293, 3}, // 2: program -> header declarations body
{294, 2}, // 3: header (PROGRAM) -> PROGRAM IDENTIFIER
{295, 0}, // 4: declarations -> <empty>
{295, 2}, // 5: declarations -> declaration declarations
{297, 3}, // 6: declaration (IDENTIFIER) -> type IDENTIFIER SEMICOLON
{298, 1}, // 7: type (NATURAL) -> NATURAL
{298, 1}, // 8: type (BOOLEAN) -> BOOLEAN
{296, 3}, // 9: body (BEGIN_TOKEN) -> BEGIN_TOKEN expressions END
{299, 1}, // 10: expressions -> expression
{299, 2}, // 11: expressions -> expression expressions
{300, 1}, // 12: expression -> read
{300, 1}, // 13: expression -> write
{300, 1}, // 14: expression -> assignment
{300, 1}, // 15: expression -> while_loop
{300, 1}, // 16: expression -> if_statement
{300, 1}, // 17: expression -> skip
{301, 5}, // 18: read (READ) -> READ LEFT_PARENTHESIS IDENTIFIER RIGHT_PARENTHESIS SEMICOLON
{302, 5}, // 19: write (WRITE) -> WRITE LEFT_PARENTHESIS expr RIGHT_PARENTHESIS SEMICOLON
{303, 4}, // 20: assignment (IDENTIFIER) -> IDENTIFIER ASSIGN expr SEMICOLON
{304, 5}, // 21: while_loop (WHILE) -> WHILE expr DO expressions DONE
{305, 4}, // 22: if_statement (IF) -> IF expr THEN if_second_half
{308, 2}, // 23: if_second_half (ENDIF) -> expressions ENDIF
{308, 4}, // 24: if_second_half (ELSE) -> expressions ELSE expressions ENDIF
{308, 5}, // 25: if_second_half (ELSEIF) -> expressions ELSEIF expr THEN if_second_half
{307, 1}, // 26: expr (TRUE) -> TRUE
{307, 1}, // 27: expr (FALSE) -> FALSE
{307, 1}, // 28: expr (IDENTIFIER) -> IDENTIFIER
{307, 1}, // 29: expr (NATURAL_LITERAL) -> NATURAL_LITERAL
{307, 3}, // 30: expr (EQUAL) -> expr EQUAL expr
{307, 3}, // 31: expr (LEFT_PARENTHESIS) -> LEFT_PARENTHESIS expr RIGHT_PARENTHESIS
{307, 2}, // 32: expr (NOT) -> NOT expr
{307, 3}, // 33: expr (AND) -> expr AND expr
{307, 3}, // 34: expr (OR) -> expr OR expr
{307, 3}, // 35: expr (LESS_THAN) -> expr LESS_THAN expr
{307, 3}, // 36: expr (GREATER_THAN) -> expr GREATER_THAN expr
{307, 3}, // 37: expr (PLUS) -> expr PLUS expr
{307, 3}, // 38: expr (MINUS) -> expr MINUS expr
{307, 3}, // 39: expr (MULTIPLY) -> expr MULTIPLY expr
{307, 3}, // 40: expr (DIV) -> expr DIV expr
{307, 3}, // 41: expr (MOD) -> expr MOD expr
{306, 2}, // 42: skip (SKIP) -> SKIP SEMICOLON
{309, 1}, // 43: start_$ -> start
};
// State info and SR__ transitions for each state.
SR__ s_0[] =
{
{ { REQ_TOKEN}, { 5} },
{ { 292}, { 1} }, // start
{ { 293}, { 2} }, // program
{ { 294}, { 3} }, // header
{ { 257}, { 4} }, // PROGRAM
{ { 0}, { 0} },
};
SR__ s_1[] =
{
{ { REQ_TOKEN}, { 2} },
{ { _EOF_}, { PARSE_ACCEPT} },
{ { 0}, { 0} },
};
SR__ s_2[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -1} },
};
SR__ s_3[] =
{
{ { REQ_DEF}, { 6} },
{ { 295}, { 5} }, // declarations
{ { 297}, { 6} }, // declaration
{ { 298}, { 7} }, // type
{ { 260}, { 8} }, // NATURAL
{ { 261}, { 9} }, // BOOLEAN
{ { 0}, { -4} },
};
SR__ s_4[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 276}, { 10} }, // IDENTIFIER
{ { 0}, { 0} },
};
SR__ s_5[] =
{
{ { REQ_TOKEN}, { 3} },
{ { 296}, { 11} }, // body
{ { 258}, { 12} }, // BEGIN_TOKEN
{ { 0}, { 0} },
};
SR__ s_6[] =
{
{ { REQ_DEF}, { 6} },
{ { 295}, { 13} }, // declarations
{ { 297}, { 6} }, // declaration
{ { 298}, { 7} }, // type
{ { 260}, { 8} }, // NATURAL
{ { 261}, { 9} }, // BOOLEAN
{ { 0}, { -4} },
};
SR__ s_7[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 276}, { 14} }, // IDENTIFIER
{ { 0}, { 0} },
};
SR__ s_8[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -7} },
};
SR__ s_9[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -8} },
};
SR__ s_10[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -3} },
};
SR__ s_11[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -2} },
};
SR__ s_12[] =
{
{ { REQ_TOKEN}, { 15} },
{ { 299}, { 15} }, // expressions
{ { 300}, { 16} }, // expression
{ { 301}, { 17} }, // read
{ { 302}, { 18} }, // write
{ { 303}, { 19} }, // assignment
{ { 304}, { 20} }, // while_loop
{ { 305}, { 21} }, // if_statement
{ { 306}, { 22} }, // skip
{ { 274}, { 23} }, // READ
{ { 275}, { 24} }, // WRITE
{ { 276}, { 25} }, // IDENTIFIER
{ { 271}, { 26} }, // WHILE
{ { 266}, { 27} }, // IF
{ { 265}, { 28} }, // SKIP
{ { 0}, { 0} },
};
SR__ s_13[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -5} },
};
SR__ s_14[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 280}, { 29} }, // SEMICOLON
{ { 0}, { 0} },
};
SR__ s_15[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 259}, { 30} }, // END
{ { 0}, { 0} },
};
SR__ s_16[] =
{
{ { REQ_DEF}, { 15} },
{ { 299}, { 31} }, // expressions
{ { 300}, { 16} }, // expression
{ { 301}, { 17} }, // read
{ { 302}, { 18} }, // write
{ { 303}, { 19} }, // assignment
{ { 304}, { 20} }, // while_loop
{ { 305}, { 21} }, // if_statement
{ { 306}, { 22} }, // skip
{ { 274}, { 23} }, // READ
{ { 275}, { 24} }, // WRITE
{ { 276}, { 25} }, // IDENTIFIER
{ { 271}, { 26} }, // WHILE
{ { 266}, { 27} }, // IF
{ { 265}, { 28} }, // SKIP
{ { 0}, { -10} },
};
SR__ s_17[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -12} },
};
SR__ s_18[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -13} },
};
SR__ s_19[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -14} },
};
SR__ s_20[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -15} },
};
SR__ s_21[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -16} },
};
SR__ s_22[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -17} },
};
SR__ s_23[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 277}, { 32} }, // LEFT_PARENTHESIS
{ { 0}, { 0} },
};
SR__ s_24[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 277}, { 33} }, // LEFT_PARENTHESIS
{ { 0}, { 0} },
};
SR__ s_25[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 279}, { 34} }, // ASSIGN
{ { 0}, { 0} },
};
SR__ s_26[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 35} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_27[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 42} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_28[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 280}, { 43} }, // SEMICOLON
{ { 0}, { 0} },
};
SR__ s_29[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -6} },
};
SR__ s_30[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -9} },
};
SR__ s_31[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -11} },
};
SR__ s_32[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 276}, { 44} }, // IDENTIFIER
{ { 0}, { 0} },
};
SR__ s_33[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 45} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_34[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 46} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_35[] =
{
{ { REQ_TOKEN}, { 12} },
{ { 272}, { 47} }, // DO
{ { 284}, { 48} }, // EQUAL
{ { 282}, { 49} }, // AND
{ { 283}, { 50} }, // OR
{ { 285}, { 51} }, // LESS_THAN
{ { 286}, { 52} }, // GREATER_THAN
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { 0} },
};
SR__ s_36[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -26} },
};
SR__ s_37[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -27} },
};
SR__ s_38[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -28} },
};
SR__ s_39[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -29} },
};
SR__ s_40[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 58} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_41[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 59} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_42[] =
{
{ { REQ_TOKEN}, { 12} },
{ { 267}, { 60} }, // THEN
{ { 284}, { 48} }, // EQUAL
{ { 282}, { 49} }, // AND
{ { 283}, { 50} }, // OR
{ { 285}, { 51} }, // LESS_THAN
{ { 286}, { 52} }, // GREATER_THAN
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { 0} },
};
SR__ s_43[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -42} },
};
SR__ s_44[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 278}, { 61} }, // RIGHT_PARENTHESIS
{ { 0}, { 0} },
};
SR__ s_45[] =
{
{ { REQ_TOKEN}, { 12} },
{ { 278}, { 62} }, // RIGHT_PARENTHESIS
{ { 284}, { 48} }, // EQUAL
{ { 282}, { 49} }, // AND
{ { 283}, { 50} }, // OR
{ { 285}, { 51} }, // LESS_THAN
{ { 286}, { 52} }, // GREATER_THAN
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { 0} },
};
SR__ s_46[] =
{
{ { REQ_TOKEN}, { 12} },
{ { 280}, { 63} }, // SEMICOLON
{ { 284}, { 48} }, // EQUAL
{ { 282}, { 49} }, // AND
{ { 283}, { 50} }, // OR
{ { 285}, { 51} }, // LESS_THAN
{ { 286}, { 52} }, // GREATER_THAN
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { 0} },
};
SR__ s_47[] =
{
{ { REQ_TOKEN}, { 15} },
{ { 299}, { 64} }, // expressions
{ { 300}, { 16} }, // expression
{ { 301}, { 17} }, // read
{ { 302}, { 18} }, // write
{ { 303}, { 19} }, // assignment
{ { 304}, { 20} }, // while_loop
{ { 305}, { 21} }, // if_statement
{ { 306}, { 22} }, // skip
{ { 274}, { 23} }, // READ
{ { 275}, { 24} }, // WRITE
{ { 276}, { 25} }, // IDENTIFIER
{ { 271}, { 26} }, // WHILE
{ { 266}, { 27} }, // IF
{ { 265}, { 28} }, // SKIP
{ { 0}, { 0} },
};
SR__ s_48[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 65} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_49[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 66} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_50[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 67} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_51[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 68} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_52[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 69} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_53[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 70} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_54[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 71} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_55[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 72} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_56[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 73} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_57[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 74} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_58[] =
{
{ { REQ_TOKEN}, { 12} },
{ { 278}, { 75} }, // RIGHT_PARENTHESIS
{ { 284}, { 48} }, // EQUAL
{ { 282}, { 49} }, // AND
{ { 283}, { 50} }, // OR
{ { 285}, { 51} }, // LESS_THAN
{ { 286}, { 52} }, // GREATER_THAN
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { 0} },
};
SR__ s_59[] =
{
{ { REQ_DEF}, { 11} },
{ { 284}, { 48} }, // EQUAL
{ { 282}, { 49} }, // AND
{ { 283}, { 50} }, // OR
{ { 285}, { 51} }, // LESS_THAN
{ { 286}, { 52} }, // GREATER_THAN
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { -32} },
};
SR__ s_60[] =
{
{ { REQ_TOKEN}, { 16} },
{ { 308}, { 76} }, // if_second_half
{ { 299}, { 77} }, // expressions
{ { 300}, { 16} }, // expression
{ { 301}, { 17} }, // read
{ { 302}, { 18} }, // write
{ { 303}, { 19} }, // assignment
{ { 304}, { 20} }, // while_loop
{ { 305}, { 21} }, // if_statement
{ { 306}, { 22} }, // skip
{ { 274}, { 23} }, // READ
{ { 275}, { 24} }, // WRITE
{ { 276}, { 25} }, // IDENTIFIER
{ { 271}, { 26} }, // WHILE
{ { 266}, { 27} }, // IF
{ { 265}, { 28} }, // SKIP
{ { 0}, { 0} },
};
SR__ s_61[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 280}, { 78} }, // SEMICOLON
{ { 0}, { 0} },
};
SR__ s_62[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 280}, { 79} }, // SEMICOLON
{ { 0}, { 0} },
};
SR__ s_63[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -20} },
};
SR__ s_64[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 273}, { 80} }, // DONE
{ { 0}, { 0} },
};
SR__ s_65[] =
{
{ { REQ_DEF}, { 8} },
{ { 285}, { 51} }, // LESS_THAN
{ { 286}, { 52} }, // GREATER_THAN
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { -30} },
};
SR__ s_66[] =
{
{ { REQ_DEF}, { 9} },
{ { 284}, { 48} }, // EQUAL
{ { 285}, { 51} }, // LESS_THAN
{ { 286}, { 52} }, // GREATER_THAN
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { -33} },
};
SR__ s_67[] =
{
{ { REQ_DEF}, { 9} },
{ { 284}, { 48} }, // EQUAL
{ { 285}, { 51} }, // LESS_THAN
{ { 286}, { 52} }, // GREATER_THAN
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { -34} },
};
SR__ s_68[] =
{
{ { REQ_DEF}, { 6} },
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { -35} },
};
SR__ s_69[] =
{
{ { REQ_DEF}, { 6} },
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { -36} },
};
SR__ s_70[] =
{
{ { REQ_DEF}, { 4} },
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { -37} },
};
SR__ s_71[] =
{
{ { REQ_DEF}, { 4} },
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { -38} },
};
SR__ s_72[] =
{
{ { REQ_DEF}, { 1} },
{ { 0}, { -39} },
};
SR__ s_73[] =
{
{ { REQ_DEF}, { 1} },
{ { 0}, { -40} },
};
SR__ s_74[] =
{
{ { REQ_DEF}, { 1} },
{ { 0}, { -41} },
};
SR__ s_75[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -31} },
};
SR__ s_76[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -22} },
};
SR__ s_77[] =
{
{ { REQ_TOKEN}, { 4} },
{ { 270}, { 81} }, // ENDIF
{ { 268}, { 82} }, // ELSE
{ { 269}, { 83} }, // ELSEIF
{ { 0}, { 0} },
};
SR__ s_78[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -18} },
};
SR__ s_79[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -19} },
};
SR__ s_80[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -21} },
};
SR__ s_81[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -23} },
};
SR__ s_82[] =
{
{ { REQ_TOKEN}, { 15} },
{ { 299}, { 84} }, // expressions
{ { 300}, { 16} }, // expression
{ { 301}, { 17} }, // read
{ { 302}, { 18} }, // write
{ { 303}, { 19} }, // assignment
{ { 304}, { 20} }, // while_loop
{ { 305}, { 21} }, // if_statement
{ { 306}, { 22} }, // skip
{ { 274}, { 23} }, // READ
{ { 275}, { 24} }, // WRITE
{ { 276}, { 25} }, // IDENTIFIER
{ { 271}, { 26} }, // WHILE
{ { 266}, { 27} }, // IF
{ { 265}, { 28} }, // SKIP
{ { 0}, { 0} },
};
SR__ s_83[] =
{
{ { REQ_TOKEN}, { 8} },
{ { 307}, { 85} }, // expr
{ { 262}, { 36} }, // TRUE
{ { 263}, { 37} }, // FALSE
{ { 276}, { 38} }, // IDENTIFIER
{ { 281}, { 39} }, // NATURAL_LITERAL
{ { 277}, { 40} }, // LEFT_PARENTHESIS
{ { 264}, { 41} }, // NOT
{ { 0}, { 0} },
};
SR__ s_84[] =
{
{ { REQ_TOKEN}, { 2} },
{ { 270}, { 86} }, // ENDIF
{ { 0}, { 0} },
};
SR__ s_85[] =
{
{ { REQ_TOKEN}, { 12} },
{ { 267}, { 87} }, // THEN
{ { 284}, { 48} }, // EQUAL
{ { 282}, { 49} }, // AND
{ { 283}, { 50} }, // OR
{ { 285}, { 51} }, // LESS_THAN
{ { 286}, { 52} }, // GREATER_THAN
{ { 287}, { 53} }, // PLUS
{ { 288}, { 54} }, // MINUS
{ { 289}, { 55} }, // MULTIPLY
{ { 290}, { 56} }, // DIV
{ { 291}, { 57} }, // MOD
{ { 0}, { 0} },
};
SR__ s_86[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -24} },
};
SR__ s_87[] =
{
{ { REQ_TOKEN}, { 16} },
{ { 308}, { 88} }, // if_second_half
{ { 299}, { 77} }, // expressions
{ { 300}, { 16} }, // expression
{ { 301}, { 17} }, // read
{ { 302}, { 18} }, // write
{ { 303}, { 19} }, // assignment
{ { 304}, { 20} }, // while_loop
{ { 305}, { 21} }, // if_statement
{ { 306}, { 22} }, // skip
{ { 274}, { 23} }, // READ
{ { 275}, { 24} }, // WRITE
{ { 276}, { 25} }, // IDENTIFIER
{ { 271}, { 26} }, // WHILE
{ { 266}, { 27} }, // IF
{ { 265}, { 28} }, // SKIP
{ { 0}, { 0} },
};
SR__ s_88[] =
{
{ { DEF_RED}, { 1} },
{ { 0}, { -25} },
};
// State array:
SR__ *s_state[] =
{
s_0, s_1, s_2, s_3, s_4, s_5, s_6, s_7, s_8, s_9,
s_10, s_11, s_12, s_13, s_14, s_15, s_16, s_17, s_18, s_19,
s_20, s_21, s_22, s_23, s_24, s_25, s_26, s_27, s_28, s_29,
s_30, s_31, s_32, s_33, s_34, s_35, s_36, s_37, s_38, s_39,
s_40, s_41, s_42, s_43, s_44, s_45, s_46, s_47, s_48, s_49,
s_50, s_51, s_52, s_53, s_54, s_55, s_56, s_57, s_58, s_59,
s_60, s_61, s_62, s_63, s_64, s_65, s_66, s_67, s_68, s_69,
s_70, s_71, s_72, s_73, s_74, s_75, s_76, s_77, s_78, s_79,
s_80, s_81, s_82, s_83, s_84, s_85, s_86, s_87, s_88,
};
} // anonymous namespace ends
// If the parsing function call uses arguments, then provide an overloaded
// function. The code below doesn't rely on parameters, so no arguments are
// required. Furthermore, parse uses a function try block to allow us to do
// ACCEPT and ABORT from anywhere, even from within members called by actions,
// simply throwing the appropriate exceptions.
ParserBase::ParserBase()
:
// $insert requiredtokens
d_requiredTokens__(0),
d_acceptedTokens__(d_requiredTokens__),
d_token__(_UNDETERMINED_),
d_nextToken__(_UNDETERMINED_)
{}
void ParserBase::setDebug(bool mode)
{
d_actionCases__ = false;
d_debug__ = mode;
}
void ParserBase::setDebug(DebugMode__ mode)
{
d_actionCases__ = mode & ACTIONCASES;
d_debug__ = mode & ON;
}
void Parser::print__()
{
// $insert print
}
void ParserBase::clearin()
{
d_token__ = d_nextToken__ = _UNDETERMINED_;
}
void ParserBase::push__(size_t state)
{
size_t currentSize = d_stateStack__.size();
if (static_cast<size_t>(d_stackIdx__ + 1) == currentSize)
{
size_t newSize = currentSize + STACK_EXPANSION__;
d_stateStack__.resize(newSize);
// $insert LTYPEresize
d_locationStack__.resize(newSize);
if (d_valueStack__.capacity() >= newSize)
d_valueStack__.resize(newSize);
else
{
std::vector<STYPE__> enlarged(newSize);
for (size_t idx = 0; idx != currentSize; ++idx)
enlarged[idx] = std::move(d_valueStack__[idx]);
d_valueStack__.swap(enlarged);
}
}
++d_stackIdx__;
d_stateStack__[d_stackIdx__] = d_state__ = state;
// $insert LTYPEpush
*(d_lsp__ = &d_locationStack__[d_stackIdx__]) = d_loc__;
*(d_vsp__ = &d_valueStack__[d_stackIdx__]) = std::move(d_val__);
}
void ParserBase::popToken__()
{
d_token__ = d_nextToken__;
d_val__ = std::move(d_nextVal__);
d_nextVal__ = STYPE__();
d_nextToken__ = _UNDETERMINED_;
}
void ParserBase::pushToken__(int token)
{
d_nextToken__ = d_token__;
d_nextVal__ = std::move(d_val__);
d_token__ = token;
}
void ParserBase::pop__(size_t count)
{
if (d_stackIdx__ < static_cast<int>(count))
{
ABORT();
}
d_stackIdx__ -= count;
d_state__ = d_stateStack__[d_stackIdx__];
d_vsp__ = &d_valueStack__[d_stackIdx__];
// $insert LTYPEpop
d_lsp__ = &d_locationStack__[d_stackIdx__];
}
inline size_t ParserBase::top__() const
{
return d_stateStack__[d_stackIdx__];
}
void Parser::executeAction(int production)
try
{
if (d_token__ != _UNDETERMINED_)
pushToken__(d_token__); // save an already available token
switch (production)
{
// $insert actioncases
case 1:
#line 27 "lang.y"
{
std::cout << "start -> program" << std::endl;
}
break;
case 2:
#line 33 "lang.y"
{
std::cout << "program -> header declarations body" << std::endl;
}
break;
case 3:
#line 39 "lang.y"
{
std::cout << "header -> PROGRAM IDENTIFIER" << std::endl;
}
break;
case 4:
#line 45 "lang.y"
{
std::cout << "declarations -> \"\"" << std::endl;
}
break;
case 5:
#line 50 "lang.y"
{
std::cout << "declarations -> declaration declarations" << std::endl;
}
break;
case 6:
#line 56 "lang.y"
{
std::cout << "declaration -> type IDENTIFIER SEMICOLON" << std::endl;
}
break;
case 7:
#line 63 "lang.y"
{
std::cout << "type -> NATURAL" << std::endl;
}
break;
case 8:
#line 68 "lang.y"
{
std::cout << "type -> BOOLEAN" << std::endl;
}
break;
case 9:
#line 74 "lang.y"
{
std::cout << "body -> BEGIN_TOKEN statements END" << std::endl;
}
break;
case 10:
#line 81 "lang.y"
{
std::cout << "expressions -> expression" << std::endl;
}
break;
case 11:
#line 86 "lang.y"
{
std::cout << "expressions -> expression expressions" << std::endl;
}
break;
case 12:
#line 93 "lang.y"
{
std::cout << "expression -> read" << std::endl;
}
break;
case 13:
#line 98 "lang.y"
{
std::cout << "expression -> write" << std::endl;
}
break;
case 14:
#line 103 "lang.y"
{
std::cout << "expression -> assignment" << std::endl;
}
break;
case 15:
#line 108 "lang.y"
{
std::cout << "expression -> while_loop" << std::endl;
}
break;
case 16:
#line 113 "lang.y"
{
std::cout << "expression -> if_statement" << std::endl;
}
break;
case 17:
#line 118 "lang.y"
{
std::cout << "expression -> skip" << std::endl;
}
break;
case 18:
#line 124 "lang.y"
{
std::cout << "read -> READ LEFT_PARENTHESIS IDENTIFIER RIGHT_PARENTHESIS SEMICOLON" << std::endl;
}
break;
case 19:
#line 130 "lang.y"
{
std::cout << "write -> WRITE LEFT_PARENTHESIS expr RIGHT_PARENTHESIS SEMICOLON" << std::endl;
}
break;
case 20:
#line 136 "lang.y"
{
std::cout << "assignment -> IDENTIFIER ASSIGN expr SEMICOLON" << std::endl;
}
break;
case 21:
#line 142 "lang.y"
{
std::cout << "while_loop -> WHILE expr DO expressions DONE" << std::endl;
}
break;
case 22:
#line 148 "lang.y"
{
std::cout << "if_statement -> IF expr THEN if_second_half" << std::endl;
}
break;
case 23:
#line 155 "lang.y"
{
std::cout << "if_second_half -> expressions ENDIF" << std::endl;
}
break;
case 24:
#line 160 "lang.y"
{
std::cout << "if_second_half -> expressions ELSE expressions ENDIF" << std::endl;
}
break;
case 25:
#line 165 "lang.y"
{
std::cout << "if_second_half -> expressions ELSEIF expr THEN if_second_half" << std::endl;
}
break;
case 26:
#line 172 "lang.y"
{
std::cout << "expr -> TRUE" << std::endl;
}
break;
case 27:
#line 177 "lang.y"
{
std::cout << "expr -> FALSE" << std::endl;
}
break;
case 28:
#line 182 "lang.y"
{
std::cout << "expr -> IDENTIFIER" << std::endl;
}
break;
case 29:
#line 187 "lang.y"
{
std::cout << "expr -> NATURAL_LITERAL" << std::endl;
}
break;
case 30:
#line 192 "lang.y"
{
std::cout << "expr -> expr EQUAL expr" << std::endl;
}
break;
case 31:
#line 197 "lang.y"
{
std::cout << "expr -> LEFT_PARENTHESIS expr RIGHT_PARENTHESIS" << std::endl;
}
break;
case 32:
#line 202 "lang.y"
{
std::cout << "expr -> NOT expr" << std::endl;
}
break;
case 33:
#line 207 "lang.y"
{
std::cout << "expr -> expr AND expr" << std::endl;
}
break;
case 34:
#line 212 "lang.y"
{
std::cout << "expr -> expr OR expr" << std::endl;
}
break;
case 35:
#line 217 "lang.y"
{
std::cout << "expr -> expr LESS_THAN expr" << std::endl;
}
break;
case 36:
#line 222 "lang.y"
{
std::cout << "expr -> expr GREATER_THAN expr" << std::endl;
}
break;
case 37:
#line 227 "lang.y"
{
std::cout << "expr -> expr PLUS expr" << std::endl;
}
break;
case 38:
#line 232 "lang.y"
{
std::cout << "expr -> expr MINUS expr" << std::endl;
}
break;
case 39:
#line 237 "lang.y"
{
std::cout << "expr -> expr MULTIPLY expr" << std::endl;
}
break;
case 40:
#line 242 "lang.y"
{
std::cout << "expr -> expr DIV expr" << std::endl;
}
break;
case 41:
#line 247 "lang.y"
{
std::cout << "expr -> expr MOD expr" << std::endl;
}
break;
case 42:
#line 253 "lang.y"
{
std::cout << "skip -> SKIP SEMICOLON" << std::endl;
}
break;
}
}
catch (std::exception const &exc)
{
exceptionHandler__(exc);
}
inline void ParserBase::reduce__(PI__ const &pi)
{
d_token__ = pi.d_nonTerm;
pop__(pi.d_size);
}
// If d_token__ is _UNDETERMINED_ then if d_nextToken__ is _UNDETERMINED_ another
// token is obtained from lex(). Then d_nextToken__ is assigned to d_token__.
void Parser::nextToken()
{
if (d_token__ != _UNDETERMINED_) // no need for a token: got one
return; // already
if (d_nextToken__ != _UNDETERMINED_)
{
popToken__(); // consume pending token
}
else
{
++d_acceptedTokens__; // accept another token (see
// errorRecover())
d_token__ = lex();
if (d_token__ <= 0)
d_token__ = _EOF_;
}
print();
}
// if the final transition is negative, then we should reduce by the rule
// given by its positive value. Note that the `recovery' parameter is only
// used with the --debug option
int Parser::lookup(bool recovery)
{
// $insert threading
SR__ *sr = s_state[d_state__]; // get the appropriate state-table
int lastIdx = sr->d_lastIdx; // sentinel-index in the SR__ array
SR__ *lastElementPtr = sr + lastIdx;
lastElementPtr->d_token = d_token__; // set search-token
SR__ *elementPtr = sr + 1; // start the search at s_xx[1]
while (elementPtr->d_token != d_token__)
++elementPtr;
if (elementPtr == lastElementPtr) // reached the last element
{
if (elementPtr->d_action < 0) // default reduction
{
return elementPtr->d_action;
}
// No default reduction, so token not found, so error.
throw UNEXPECTED_TOKEN__;
}
// not at the last element: inspect the nature of the action
// (< 0: reduce, 0: ACCEPT, > 0: shift)
int action = elementPtr->d_action;
return action;
}
// When an error has occurred, pop elements off the stack until the top
// state has an error-item. If none is found, the default recovery
// mode (which is to abort) is activated.
//
// If EOF is encountered without being appropriate for the current state,
// then the error recovery will fall back to the default recovery mode.
// (i.e., parsing terminates)
void Parser::errorRecovery()
try
{
if (d_acceptedTokens__ >= d_requiredTokens__)// only generate an error-
{ // message if enough tokens
++d_nErrors__; // were accepted. Otherwise
error("Syntax error"); // simply skip input
}
// get the error state
while (not (s_state[top__()][0].d_type & ERR_ITEM))
{
pop__();
}
// In the error state, lookup a token allowing us to proceed.
// Continuation may be possible following multiple reductions,
// but eventuall a shift will be used, requiring the retrieval of
// a terminal token. If a retrieved token doesn't match, the catch below
// will ensure the next token is requested in the while(true) block
// implemented below:
int lastToken = d_token__; // give the unexpected token a
// chance to be processed
// again.
pushToken__(_error_); // specify _error_ as next token
push__(lookup(true)); // push the error state
d_token__ = lastToken; // reactivate the unexpected
// token (we're now in an
// ERROR state).
bool gotToken = true; // the next token is a terminal
while (true)
{
try
{
if (s_state[d_state__]->d_type & REQ_TOKEN)
{
gotToken = d_token__ == _UNDETERMINED_;
nextToken(); // obtain next token
}
int action = lookup(true);
if (action > 0) // push a new state
{
push__(action);
popToken__();
if (gotToken)
{
d_acceptedTokens__ = 0;
return;
}
}
else if (action < 0)
{
// no actions executed on recovery but save an already
// available token:
if (d_token__ != _UNDETERMINED_)
pushToken__(d_token__);
// next token is the rule's LHS
reduce__(s_productionInfo[-action]);
}
else
ABORT(); // abort when accepting during
// error recovery
}
catch (...)
{
if (d_token__ == _EOF_)
ABORT(); // saw inappropriate _EOF_
popToken__(); // failing token now skipped
}
}
}
catch (ErrorRecovery__) // This is: DEFAULT_RECOVERY_MODE
{
ABORT();
}
// The parsing algorithm:
// Initially, state 0 is pushed on the stack, and d_token__ as well as
// d_nextToken__ are initialized to _UNDETERMINED_.
//
// Then, in an eternal loop:
//
// 1. If a state does not have REQ_TOKEN no token is assigned to
// d_token__. If the state has REQ_TOKEN, nextToken() is called to
// determine d_nextToken__ and d_token__ is set to
// d_nextToken__. nextToken() will not call lex() unless d_nextToken__ is
// _UNDETERMINED_.
//
// 2. lookup() is called:
// d_token__ is stored in the final element's d_token field of the
// state's SR_ array.
//
// 3. The current token is looked up in the state's SR_ array
//
// 4. Depending on the result of the lookup() function the next state is
// shifted on the parser's stack, a reduction by some rule is applied,
// or the parsing function returns ACCEPT(). When a reduction is
// called for, any action that may have been defined for that
// reduction is executed.
//
// 5. An error occurs if d_token__ is not found, and the state has no
// default reduction. Error handling was described at the top of this
// file.
int Parser::parse()
try
{
push__(0); // initial state
clearin(); // clear the tokens.
while (true)
{
try
{
if (s_state[d_state__]->d_type & REQ_TOKEN)
nextToken(); // obtain next token
int action = lookup(false); // lookup d_token__ in d_state__
if (action > 0) // SHIFT: push a new state
{
push__(action);
popToken__(); // token processed
}
else if (action < 0) // REDUCE: execute and pop.
{
executeAction(-action);
// next token is the rule's LHS
reduce__(s_productionInfo[-action]);
}
else
ACCEPT();
}
catch (ErrorRecovery__)
{
errorRecovery();
}
}
}
catch (Return__ retValue)
{
return retValue;
}
| [
"laszlo@eclick.co.hu"
] | laszlo@eclick.co.hu |
554b12c80fdf9381c65a3b05ffdf0c6b31738fa4 | e87caa6011c4f1bbaa71b8fdcd937a94bdbaedb3 | /NTech_2D_Crystal/ResourceManager.cpp | 4b805908225ac692d81e8bd93d3f3f83f947f293 | [] | no_license | CptNO/NTech_2D_Crystal | 6767a536b32b37d5cc680e8069f984808d23f949 | c94109ab07ae271757bfbf3ed07dc832755a715c | refs/heads/master | 2023-01-22T16:32:13.359587 | 2020-12-08T16:13:18 | 2020-12-08T16:13:18 | 319,690,404 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 236 | cpp | #include "ResourceManager.h"
namespace NTCrystal {
TextureCache ResourceManager::m_textureCache;
GLTexture ResourceManager::getTexture(std::string texturePath) {
return m_textureCache.getTexture(texturePath);
}
} | [
"iv_novosel@hotmail.com"
] | iv_novosel@hotmail.com |
eb02c250bf3d7690a0075662af65abe889ef2585 | c4baf3d6e71be34ab4ad5d52ce9848cc6b71e794 | /ByteDance/Tree/437-PathSumIII.cpp | 44407510a6def325de466a2d49b49c0fc91fc877 | [] | no_license | weiqianx/Interview | 5eda3cf6f6bad5ef5ea18960c86fb73e70c391fe | 6f445b99a58bf43fc459959438787aedad81e724 | refs/heads/main | 2023-03-24T10:58:45.887321 | 2021-03-19T03:10:10 | 2021-03-19T03:10:10 | 352,879,950 | 1 | 0 | null | 2021-03-30T05:24:18 | 2021-03-30T05:24:18 | null | UTF-8 | C++ | false | false | 2,340 | cpp | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
// prefix sum + hash map
class Solution {
public:
int targetSum = 0, result = 0;
unordered_map<int, int> seen;
// do preorder traversal
void dfs(TreeNode* root, int prefixSum) {
if (!root) return;
// update prefix sum so far
prefixSum += root->val;
// case1: path starting from the root
if (prefixSum == targetSum) result++;
// case2: path starting from the middle of the tree
// if any interval summing up to target sum, calculate the number of nodes within that interval
result += seen[prefixSum - targetSum];
// update map
seen[prefixSum]++;
// search left and right subtree
dfs(root->left, prefixSum);
dfs(root->right, prefixSum);
// remove the current sum from map, backtracking
seen[prefixSum]--;
}
int pathSum(TreeNode* root, int sum) {
targetSum = sum;
dfs(root, 0);
return result;
}
};
// dfs + recursion
class Solution {
public:
int result = 0;
int pathSum(TreeNode* root, int sum) {
if (!root) return result;
sumUp(root, sum);
pathSum(root->left, sum);
pathSum(root->right, sum);
return result;
}
// check if contains any desired paths.
void sumUp(TreeNode* root, int sum) {
if (!root) return;
if (root->val == sum) result++;
sumUp(root->left, sum - root->val);
sumUp(root->right, sum - root->val);
}
};
// DFS + recursion
class Solution {
public:
int pathSum(TreeNode* root, int sum) {
if (!root) return 0;
return pathSumFromRoot(root, sum) + pathSum(root->left, sum) + pathSum(root->right, sum);
}
int pathSumFromRoot(TreeNode* root, int sum) {
if (!root) return 0;
int count = root->val == sum ? 1 : 0;
return count + pathSumFromRoot(root->left, sum - root->val) + pathSumFromRoot(root->right, sum - root->val);
}
};
| [
"noreply@github.com"
] | noreply@github.com |
e09c811080edf93160c6a1d8da4ca97123a91c10 | b22588340d7925b614a735bbbde1b351ad657ffc | /athena/LArCalorimeter/LArRawConditions/src/LArRampMC.cxx | 92ff80c187cc3948da2f7e729846f4cb83f51ff9 | [] | no_license | rushioda/PIXELVALID_athena | 90befe12042c1249cbb3655dde1428bb9b9a42ce | 22df23187ef85e9c3120122c8375ea0e7d8ea440 | refs/heads/master | 2020-12-14T22:01:15.365949 | 2020-01-19T03:59:35 | 2020-01-19T03:59:35 | 234,836,993 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,291 | cxx | /*
Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
#include "LArRawConditions/LArRampMC.h"
#include "AthenaKernel/getMessageSvc.h"
#include "LArElecCalib/ILArMCSymTool.h"
#include <iostream>
using namespace std ;
LArRampMC::LArRampMC() : LArRampComplete() , m_larmcsym("LArMCSymTool")
{
}
StatusCode LArRampMC::initialize()
{
if(m_larmcsym.retrieve().isFailure()){
MsgStream log(Athena::getMessageSvc(), "LArRampMC");
log << MSG::WARNING << "Could not retrieve LArMCSymTool " << endreq;
return (StatusCode::FAILURE);
}
return (LArRampCompleteBase::initialize()) ;
}
LArRampMC::~LArRampMC() {}
/* retrieve Ramp ******************************************************
*/
LArRampMC::RampRef_t LArRampMC::ADC2DAC(const HWIdentifier& CellID,int gain) const
{
// if(!m_larmcsym) initialize();
// symmetrize CellID for MC usage
HWIdentifier SymCellID = m_larmcsym->symOnline(CellID);
return LArRampComplete::ADC2DAC(SymCellID,gain);
}
LArRampMC::RampRef_t LArRampMC::ADC2DAC(const Identifier& CellID,int gain) const
{
// if(!m_larmcsym) initialize();
// symmetrize CellID for MC usage
HWIdentifier SymCellID = m_larmcsym->symOnline(CellID);
return LArRampComplete::ADC2DAC(SymCellID,gain);
}
| [
"rushioda@lxplus754.cern.ch"
] | rushioda@lxplus754.cern.ch |
780c9f18df7bb671e4e342f25795475c1c95ba15 | fa42b384f3670e8de3d8a6e02efceb870d7a885c | /Theater/Theater/SeatSelection.cpp | 7d55e4d3e6fdcaeec650ebd07e8b4fd502b42648 | [] | no_license | e-esparza/cs3376-assignments | 1d76a0e5c3eea9efe98d82130d51c04607d8a399 | 1a206d6d7763f3d60d9540853bc6a21bd5e76502 | refs/heads/master | 2020-02-26T15:14:04.605809 | 2013-05-02T02:13:24 | 2013-05-02T02:13:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,266 | cpp | //
// SeatSelection.cpp
// Assignment3
//
// Created by Michael Muggler on 3/24/13.
// Copyright (c) 2013 Michael Muggler. All rights reserved.
//
#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include "SeatSelection.h"
using namespace std;
SeatSelection::SeatSelection(int startingRow, int rowCount)
{
total = rowCount*10;
this->startingRow = startingRow;
for( int i = 0; i < rowCount; i++ )
{
vector<string> row;
row.push_back("J");
row.push_back("I");
row.push_back("H");
row.push_back("G");
row.push_back("F");
row.push_back("E");
row.push_back("D");
row.push_back("C");
row.push_back("B");
row.push_back("A");
seats.push_back(row);
}
}
void SeatSelection::assignSeats(int seatCount)
{
if( seatCount > 10 ) {
cout << "Sorry, your reservation size cannot exceed 10." << endl;
return;
}
if( total <= 0 ) {
cout << "Sorry, not enough seats. Please come again!" << endl;
return;
}
if( (total-seatCount) < 0 ) {
cout << "Sorry, only " << total << ((total > 1) ? " seats are " : " seat is ") << "available." << endl;
return;
}
cout << "Your seats are: ";
while( seatCount > 0 )
{
bool found;
found = false;
int rowIndex;
for( rowIndex = 0; rowIndex < seats.size(); rowIndex++ )
{
std::vector<string>::reverse_iterator rit = seats[rowIndex].rbegin();
for (rit = seats[rowIndex].rbegin(); rit!= seats[rowIndex].rend(); ++rit) {
cout << (rowIndex+(this->startingRow)) << *rit << " ";
found = true;
seatCount--;
total--;
seats[rowIndex].pop_back();
if ( found ) break;
}
if( found ) break;
}
}
cout << endl;
}
int SeatSelection::getAvailableSeats()
{
return total;
} | [
"michael.muggler@utdallas.edu"
] | michael.muggler@utdallas.edu |
ef299dd5a458cff9680f56ac921b2ba7d80eb03a | ba5d1d776888be6ae9688d850f0445d80973ee8f | /game/shared/util_shared.cpp | bc384c9817a1ad1d3c9137df2313b97390544ad6 | [
"MIT"
] | permissive | BerntA/tfo-code | eb127b86111dce2b6f66e98c9476adc9ddbbd267 | b82efd940246af8fe90cb76fa6a96bba42c277b7 | refs/heads/master | 2023-08-17T06:57:13.107323 | 2023-08-09T18:37:54 | 2023-08-09T18:37:54 | 41,260,457 | 16 | 5 | MIT | 2023-05-29T23:35:33 | 2015-08-23T17:52:50 | C++ | UTF-8 | C++ | false | false | 34,267 | cpp | //========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "mathlib/mathlib.h"
#include "util_shared.h"
#include "model_types.h"
#include "convar.h"
#include "IEffects.h"
#include "vphysics/object_hash.h"
#include "mathlib/IceKey.H"
#include "checksum_crc.h"
#ifdef TF_CLIENT_DLL
#include "cdll_util.h"
#endif
#include "particle_parse.h"
#include "KeyValues.h"
#include "time.h"
#ifdef USES_ECON_ITEMS
#include "econ_item_constants.h"
#include "econ_holidays.h"
#include "rtime.h"
#endif // USES_ECON_ITEMS
#ifdef CLIENT_DLL
#include "c_te_effect_dispatch.h"
#else
#include "te_effect_dispatch.h"
bool NPC_CheckBrushExclude( CBaseEntity *pEntity, CBaseEntity *pBrush );
#endif
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
ConVar r_visualizetraces( "r_visualizetraces", "0", FCVAR_CHEAT );
ConVar developer("developer", "0", 0, "Set developer message level" ); // developer mode
float UTIL_VecToYaw( const Vector &vec )
{
if (vec.y == 0 && vec.x == 0)
return 0;
float yaw = atan2( vec.y, vec.x );
yaw = RAD2DEG(yaw);
if (yaw < 0)
yaw += 360;
return yaw;
}
float UTIL_VecToPitch( const Vector &vec )
{
if (vec.y == 0 && vec.x == 0)
{
if (vec.z < 0)
return 180.0;
else
return -180.0;
}
float dist = vec.Length2D();
float pitch = atan2( -vec.z, dist );
pitch = RAD2DEG(pitch);
return pitch;
}
float UTIL_VecToYaw( const matrix3x4_t &matrix, const Vector &vec )
{
Vector tmp = vec;
VectorNormalize( tmp );
float x = matrix[0][0] * tmp.x + matrix[1][0] * tmp.y + matrix[2][0] * tmp.z;
float y = matrix[0][1] * tmp.x + matrix[1][1] * tmp.y + matrix[2][1] * tmp.z;
if (x == 0.0f && y == 0.0f)
return 0.0f;
float yaw = atan2( -y, x );
yaw = RAD2DEG(yaw);
if (yaw < 0)
yaw += 360;
return yaw;
}
float UTIL_VecToPitch( const matrix3x4_t &matrix, const Vector &vec )
{
Vector tmp = vec;
VectorNormalize( tmp );
float x = matrix[0][0] * tmp.x + matrix[1][0] * tmp.y + matrix[2][0] * tmp.z;
float z = matrix[0][2] * tmp.x + matrix[1][2] * tmp.y + matrix[2][2] * tmp.z;
if (x == 0.0f && z == 0.0f)
return 0.0f;
float pitch = atan2( z, x );
pitch = RAD2DEG(pitch);
if (pitch < 0)
pitch += 360;
return pitch;
}
Vector UTIL_YawToVector( float yaw )
{
Vector ret;
ret.z = 0;
float angle = DEG2RAD( yaw );
SinCos( angle, &ret.y, &ret.x );
return ret;
}
//-----------------------------------------------------------------------------
// Purpose: Helper function get get determinisitc random values for shared/prediction code
// Input : seedvalue -
// *module -
// line -
// Output : static int
//-----------------------------------------------------------------------------
static int SeedFileLineHash( int seedvalue, const char *sharedname, int additionalSeed )
{
CRC32_t retval;
CRC32_Init( &retval );
CRC32_ProcessBuffer( &retval, (void *)&seedvalue, sizeof( int ) );
CRC32_ProcessBuffer( &retval, (void *)&additionalSeed, sizeof( int ) );
CRC32_ProcessBuffer( &retval, (void *)sharedname, Q_strlen( sharedname ) );
CRC32_Final( &retval );
return (int)( retval );
}
float SharedRandomFloat( const char *sharedname, float flMinVal, float flMaxVal, int additionalSeed /*=0*/ )
{
Assert( CBaseEntity::GetPredictionRandomSeed() != -1 );
int seed = SeedFileLineHash( CBaseEntity::GetPredictionRandomSeed(), sharedname, additionalSeed );
RandomSeed( seed );
return RandomFloat( flMinVal, flMaxVal );
}
int SharedRandomInt( const char *sharedname, int iMinVal, int iMaxVal, int additionalSeed /*=0*/ )
{
Assert( CBaseEntity::GetPredictionRandomSeed() != -1 );
int seed = SeedFileLineHash( CBaseEntity::GetPredictionRandomSeed(), sharedname, additionalSeed );
RandomSeed( seed );
return RandomInt( iMinVal, iMaxVal );
}
Vector SharedRandomVector( const char *sharedname, float minVal, float maxVal, int additionalSeed /*=0*/ )
{
Assert( CBaseEntity::GetPredictionRandomSeed() != -1 );
int seed = SeedFileLineHash( CBaseEntity::GetPredictionRandomSeed(), sharedname, additionalSeed );
RandomSeed( seed );
// HACK: Can't call RandomVector/Angle because it uses rand() not vstlib Random*() functions!
// Get a random vector.
Vector random;
random.x = RandomFloat( minVal, maxVal );
random.y = RandomFloat( minVal, maxVal );
random.z = RandomFloat( minVal, maxVal );
return random;
}
QAngle SharedRandomAngle( const char *sharedname, float minVal, float maxVal, int additionalSeed /*=0*/ )
{
Assert( CBaseEntity::GetPredictionRandomSeed() != -1 );
int seed = SeedFileLineHash( CBaseEntity::GetPredictionRandomSeed(), sharedname, additionalSeed );
RandomSeed( seed );
// HACK: Can't call RandomVector/Angle because it uses rand() not vstlib Random*() functions!
// Get a random vector.
Vector random;
random.x = RandomFloat( minVal, maxVal );
random.y = RandomFloat( minVal, maxVal );
random.z = RandomFloat( minVal, maxVal );
return QAngle( random.x, random.y, random.z );
}
//-----------------------------------------------------------------------------
//
// Shared client/server trace filter code
//
//-----------------------------------------------------------------------------
bool PassServerEntityFilter( const IHandleEntity *pTouch, const IHandleEntity *pPass )
{
if ( !pPass )
return true;
if ( pTouch == pPass )
return false;
const CBaseEntity *pEntTouch = EntityFromEntityHandle( pTouch );
const CBaseEntity *pEntPass = EntityFromEntityHandle( pPass );
if ( !pEntTouch || !pEntPass )
return true;
// don't clip against own missiles
if ( pEntTouch->GetOwnerEntity() == pEntPass )
return false;
// don't clip against owner
if ( pEntPass->GetOwnerEntity() == pEntTouch )
return false;
return true;
}
//-----------------------------------------------------------------------------
// A standard filter to be applied to just about everything.
//-----------------------------------------------------------------------------
bool StandardFilterRules( IHandleEntity *pHandleEntity, int fContentsMask )
{
CBaseEntity *pCollide = EntityFromEntityHandle( pHandleEntity );
// Static prop case...
if ( !pCollide )
return true;
SolidType_t solid = pCollide->GetSolid();
const model_t *pModel = pCollide->GetModel();
if ( ( modelinfo->GetModelType( pModel ) != mod_brush ) || (solid != SOLID_BSP && solid != SOLID_VPHYSICS) )
{
if ( (fContentsMask & CONTENTS_MONSTER) == 0 )
return false;
}
// This code is used to cull out tests against see-thru entities
if ( !(fContentsMask & CONTENTS_WINDOW) && pCollide->IsTransparent() )
return false;
// FIXME: this is to skip BSP models that are entities that can be
// potentially moved/deleted, similar to a monster but doors don't seem to
// be flagged as monsters
// FIXME: the FL_WORLDBRUSH looked promising, but it needs to be set on
// everything that's actually a worldbrush and it currently isn't
if ( !(fContentsMask & CONTENTS_MOVEABLE) && (pCollide->GetMoveType() == MOVETYPE_PUSH))// !(touch->flags & FL_WORLDBRUSH) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Simple trace filter
//-----------------------------------------------------------------------------
CTraceFilterSimple::CTraceFilterSimple( const IHandleEntity *passedict, int collisionGroup,
ShouldHitFunc_t pExtraShouldHitFunc )
{
m_pPassEnt = passedict;
m_collisionGroup = collisionGroup;
m_pExtraShouldHitCheckFunction = pExtraShouldHitFunc;
}
//-----------------------------------------------------------------------------
// The trace filter!
//-----------------------------------------------------------------------------
bool CTraceFilterSimple::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
if ( !StandardFilterRules( pHandleEntity, contentsMask ) )
return false;
if ( m_pPassEnt )
{
if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt ) )
{
return false;
}
}
// Don't test if the game code tells us we should ignore this collision...
CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
if ( !pEntity )
return false;
if ( !pEntity->ShouldCollide( m_collisionGroup, contentsMask ) )
return false;
if ( pEntity && !g_pGameRules->ShouldCollide( m_collisionGroup, pEntity->GetCollisionGroup() ) )
return false;
if ( m_pExtraShouldHitCheckFunction &&
(! ( m_pExtraShouldHitCheckFunction( pHandleEntity, contentsMask ) ) ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Trace filter that only hits NPCs and the player
//-----------------------------------------------------------------------------
bool CTraceFilterOnlyNPCsAndPlayer::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
if ( CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask ) )
{
CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
if ( !pEntity )
return false;
#ifdef CSTRIKE_DLL
#ifndef CLIENT_DLL
if ( pEntity->Classify() == CLASS_PLAYER_ALLY )
return true; // CS hostages are CLASS_PLAYER_ALLY but not IsNPC()
#endif // !CLIENT_DLL
#endif // CSTRIKE_DLL
return (pEntity->IsNPC() || pEntity->IsPlayer());
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Trace filter that only hits anything but NPCs and the player
//-----------------------------------------------------------------------------
bool CTraceFilterNoNPCsOrPlayer::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
if ( CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask ) )
{
CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
if ( !pEntity )
return NULL;
#ifndef CLIENT_DLL
if ( pEntity->Classify() == CLASS_PLAYER_ALLY )
return false; // CS hostages are CLASS_PLAYER_ALLY but not IsNPC()
#endif
return (!pEntity->IsNPC() && !pEntity->IsPlayer());
}
return false;
}
//-----------------------------------------------------------------------------
// Trace filter that skips two entities
//-----------------------------------------------------------------------------
CTraceFilterSkipTwoEntities::CTraceFilterSkipTwoEntities( const IHandleEntity *passentity, const IHandleEntity *passentity2, int collisionGroup ) :
BaseClass( passentity, collisionGroup ), m_pPassEnt2(passentity2)
{
}
bool CTraceFilterSkipTwoEntities::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
Assert( pHandleEntity );
if ( !PassServerEntityFilter( pHandleEntity, m_pPassEnt2 ) )
return false;
return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask );
}
//-----------------------------------------------------------------------------
// Trace filter that can take a list of entities to ignore
//-----------------------------------------------------------------------------
CTraceFilterSimpleList::CTraceFilterSimpleList( int collisionGroup ) :
CTraceFilterSimple( NULL, collisionGroup )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTraceFilterSimpleList::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
if ( m_PassEntities.Find(pHandleEntity) != m_PassEntities.InvalidIndex() )
return false;
return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask );
}
//-----------------------------------------------------------------------------
// Purpose: Add an entity to my list of entities to ignore in the trace
//-----------------------------------------------------------------------------
void CTraceFilterSimpleList::AddEntityToIgnore( IHandleEntity *pEntity )
{
m_PassEntities.AddToTail( pEntity );
}
//-----------------------------------------------------------------------------
// Purpose: Custom trace filter used for NPC LOS traces
//-----------------------------------------------------------------------------
CTraceFilterLOS::CTraceFilterLOS( IHandleEntity *pHandleEntity, int collisionGroup, IHandleEntity *pHandleEntity2 ) :
CTraceFilterSkipTwoEntities( pHandleEntity, pHandleEntity2, collisionGroup )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTraceFilterLOS::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
if ( !pEntity->BlocksLOS() )
return false;
return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask );
}
//-----------------------------------------------------------------------------
// Trace filter that can take a classname to ignore
//-----------------------------------------------------------------------------
CTraceFilterSkipClassname::CTraceFilterSkipClassname( const IHandleEntity *passentity, const char *pchClassname, int collisionGroup ) :
CTraceFilterSimple( passentity, collisionGroup ), m_pchClassname( pchClassname )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTraceFilterSkipClassname::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
if ( !pEntity || FClassnameIs( pEntity, m_pchClassname ) )
return false;
return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask );
}
//-----------------------------------------------------------------------------
// Trace filter that skips two classnames
//-----------------------------------------------------------------------------
CTraceFilterSkipTwoClassnames::CTraceFilterSkipTwoClassnames( const IHandleEntity *passentity, const char *pchClassname, const char *pchClassname2, int collisionGroup ) :
BaseClass( passentity, pchClassname, collisionGroup ), m_pchClassname2(pchClassname2)
{
}
bool CTraceFilterSkipTwoClassnames::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
if ( !pEntity || FClassnameIs( pEntity, m_pchClassname2 ) )
return false;
return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask );
}
//-----------------------------------------------------------------------------
// Trace filter that can take a list of entities to ignore
//-----------------------------------------------------------------------------
CTraceFilterSimpleClassnameList::CTraceFilterSimpleClassnameList( const IHandleEntity *passentity, int collisionGroup ) :
CTraceFilterSimple( passentity, collisionGroup )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTraceFilterSimpleClassnameList::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
if ( !pEntity )
return false;
for ( int i = 0; i < m_PassClassnames.Count(); ++i )
{
if ( FClassnameIs( pEntity, m_PassClassnames[ i ] ) )
return false;
}
return CTraceFilterSimple::ShouldHitEntity( pHandleEntity, contentsMask );
}
//-----------------------------------------------------------------------------
// Purpose: Add an entity to my list of entities to ignore in the trace
//-----------------------------------------------------------------------------
void CTraceFilterSimpleClassnameList::AddClassnameToIgnore( const char *pchClassname )
{
m_PassClassnames.AddToTail( pchClassname );
}
CTraceFilterChain::CTraceFilterChain( ITraceFilter *pTraceFilter1, ITraceFilter *pTraceFilter2 )
{
m_pTraceFilter1 = pTraceFilter1;
m_pTraceFilter2 = pTraceFilter2;
}
bool CTraceFilterChain::ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
bool bResult1 = true;
bool bResult2 = true;
if ( m_pTraceFilter1 )
bResult1 = m_pTraceFilter1->ShouldHitEntity( pHandleEntity, contentsMask );
if ( m_pTraceFilter2 )
bResult2 = m_pTraceFilter2->ShouldHitEntity( pHandleEntity, contentsMask );
return ( bResult1 && bResult2 );
}
//-----------------------------------------------------------------------------
// Sweeps against a particular model, using collision rules
//-----------------------------------------------------------------------------
void UTIL_TraceModel( const Vector &vecStart, const Vector &vecEnd, const Vector &hullMin,
const Vector &hullMax, CBaseEntity *pentModel, int collisionGroup, trace_t *ptr )
{
// Cull it....
if ( pentModel && pentModel->ShouldCollide( collisionGroup, MASK_ALL ) )
{
Ray_t ray;
ray.Init( vecStart, vecEnd, hullMin, hullMax );
enginetrace->ClipRayToEntity( ray, MASK_ALL, pentModel, ptr );
}
else
{
memset( ptr, 0, sizeof(trace_t) );
ptr->fraction = 1.0f;
}
}
bool UTIL_EntityHasMatchingRootParent( CBaseEntity *pRootParent, CBaseEntity *pEntity )
{
if ( pRootParent )
{
// NOTE: Don't let siblings/parents collide.
if ( pRootParent == pEntity->GetRootMoveParent() )
return true;
if ( pEntity->GetOwnerEntity() && pRootParent == pEntity->GetOwnerEntity()->GetRootMoveParent() )
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Sweep an entity from the starting to the ending position
//-----------------------------------------------------------------------------
class CTraceFilterEntity : public CTraceFilterSimple
{
DECLARE_CLASS( CTraceFilterEntity, CTraceFilterSimple );
public:
CTraceFilterEntity( CBaseEntity *pEntity, int nCollisionGroup )
: CTraceFilterSimple( pEntity, nCollisionGroup )
{
m_pRootParent = pEntity->GetRootMoveParent();
m_pEntity = pEntity;
m_checkHash = g_EntityCollisionHash->IsObjectInHash(pEntity);
}
bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
CBaseEntity *pEntity = EntityFromEntityHandle( pHandleEntity );
if ( !pEntity )
return false;
// Check parents against each other
// NOTE: Don't let siblings/parents collide.
if ( UTIL_EntityHasMatchingRootParent( m_pRootParent, pEntity ) )
return false;
if ( m_checkHash )
{
if ( g_EntityCollisionHash->IsObjectPairInHash( m_pEntity, pEntity ) )
return false;
}
#ifndef CLIENT_DLL
if ( m_pEntity->IsNPC() )
{
if ( NPC_CheckBrushExclude( m_pEntity, pEntity ) )
return false;
}
#endif
return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask );
}
private:
CBaseEntity *m_pRootParent;
CBaseEntity *m_pEntity;
bool m_checkHash;
};
class CTraceFilterEntityIgnoreOther : public CTraceFilterEntity
{
DECLARE_CLASS( CTraceFilterEntityIgnoreOther, CTraceFilterEntity );
public:
CTraceFilterEntityIgnoreOther( CBaseEntity *pEntity, const IHandleEntity *pIgnore, int nCollisionGroup ) :
CTraceFilterEntity( pEntity, nCollisionGroup ), m_pIgnoreOther( pIgnore )
{
}
bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask )
{
if ( pHandleEntity == m_pIgnoreOther )
return false;
return BaseClass::ShouldHitEntity( pHandleEntity, contentsMask );
}
private:
const IHandleEntity *m_pIgnoreOther;
};
//-----------------------------------------------------------------------------
// Sweeps a particular entity through the world
//-----------------------------------------------------------------------------
void UTIL_TraceEntity( CBaseEntity *pEntity, const Vector &vecAbsStart, const Vector &vecAbsEnd, unsigned int mask, trace_t *ptr )
{
ICollideable *pCollision = pEntity->GetCollideable();
// Adding this assertion here so game code catches it, but really the assertion belongs in the engine
// because one day, rotated collideables will work!
Assert( pCollision->GetCollisionAngles() == vec3_angle );
CTraceFilterEntity traceFilter( pEntity, pCollision->GetCollisionGroup() );
#ifdef PORTAL
UTIL_Portal_TraceEntity( pEntity, vecAbsStart, vecAbsEnd, mask, &traceFilter, ptr );
#else
enginetrace->SweepCollideable( pCollision, vecAbsStart, vecAbsEnd, pCollision->GetCollisionAngles(), mask, &traceFilter, ptr );
#endif
}
void UTIL_TraceEntity( CBaseEntity *pEntity, const Vector &vecAbsStart, const Vector &vecAbsEnd,
unsigned int mask, const IHandleEntity *pIgnore, int nCollisionGroup, trace_t *ptr )
{
ICollideable *pCollision;
pCollision = pEntity->GetCollideable();
// Adding this assertion here so game code catches it, but really the assertion belongs in the engine
// because one day, rotated collideables will work!
Assert( pCollision->GetCollisionAngles() == vec3_angle );
CTraceFilterEntityIgnoreOther traceFilter( pEntity, pIgnore, nCollisionGroup );
#ifdef PORTAL
UTIL_Portal_TraceEntity( pEntity, vecAbsStart, vecAbsEnd, mask, &traceFilter, ptr );
#else
enginetrace->SweepCollideable( pCollision, vecAbsStart, vecAbsEnd, pCollision->GetCollisionAngles(), mask, &traceFilter, ptr );
#endif
}
void UTIL_TraceEntity( CBaseEntity *pEntity, const Vector &vecAbsStart, const Vector &vecAbsEnd,
unsigned int mask, ITraceFilter *pFilter, trace_t *ptr )
{
ICollideable *pCollision;
pCollision = pEntity->GetCollideable();
// Adding this assertion here so game code catches it, but really the assertion belongs in the engine
// because one day, rotated collideables will work!
Assert( pCollision->GetCollisionAngles() == vec3_angle );
#ifdef PORTAL
UTIL_Portal_TraceEntity( pEntity, vecAbsStart, vecAbsEnd, mask, pFilter, ptr );
#else
enginetrace->SweepCollideable( pCollision, vecAbsStart, vecAbsEnd, pCollision->GetCollisionAngles(), mask, pFilter, ptr );
#endif
}
// ----
// This is basically a regular TraceLine that uses the FilterEntity filter.
void UTIL_TraceLineFilterEntity( CBaseEntity *pEntity, const Vector &vecAbsStart, const Vector &vecAbsEnd,
unsigned int mask, int nCollisionGroup, trace_t *ptr )
{
CTraceFilterEntity traceFilter( pEntity, nCollisionGroup );
UTIL_TraceLine( vecAbsStart, vecAbsEnd, mask, &traceFilter, ptr );
}
void UTIL_ClipTraceToPlayers( const Vector& vecAbsStart, const Vector& vecAbsEnd, unsigned int mask, ITraceFilter *filter, trace_t *tr )
{
trace_t playerTrace;
Ray_t ray;
float smallestFraction = tr->fraction;
const float maxRange = 60.0f;
ray.Init( vecAbsStart, vecAbsEnd );
for ( int k = 1; k <= gpGlobals->maxClients; ++k )
{
CBasePlayer *player = UTIL_PlayerByIndex( k );
if ( !player || !player->IsAlive() )
continue;
#ifdef CLIENT_DLL
if ( player->IsDormant() )
continue;
#endif // CLIENT_DLL
if ( filter && filter->ShouldHitEntity( player, mask ) == false )
continue;
float range = DistanceToRay( player->WorldSpaceCenter(), vecAbsStart, vecAbsEnd );
if ( range < 0.0f || range > maxRange )
continue;
enginetrace->ClipRayToEntity( ray, mask|CONTENTS_HITBOX, player, &playerTrace );
if ( playerTrace.fraction < smallestFraction )
{
// we shortened the ray - save off the trace
*tr = playerTrace;
smallestFraction = playerTrace.fraction;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Make a tracer using a particle effect
//-----------------------------------------------------------------------------
void UTIL_ParticleTracer( const char *pszTracerEffectName, const Vector &vecStart, const Vector &vecEnd,
int iEntIndex, int iAttachment, bool bWhiz )
{
int iParticleIndex = GetParticleSystemIndex( pszTracerEffectName );
UTIL_Tracer( vecStart, vecEnd, iEntIndex, iAttachment, 0, bWhiz, "ParticleTracer", iParticleIndex );
}
//-----------------------------------------------------------------------------
// Purpose: Make a tracer effect using the old, non-particle system, tracer effects.
//-----------------------------------------------------------------------------
void UTIL_Tracer( const Vector &vecStart, const Vector &vecEnd, int iEntIndex,
int iAttachment, float flVelocity, bool bWhiz, const char *pCustomTracerName, int iParticleID )
{
CEffectData data;
data.m_vStart = vecStart;
data.m_vOrigin = vecEnd;
#ifdef CLIENT_DLL
data.m_hEntity = ClientEntityList().EntIndexToHandle( iEntIndex );
#else
data.m_nEntIndex = iEntIndex;
#endif
data.m_flScale = flVelocity;
data.m_nHitBox = iParticleID;
// Flags
if ( bWhiz )
{
data.m_fFlags |= TRACER_FLAG_WHIZ;
}
if ( iAttachment != TRACER_DONT_USE_ATTACHMENT )
{
data.m_fFlags |= TRACER_FLAG_USEATTACHMENT;
data.m_nAttachmentIndex = iAttachment;
}
// Fire it off
if ( pCustomTracerName )
{
DispatchEffect( pCustomTracerName, data );
}
else
{
DispatchEffect( "Tracer", data );
}
}
void UTIL_BloodDrips( const Vector &origin, const Vector &direction, int color, int amount )
{
if ( !UTIL_ShouldShowBlood( color ) )
return;
if ( color == DONT_BLEED || amount == 0 )
return;
if ( g_Language.GetInt() == LANGUAGE_GERMAN && color == BLOOD_COLOR_RED )
color = 0;
if ( g_pGameRules->IsMultiplayer() )
{
// scale up blood effect in multiplayer for better visibility
amount *= 5;
}
if ( amount > 255 )
amount = 255;
if (color == BLOOD_COLOR_MECH)
{
g_pEffects->Sparks(origin);
if (random->RandomFloat(0, 2) >= 1)
{
UTIL_Smoke(origin, random->RandomInt(10, 15), 10);
}
}
else
{
// Normal blood impact
UTIL_BloodImpact( origin, direction, color, amount );
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns low violence settings
//-----------------------------------------------------------------------------
static ConVar violence_hblood( "violence_hblood","1", 0, "Draw human blood" );
static ConVar violence_hgibs( "violence_hgibs","1", 0, "Show human gib entities" );
static ConVar violence_ablood( "violence_ablood","1", 0, "Draw alien blood" );
static ConVar violence_agibs( "violence_agibs","1", 0, "Show alien gib entities" );
bool UTIL_IsLowViolence( void )
{
// These convars are no longer necessary -- the engine is the final arbiter of
// violence settings -- but they're here for legacy support and for testing low
// violence when the engine is in normal violence mode.
if ( !violence_hblood.GetBool() || !violence_ablood.GetBool() || !violence_hgibs.GetBool() || !violence_agibs.GetBool() )
return true;
return engine->IsLowViolence();
}
bool UTIL_ShouldShowBlood( int color )
{
if ( color != DONT_BLEED )
{
if ( color == BLOOD_COLOR_RED )
{
return violence_hblood.GetBool();
}
else
{
return violence_ablood.GetBool();
}
}
return false;
}
//------------------------------------------------------------------------------
// Purpose : Use trace to pass a specific decal type to the entity being decaled
// Input :
// Output :
//------------------------------------------------------------------------------
void UTIL_DecalTrace( trace_t *pTrace, char const *decalName )
{
if (pTrace->fraction == 1.0)
return;
CBaseEntity *pEntity = pTrace->m_pEnt;
pEntity->DecalTrace( pTrace, decalName );
}
void UTIL_BloodDecalTrace( trace_t *pTrace, int bloodColor )
{
if ( UTIL_ShouldShowBlood( bloodColor ) )
{
if ( bloodColor == BLOOD_COLOR_RED )
{
UTIL_DecalTrace( pTrace, "Blood" );
}
else
{
UTIL_DecalTrace( pTrace, "YellowBlood" );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &pos -
// &dir -
// color -
// amount -
//-----------------------------------------------------------------------------
void UTIL_BloodImpact( const Vector &pos, const Vector &dir, int color, int amount )
{
CEffectData data;
data.m_vOrigin = pos;
data.m_vNormal = dir;
data.m_flScale = (float)amount;
data.m_nColor = (unsigned char)color;
DispatchEffect( "bloodimpact", data );
}
bool UTIL_IsSpaceEmpty( CBaseEntity *pMainEnt, const Vector &vMin, const Vector &vMax )
{
Vector vHalfDims = ( vMax - vMin ) * 0.5f;
Vector vCenter = vMin + vHalfDims;
trace_t trace;
UTIL_TraceHull( vCenter, vCenter, -vHalfDims, vHalfDims, MASK_SOLID, pMainEnt, COLLISION_GROUP_NONE, &trace );
bool bClear = ( trace.fraction == 1 && trace.allsolid != 1 && (trace.startsolid != 1) );
return bClear;
}
void UTIL_StringToFloatArray( float *pVector, int count, const char *pString )
{
char *pstr, *pfront, tempString[128];
int j;
Q_strncpy( tempString, pString, sizeof(tempString) );
pstr = pfront = tempString;
for ( j = 0; j < count; j++ ) // lifted from pr_edict.c
{
pVector[j] = atof( pfront );
// skip any leading whitespace
while ( *pstr && *pstr <= ' ' )
pstr++;
// skip to next whitespace
while ( *pstr && *pstr > ' ' )
pstr++;
if (!*pstr)
break;
pstr++;
pfront = pstr;
}
for ( j++; j < count; j++ )
{
pVector[j] = 0;
}
}
void UTIL_StringToVector( float *pVector, const char *pString )
{
UTIL_StringToFloatArray( pVector, 3, pString );
}
void UTIL_StringToIntArray( int *pVector, int count, const char *pString )
{
char *pstr, *pfront, tempString[128];
int j;
Q_strncpy( tempString, pString, sizeof(tempString) );
pstr = pfront = tempString;
for ( j = 0; j < count; j++ ) // lifted from pr_edict.c
{
pVector[j] = atoi( pfront );
while ( *pstr && *pstr != ' ' )
pstr++;
if (!*pstr)
break;
pstr++;
pfront = pstr;
}
for ( j++; j < count; j++ )
{
pVector[j] = 0;
}
}
void UTIL_StringToColor32( color32 *color, const char *pString )
{
int tmp[4];
UTIL_StringToIntArray( tmp, 4, pString );
color->r = tmp[0];
color->g = tmp[1];
color->b = tmp[2];
color->a = tmp[3];
}
#ifndef _XBOX
void UTIL_DecodeICE( unsigned char * buffer, int size, const unsigned char *key)
{
if ( !key )
return;
IceKey ice( 0 ); // level 0 = 64bit key
ice.set( key ); // set key
int blockSize = ice.blockSize();
unsigned char *temp = (unsigned char *)_alloca( PAD_NUMBER( size, blockSize ) );
unsigned char *p1 = buffer;
unsigned char *p2 = temp;
// encrypt data in 8 byte blocks
int bytesLeft = size;
while ( bytesLeft >= blockSize )
{
ice.decrypt( p1, p2 );
bytesLeft -= blockSize;
p1+=blockSize;
p2+=blockSize;
}
// copy encrypted data back to original buffer
Q_memcpy( buffer, temp, size-bytesLeft );
}
#endif
// work-around since client header doesn't like inlined gpGlobals->curtime
float IntervalTimer::Now( void ) const
{
return gpGlobals->curtime;
}
// work-around since client header doesn't like inlined gpGlobals->curtime
float CountdownTimer::Now( void ) const
{
return gpGlobals->curtime;
}
#ifdef CLIENT_DLL
CBasePlayer *UTIL_PlayerByIndex( int entindex )
{
return ToBasePlayer( ClientEntityList().GetEnt( entindex ) );
}
//=============================================================================
// HPE_BEGIN:
// [menglish] Added UTIL function for events in client win_panel which transmit the player as a user ID
//=============================================================================
CBasePlayer* UTIL_PlayerByUserId( int userID )
{
for (int i = 1; i<=gpGlobals->maxClients; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( !pPlayer )
continue;
if ( pPlayer->GetUserID() == userID )
{
return pPlayer;
}
}
return NULL;
}
//=============================================================================
// HPE_END
//=============================================================================
#endif
char* ReadAndAllocStringValue( KeyValues *pSub, const char *pName, const char *pFilename )
{
const char *pValue = pSub->GetString( pName, NULL );
if ( !pValue )
{
if ( pFilename )
{
DevWarning( "Can't get key value '%s' from file '%s'.\n", pName, pFilename );
}
return "";
}
int len = Q_strlen( pValue ) + 1;
char *pAlloced = new char[ len ];
Assert( pAlloced );
Q_strncpy( pAlloced, pValue, len );
return pAlloced;
}
int UTIL_StringFieldToInt( const char *szValue, const char **pValueStrings, int iNumStrings )
{
if ( !szValue || !szValue[0] )
return -1;
for ( int i = 0; i < iNumStrings; i++ )
{
if ( FStrEq(szValue, pValueStrings[i]) )
return i;
}
Assert(0);
return -1;
}
int find_day_of_week( struct tm& found_day, int day_of_week, int step )
{
return 0;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#ifdef USES_ECON_ITEMS
static bool s_HolidaysCalculated = false;
static CBitVec<kHolidayCount> s_HolidaysActive;
//-----------------------------------------------------------------------------
// Purpose: Used at level change and round start to re-calculate which holiday is active
//-----------------------------------------------------------------------------
void UTIL_CalculateHolidays()
{
s_HolidaysActive.ClearAll();
CRTime::UpdateRealTime();
for ( int iHoliday = 0; iHoliday < kHolidayCount; iHoliday++ )
{
if ( EconHolidays_IsHolidayActive( iHoliday, CRTime::RTime32TimeCur() ) )
{
s_HolidaysActive.Set( iHoliday );
}
}
s_HolidaysCalculated = true;
}
#endif // USES_ECON_ITEMS
bool UTIL_IsHolidayActive( /*EHoliday*/ int eHoliday )
{
#ifdef USES_ECON_ITEMS
if ( IsX360() )
return false;
if ( !s_HolidaysCalculated )
{
UTIL_CalculateHolidays();
}
return s_HolidaysActive.IsBitSet( eHoliday );
#else
return false;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int UTIL_GetHolidayForString( const char* pszHolidayName )
{
#ifdef USES_ECON_ITEMS
if ( !pszHolidayName )
return kHoliday_None;
return EconHolidays_GetHolidayForString( pszHolidayName );
#else
return 0;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char* UTIL_GetActiveHolidayString()
{
#ifdef USES_ECON_ITEMS
return EconHolidays_GetActiveHolidayString();
#else
return NULL;
#endif
}
| [
"bernta1@msn.com"
] | bernta1@msn.com |
f21f136529aef5e05fcc31f76c7116e5dc0ffe2f | 92e979498ec13e4ef1f9ff140e12865b5082c1dd | /SDK/BP_ProjectileCrossbowArrow_functions.cpp | 8dd3f11eeda24c416b4e89cd3992e2a7882b8670 | [] | no_license | ALEHACKsp/BlazingSails-SDK | ac1d98ff67983b9d8e9c527815f17233d045d44d | 900cbb934dc85f7325f1fc8845b90def2298dc2d | refs/heads/master | 2022-04-08T21:55:32.767942 | 2020-03-11T11:37:42 | 2020-03-11T11:37:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,300 | cpp |
#include "../SDK.h"
// Name: BlazingSails, Version: 1.481.81
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
namespace SDK
{
//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------
// Function BP_ProjectileCrossbowArrow.BP_ProjectileCrossbowArrow_C.UserConstructionScript
// (Event, Public, BlueprintCallable, BlueprintEvent)
void ABP_ProjectileCrossbowArrow_C::UserConstructionScript()
{
static auto fn = UObject::FindObject<UFunction>("Function BP_ProjectileCrossbowArrow.BP_ProjectileCrossbowArrow_C.UserConstructionScript");
ABP_ProjectileCrossbowArrow_C_UserConstructionScript_Params params;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function BP_ProjectileCrossbowArrow.BP_ProjectileCrossbowArrow_C.PostHit
// (BlueprintCallable, BlueprintEvent)
// Parameters:
// bool ForceKilled_ (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
void ABP_ProjectileCrossbowArrow_C::PostHit(bool ForceKilled_)
{
static auto fn = UObject::FindObject<UFunction>("Function BP_ProjectileCrossbowArrow.BP_ProjectileCrossbowArrow_C.PostHit");
ABP_ProjectileCrossbowArrow_C_PostHit_Params params;
params.ForceKilled_ = ForceKilled_;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
// Function BP_ProjectileCrossbowArrow.BP_ProjectileCrossbowArrow_C.ExecuteUbergraph_BP_ProjectileCrossbowArrow
// (Final)
// Parameters:
// int EntryPoint (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData)
void ABP_ProjectileCrossbowArrow_C::ExecuteUbergraph_BP_ProjectileCrossbowArrow(int EntryPoint)
{
static auto fn = UObject::FindObject<UFunction>("Function BP_ProjectileCrossbowArrow.BP_ProjectileCrossbowArrow_C.ExecuteUbergraph_BP_ProjectileCrossbowArrow");
ABP_ProjectileCrossbowArrow_C_ExecuteUbergraph_BP_ProjectileCrossbowArrow_Params params;
params.EntryPoint = EntryPoint;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"zp2kshield@gmail.com"
] | zp2kshield@gmail.com |
17c56322e83ee21db0073000e9d2ceadf63c9a58 | a33aac97878b2cb15677be26e308cbc46e2862d2 | /program_data/PKU_raw/99/1079.c | 58d8818862508d8852303cb95ac1b3670a87e174 | [] | 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 | 713 | c | int main()
{
int n,i;
cin>>n;
int A[n];
double B[4]={0,0,0,0};
for (i=0;i<n;i++)
{
cin>>A[i];
if (A[i]<19)
B[0]=B[0]+1;
else
{
if (A[i]<36)
B[1]=B[1]+1;
else
{
if (A[i]<61)
B[2]=B[2]+1;
else
B[3]=B[3]+1;
}
}
}
cout<<fixed<<setprecision(2)<<"1-18: "<<(B[0]*100)/n<<"%"<<'\n'<<"19-35: "<<(B[1]*100)/n<<"%"<<endl<<"36-60: "<<(B[2]*100)/n<<"%"<<endl<<"60??: "<<(B[3]*100)/n<<"%"<<endl;
return 0;
} | [
"bdqnghi@gmail.com"
] | bdqnghi@gmail.com |
24d04a2e744a4459bb427dddf9976c1af5b1a45c | d75e98e95f295bf80277e93281db0d3c6622ab81 | /src/Phyllo/Util/Pair.h | e306ba4a26e952e95519da78a86d4f4e013dc3c3 | [
"MIT"
] | permissive | ethanjli/phyllo-cpp | daaac80d84e48d852cfb294f91136bf64fe30f78 | 915d872d4a2c3fc250e1aa0a879fd4c8ec2642d3 | refs/heads/master | 2020-12-21T23:15:59.885984 | 2020-03-03T22:22:03 | 2020-03-03T22:22:03 | 236,596,114 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 403 | h | #pragma once
// Standard libraries
// Third-party libraries
#include <etl/utility.h> // This indirectly includes ETL_PAIR
// Phyllo
namespace Phyllo { namespace Util {
template<typename First, typename Second>
using Pair = etl::pair<First, Second>;
template<typename First, typename Second>
Pair<First, Second> makePair(First first, Second second) {
return ETL_MAKE_PAIR(first, second);
}
} } | [
"lietk12@gmail.com"
] | lietk12@gmail.com |
681fab2aa0d4bb2f10d1022c4303ee659a428d4e | bbfa470ececd273e994cb89bd1fdb3a536d314ac | /base/src/test/benchmark_zerocoin.cpp | 4c0cb8fcfcf3dee8575b2526a541a16808681ed8 | [
"MIT"
] | permissive | fruitsfuture/AsHa | 2fca95a0705ad83838e7f6de20c64e1e5b9baf6d | a6725d14a4cf65acaa45c20ca16019ff5943a43b | refs/heads/master | 2023-08-27T04:52:56.429024 | 2021-11-02T09:06:47 | 2021-11-02T09:06:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,344 | cpp | /**
* @file Benchmark.cpp
*
* @brief Benchmarking tests for Zerocoin.
*
* @author Ian Miers, Christina Garman and Matthew Green
* @date June 2013
*
* @copyright Copyright 2013 Ian Miers, Christina Garman and Matthew Green
* @license This project is released under the MIT license.
**/
/***********************************************************************
*************Copyright (c) 2015-2017 The PIVX developers****************
******************Copyright (c) 2010-2019 Nur1Labs**********************
>Distributed under the MIT/X11 software license, see the accompanying
>file COPYING or http://www.opensource.org/licenses/mit-license.php.
************************************************************************/
#include <boost/test/unit_test.hpp>
#include <string>
#include <iostream>
#include <fstream>
// #include <curses.h>
#include <exception>
#include <cstdlib>
#include <sys/time.h>
#include "streams.h"
#include "libzerocoin/ParamGeneration.h"
#include "libzerocoin/Denominations.h"
#include "libzerocoin/Coin.h"
#include "libzerocoin/CoinSpend.h"
#include "libzerocoin/Accumulator.h"
using namespace std;
using namespace libzerocoin;
#define COLOR_STR_GREEN "\033[32m"
#define COLOR_STR_NORMAL "\033[0m"
#define COLOR_STR_RED "\033[31m"
#define TESTS_COINS_TO_ACCUMULATE 50
// Global test counters
uint32_t ggNumTests = 0;
uint32_t ggSuccessfulTests = 0;
// Global coin array
PrivateCoin *ggCoins[TESTS_COINS_TO_ACCUMULATE];
// Global params
ZerocoinParams *gg_Params;
//////////
// Utility routines
//////////
class Timer
{
timeval timer[2];
public:
timeval start()
{
gettimeofday(&this->timer[0], NULL);
return this->timer[0];
}
timeval stop()
{
gettimeofday(&this->timer[1], NULL);
return this->timer[1];
}
int duration() const
{
int secs(this->timer[1].tv_sec - this->timer[0].tv_sec);
int usecs(this->timer[1].tv_usec - this->timer[0].tv_usec);
if(usecs < 0)
{
--secs;
usecs += 1000000;
}
return static_cast<int>(secs * 1000 + usecs / 1000.0 + 0.5);
}
};
// Global timer
Timer timer;
void
gLogTestResult(string testName, bool (*testPtr)())
{
string colorGreen(COLOR_STR_GREEN);
string colorNormal(COLOR_STR_NORMAL);
string colorRed(COLOR_STR_RED);
cout << "Testing if " << testName << "..." << endl;
bool testResult = testPtr();
if (testResult == true) {
cout << "\t" << colorGreen << "[PASS]" << colorNormal << endl;
ggSuccessfulTests++;
} else {
cout << colorRed << "\t[FAIL]" << colorNormal << endl;
}
ggNumTests++;
}
CBigNum
gGetTestModulus()
{
static CBigNum testModulus(0);
// TODO: should use a hard-coded RSA modulus for testing
if (!testModulus) {
CBigNum p, q;
p = CBigNum::generatePrime(1024, false);
q = CBigNum::generatePrime(1024, false);
testModulus = p * q;
}
return testModulus;
}
//////////
// Test routines
//////////
bool
Testb_GenRSAModulus()
{
CBigNum result = gGetTestModulus();
if (!result) {
return false;
}
else {
return true;
}
}
bool
Testb_CalcParamSizes()
{
bool result = true;
#if 0
uint32_t pLen, qLen;
try {
calculateGroupParamLengths(4000, 80, &pLen, &qLen);
if (pLen < 1024 || qLen < 256) {
result = false;
}
calculateGroupParamLengths(4000, 96, &pLen, &qLen);
if (pLen < 2048 || qLen < 256) {
result = false;
}
calculateGroupParamLengths(4000, 112, &pLen, &qLen);
if (pLen < 3072 || qLen < 320) {
result = false;
}
calculateGroupParamLengths(4000, 120, &pLen, &qLen);
if (pLen < 3072 || qLen < 320) {
result = false;
}
calculateGroupParamLengths(4000, 128, &pLen, &qLen);
if (pLen < 3072 || qLen < 320) {
result = false;
}
} catch (exception &e) {
result = false;
}
#endif
return result;
}
bool
Testb_GenerateGroupParams()
{
uint32_t pLen = 1024, qLen = 256, count;
IntegerGroupParams group;
for (count = 0; count < 1; count++) {
try {
group = deriveIntegerGroupParams(calculateSeed(gGetTestModulus(), "test", ZEROCOIN_DEFAULT_SECURITYLEVEL, "TEST GROUP"), pLen, qLen);
} catch (std::runtime_error e) {
cout << "Caught exception " << e.what() << endl;
return false;
}
// Now perform some simple tests on the resulting parameters
if ((uint32_t)group.groupOrder.bitSize() < qLen || (uint32_t)group.modulus.bitSize() < pLen) {
return false;
}
CBigNum c = group.g.pow_mod(group.groupOrder, group.modulus);
//cout << "g^q mod p = " << c << endl;
if (!(c.isOne())) return false;
// Try at multiple parameter sizes
pLen = pLen * 1.5;
qLen = qLen * 1.5;
}
return true;
}
bool
Testb_ParamGen()
{
bool result = true;
try {
timer.start();
// Instantiating testParams runs the parameter generation code
ZerocoinParams testParams(gGetTestModulus(),ZEROCOIN_DEFAULT_SECURITYLEVEL);
timer.stop();
cout << "\tPARAMGEN ELAPSED TIME: " << timer.duration() << " ms\t" << timer.duration()*0.001 << " s" << endl;
} catch (runtime_error e) {
cout << e.what() << endl;
result = false;
}
return result;
}
bool
Testb_Accumulator()
{
// This test assumes a list of coins were generated during
// the Testb_MintCoin() test.
if (ggCoins[0] == NULL) {
return false;
}
try {
// Accumulate the coin list from first to last into one accumulator
Accumulator accOne(&gg_Params->accumulatorParams,libzerocoin::CoinDenomination::ZQ_ONE);
Accumulator accTwo(&gg_Params->accumulatorParams,libzerocoin::CoinDenomination::ZQ_ONE);
Accumulator accThree(&gg_Params->accumulatorParams,libzerocoin::CoinDenomination::ZQ_ONE);
Accumulator accFour(&gg_Params->accumulatorParams,libzerocoin::CoinDenomination::ZQ_ONE);
AccumulatorWitness wThree(gg_Params, accThree, ggCoins[0]->getPublicCoin());
for (uint32_t i = 0; i < TESTS_COINS_TO_ACCUMULATE; i++) {
accOne += ggCoins[i]->getPublicCoin();
accTwo += ggCoins[TESTS_COINS_TO_ACCUMULATE - (i+1)]->getPublicCoin();
accThree += ggCoins[i]->getPublicCoin();
wThree += ggCoins[i]->getPublicCoin();
if(i != 0) {
accFour += ggCoins[i]->getPublicCoin();
}
}
// Compare the accumulated results
if (accOne.getValue() != accTwo.getValue() || accOne.getValue() != accThree.getValue()) {
cout << "Accumulators don't match" << endl;
return false;
}
if(accFour.getValue() != wThree.getValue()) {
cout << "Witness math not working," << endl;
return false;
}
// Verify that the witness is correct
if (!wThree.VerifyWitness(accThree, ggCoins[0]->getPublicCoin()) ) {
cout << "Witness not valid" << endl;
return false;
}
} catch (runtime_error e) {
cout << e.what() << endl;
return false;
}
return true;
}
bool
Testb_MintCoin()
{
try {
// Generate a list of coins
timer.start();
for (uint32_t i = 0; i < TESTS_COINS_TO_ACCUMULATE; i++) {
ggCoins[i] = new PrivateCoin(gg_Params,CoinDenomination::ZQ_ONE);
}
timer.stop();
} catch (exception &e) {
return false;
}
cout << "\tMINT ELAPSED TIME:\n\t\tTotal: " << timer.duration() << " ms\t" << timer.duration()*0.001 << " s\n\t\tPer Coin: " << timer.duration()/TESTS_COINS_TO_ACCUMULATE << " ms\t" << (timer.duration()/TESTS_COINS_TO_ACCUMULATE)*0.001 << " s" << endl;
return true;
}
bool
Testb_MintAndSpend()
{
try {
// This test assumes a list of coins were generated in Testb_MintCoin()
if (ggCoins[0] == NULL)
{
// No coins: mint some.
Testb_MintCoin();
if (ggCoins[0] == NULL) {
return false;
}
}
// Accumulate the list of generated coins into a fresh accumulator.
// The first one gets marked as accumulated for a witness, the
// others just get accumulated normally.
Accumulator acc(&gg_Params->accumulatorParams,CoinDenomination::ZQ_ONE);
AccumulatorWitness wAcc(gg_Params, acc, ggCoins[0]->getPublicCoin());
timer.start();
for (uint32_t i = 0; i < TESTS_COINS_TO_ACCUMULATE; i++) {
acc += ggCoins[i]->getPublicCoin();
}
timer.stop();
cout << "\tACCUMULATOR ELAPSED TIME:\n\t\tTotal: " << timer.duration() << " ms\t" << timer.duration()*0.001 << " s\n\t\tPer Element: " << timer.duration()/TESTS_COINS_TO_ACCUMULATE << " ms\t" << (timer.duration()/TESTS_COINS_TO_ACCUMULATE)*0.001 << " s" << endl;
timer.start();
for (uint32_t i = 0; i < TESTS_COINS_TO_ACCUMULATE; i++) {
wAcc +=ggCoins[i]->getPublicCoin();
}
timer.stop();
cout << "\tWITNESS ELAPSED TIME: \n\t\tTotal: " << timer.duration() << " ms\t" << timer.duration()*0.001 << " s\n\t\tPer Element: " << timer.duration()/TESTS_COINS_TO_ACCUMULATE << " ms\t" << (timer.duration()/TESTS_COINS_TO_ACCUMULATE)*0.001 << " s" << endl;
// Now spend the coin
timer.start();
CoinSpend spend(gg_Params, *(ggCoins[0]), acc, 0, wAcc, 0, SpendType::SPEND); //(0) presstab
timer.stop();
cout << "\tSPEND ELAPSED TIME: " << timer.duration() << " ms\t" << timer.duration()*0.001 << " s" << endl;
// Serialize the proof and deserialize into newSpend
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
timer.start();
ss << spend;
timer.stop();
CoinSpend newSpend(gg_Params, ss);
cout << "\tSERIALIZE ELAPSED TIME: " << timer.duration() << " ms\t" << timer.duration()*0.001 << " s" << endl;
// Finally, see if we can verify the deserialized proof (return our result)
timer.start();
bool ret = newSpend.Verify(acc);
timer.stop();
cout << "\tSPEND VERIFY ELAPSED TIME: " << timer.duration() << " ms\t" << timer.duration()*0.001 << " s" << endl;
return ret;
} catch (runtime_error &e) {
cout << e.what() << endl;
return false;
}
return false;
}
void
Testb_RunAllTests()
{
// Make a new set of parameters from a random RSA modulus
gg_Params = new ZerocoinParams(gGetTestModulus());
ggNumTests = ggSuccessfulTests = 0;
for (uint32_t i = 0; i < TESTS_COINS_TO_ACCUMULATE; i++) {
ggCoins[i] = NULL;
}
// Run through all of the Zerocoin tests
gLogTestResult("an RSA modulus can be generated", Testb_GenRSAModulus);
gLogTestResult("parameter sizes are correct", Testb_CalcParamSizes);
gLogTestResult("group/field parameters can be generated", Testb_GenerateGroupParams);
gLogTestResult("parameter generation is correct", Testb_ParamGen);
gLogTestResult("coins can be minted", Testb_MintCoin);
gLogTestResult("the accumulator works", Testb_Accumulator);
gLogTestResult("a minted coin can be spent", Testb_MintAndSpend);
// Summarize test results
if (ggSuccessfulTests < ggNumTests) {
cout << endl << "ERROR: SOME TESTS FAILED" << endl;
}
// Clear any generated coins
for (uint32_t i = 0; i < TESTS_COINS_TO_ACCUMULATE; i++) {
delete ggCoins[i];
}
cout << ggSuccessfulTests << " out of " << ggNumTests << " tests passed." << endl << endl;
delete gg_Params;
}
BOOST_AUTO_TEST_SUITE(benchmark_zerocoin)
BOOST_AUTO_TEST_CASE(benchmark_test)
{
cout << "libzerocoin v" << ZEROCOIN_VERSION_STRING << " benchmark utility." << endl << endl;
Testb_RunAllTests();
}
BOOST_AUTO_TEST_SUITE_END()
| [
"crbru.yuthafiga@gmail.com"
] | crbru.yuthafiga@gmail.com |
03e5ee4dff28a1c394e29d0b9b395f4a1b69c770 | 73e4edce3d97bfaaf0d35519175db8f835eb01a8 | /Textures.cpp | 526666f69d2697b5f0fa1f98102dde051b339f17 | [] | no_license | Marcinbloch1/PK4-PlatformGame | ecccc762e63f5f4d871181c21cb2297691446e4d | 0eda5d669fa874ab9cf36dd5acf328c5ccc45a52 | refs/heads/main | 2023-03-28T18:03:09.961707 | 2021-04-06T19:47:54 | 2021-04-06T19:47:54 | 355,291,080 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,389 | cpp | #include "Textures.h"
Textures::Textures()
{
loadAllTextures();
}
void Textures::loadTexture(TEXTURES id, std::string filename)
{
std::unique_ptr<sf::Texture> texture(new sf::Texture());
if (!texture->loadFromFile(filename))
throw std::runtime_error("Texture failed to load: " + filename);
if (id == TEXTURES::BACKGROUND_TEXTURE)
{
texture->setRepeated(true);
texture->setSmooth(true);
}
auto is_inserted = textures_map.insert(std::pair<TEXTURES, std::unique_ptr<sf::Texture>>(id, std::move(texture)));
assert(("Texture " + filename + "was loaded more than once", is_inserted.second));
}
sf::Texture& Textures::getTexture(const TEXTURES& id)
{
auto search = textures_map.find(id);
assert(("Eror with texture", search != textures_map.end()));
return *search->second;
}
void Textures::loadAllTextures()
{
loadTexture(TEXTURES::PLAYER_TEXTURE, "Textures/player.png");
loadTexture(TEXTURES::ENEMY_TEXTURE_1, "Textures/jumpingenemy.png");
loadTexture(TEXTURES::ENEMY_TEXTURE_2, "Textures/fastenemy.png");
loadTexture(TEXTURES::PLATFORM_TEXTURE, "Textures/platform_dirt.png");
loadTexture(TEXTURES::BACKGROUND_TEXTURE, "Textures/background_sky.jpg");
loadTexture(TEXTURES::COIN_TEXTURE, "Textures/coin_mario.png");
loadTexture(TEXTURES::JUMPPOWERUP_TEXTURE, "Textures/jumppowerup.png");
loadTexture(TEXTURES::SPEEDPOWERUP_TEXTURE, "Textures/speedpowerup.png");
} | [
"marcinb98@gmail.com"
] | marcinb98@gmail.com |
98873f0a6a00935ade3fa33b094c17af1510cf69 | ce46f4c02d7f0e954c93aa21647f49e78bd6da29 | /41.DFR_LCDwKPad/DFR_Key Librarys/DFR_Key v0.4jch/examples/Key_Grab2/Key_Grab2.ino | 31e226cdd65b93ec99c094369a1e4e37905e89b5 | [] | no_license | teamresistance/Arduino-Code | 6d69c86566315632c6ce858dfbeb2d3b9e1a74d6 | 01521d22a2aac1c2f9c7d9c7c9a1667c2756f1c6 | refs/heads/master | 2021-06-09T12:31:09.689772 | 2016-12-12T20:50:04 | 2016-12-12T20:50:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,524 | ino | /*
DFRobot LCD Shield for Arduino
Key Grab v0.2
Written by Glendon Klassen
gjklassen@gmail.com
http://www.sourceforge.net/users/ecefixer
http://ecefixer.tumblr.com
Displays the currently pressed key on the LCD screen.
Key Codes (in left-to-right order):
None - 0
Select - 1
Left - 2
Up - 3
Down - 4
Right - 5
*/
#include <LiquidCrystal.h>
#include <DFR_Key.h>
//Pin assignments for DFRobot LCD Keypad Shield
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
//---------------------------------------------
DFR_Key keypad;
int localKey = 0;
String keyString = "";
String keyArray[6] = {"0 - NO KEY", "1 - SEL KEY", "2 - LEFT KEY", "3 - UP KEY", "4 - DN KEY", "5 - RIGHT KEY"};
unsigned long calKeyTimer = 0;
void setup()
{
lcd.begin(16, 2);
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Key Grab v0.2");
delay(2500);
Serial.begin(9600);
// array {None, UP, DWN, LEFT, RIGHT, SEL}
// int keyLimits[6] = {0, 144, 329, 505, 742, 1023}; // DFR ver 1.0
int keyLimits[6] = {0, 100, 255, 410, 641, 1023}; // DFR ver 1.1
// int keyLimits[6] = {0, 131, 307, 408, 723, 1023}; // Cytron (default)
// keypad.set_KeyARV(keyLimits);
/*
OPTIONAL - keypad.setRate(x);
Sets the sample rate at once every x milliseconds. Default: 10ms
*/
keypad.setRate(10);
}
void loop()
{
/*
keypad.getKey();
Grabs the current key.
Returns a non-zero integer corresponding to the pressed key,
OR
Returns 0 for no keys pressed,
OR
Returns -1 (sample wait) when no key is available to be sampled.
*/
localKey = keypad.getKey();
if (localKey != SAMPLE_WAIT)
{
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Current Key:");
lcd.setCursor(0, 1);
// lcd.print(millis()/100);
lcd.print(analogRead(0));
lcd.print(" : ");
lcd.print(keyArray[localKey]);
}
if (analogRead(0) == 0) {
if (calKeyTimer == 0) calKeyTimer = millis() + 5000;
}else{
calKeyTimer = 0;
}
if (millis() > calKeyTimer && calKeyTimer != 0) {
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("Calibrate AVRs:");
lcd.setCursor(0, 1);
lcd.print("Press All Keys Once");
for (int i = 0; i < 6; i++) { // AVRs before calibration
Serial.print(keypad.getKeyAVR(i));
Serial.print("\t");
}
Serial.println();
keypad.calibrKeyAVRs();
for (int i = 0; i < 6; i++) { // AVRs after calibration
Serial.print(keypad.getKeyAVR(i));
Serial.print("\t");
}
Serial.println();
}
}
| [
"james.c.hofmann@gmail.com"
] | james.c.hofmann@gmail.com |
52fffb36d86908ab087edd313388a3e7ffee88dd | 1826cd13e527cbd312d000681728467730ff9aa4 | /71.cpp | dfcc0c51e775877f630012cdd4b51bbdbd3a8d8f | [] | no_license | gcc-tan/leetcode | 3a9b21612e3c58f54ff20d72c254ca97c4039099 | e70e60ccbc86a7cb52eaedd9ba4a4fb61bfade65 | refs/heads/master | 2021-01-23T16:25:56.020498 | 2018-08-23T09:14:04 | 2018-08-23T09:14:04 | 102,742,699 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,991 | cpp | //Simplify Path
/*
Given an absolute path for a file (Unix-style), simplify it.
For example,
path = "/home/", => "/home"
path = "/a/./b/../../c/", => "/c"
click to show corner cases.
Corner Cases:
Did you consider the case where path = "/../"?
In this case, you should return "/".
Another corner case is the path might contain multiple slashes '/' together, such as "/home//foo/".
In this case, you should ignore redundant slashes and return "/home/foo".
*/
/*
题目很切实际，就是将输入的unix风格的路径进行化简
*/
class Solution
{
public:
string simplifyPath(string path)
{
int i, j, n;
string cur, ans;//cur当前一级的目录名字
vector<string> st;//栈，保存每级目录的名字，遇到"."不处理，遇到".."弹栈，其他情况入栈
for(i = 1; i < path.size(); ++i)//去除冗余的'/'
{
if(path[i-1] == '/' && path[i] == '/')
{
path.erase(i, 1);
--i;
}
}
if(path.back() == '/') path.erase(path.length() - 1);
n = path.size();
for(i = 0; i < n; ++i)//遍历每个目录的名字
{
if(path[i] != '/') continue;
for(j = i + 1; j < n && path[j] != '/'; ++j);
cur = path.substr(i + 1, j - i - 1);
if(cur == ".") continue;
if(cur != "..")
{
st.push_back(cur);
continue;
}
if(!st.empty())
st.pop_back();
}
if(st.empty()) return "/";
for(i = 0; i < st.size(); ++i)
ans += "/" + st[i];
return ans;
}
};
/*
我发现我的代码就是造车轮子造太多
*/
string simplifyPath(string path) {
string res, tmp;
vector<string> stk;
stringstream ss(path);//利用path构造一个流对象
while(getline(ss,tmp,'/')) {//第一个是流对象，第二个是返回的结果，第三个是结尾标识
if (tmp == "" or tmp == ".") continue;
if (tmp == ".." and !stk.empty()) stk.pop_back();
else if (tmp != "..") stk.push_back(tmp);
}
for(auto str : stk) res += "/"+str;
return res.empty() ? "/" : res;
}
| [
"my_mfcmail@126.com"
] | my_mfcmail@126.com |
523b55c3203f3f85b697d5267e65b6baa0bab5f4 | 9a4f212499143124005536dd3e8b3e8b569178d8 | /common/Clipboard.cpp | d5db949651c70f2a3def12d95171275c644f9768 | [] | no_license | rekhavasanthapps/Ultravnc | 64e98b1de84f73ca2bdc76f04432dadcfa921242 | 95f533679f1aadbc06c97a3d1ccb0cdf4e43dedb | refs/heads/master | 2022-04-23T11:32:55.796442 | 2020-04-11T11:56:40 | 2020-04-11T11:56:40 | 254,855,895 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,708 | cpp | /////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2002-2013 UltraVNC Team Members. All Rights Reserved.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
// USA.
//
// If the source code for the program is not available from the place from
// which you received this file, check
// http://www.uvnc.com/
//
////////////////////////////////////////////////////////////////////////////
// Clipboard.h
// adzm - July 2010
//
// Common classes for dealing with the clipboard, including serializing and deserializing compressed data, hashing and comparing, etc.
// Used by server and viewer.
#include "Clipboard.h"
#define VC_EXTRALEAN
#include <winsock2.h>
#include <windows.h>
#include <string>
#include <rdr/MemInStream.h>
#include <rdr/ZlibOutStream.h>
#include <rdr/ZlibInStream.h>
#ifdef _INTERNALLIB
#include <zlib.h>
#include <zstd.h>
#else
#include "../zlib/zlib.h"
#include "../zstd-1.4.4/lib/zstd.h"
#endif
ExtendedClipboardDataMessage::ExtendedClipboardDataMessage()
: m_pExtendedData(NULL), m_nInternalLength(0), m_pCurrentPos(NULL), m_pData(NULL)
{
EnsureBufferLength(sz_rfbExtendedClipboardData);
m_pCurrentPos += sz_rfbExtendedClipboardData;
}
ExtendedClipboardDataMessage::~ExtendedClipboardDataMessage()
{
delete[] m_pData;
}
void ExtendedClipboardDataMessage::Reset()
{
delete[] m_pData;
m_pData = NULL;
m_pCurrentPos = NULL;
m_pExtendedData = NULL;
m_pCurrentPos = NULL;
m_nInternalLength = 0;
EnsureBufferLength(sz_rfbExtendedClipboardData);
m_pCurrentPos += sz_rfbExtendedClipboardData;
}
void ExtendedClipboardDataMessage::AddFlag(CARD32 flag)
{
m_pExtendedData->flags |= Swap32IfLE(flag);
}
bool ExtendedClipboardDataMessage::HasFlag(CARD32 flag)
{
return (m_pExtendedData->flags & Swap32IfLE(flag)) ? true : false;
}
int ExtendedClipboardDataMessage::GetMessageLength()
{
return GetDataLength() - sz_rfbExtendedClipboardData;
}
int ExtendedClipboardDataMessage::GetDataLength()
{
return (int)(m_pCurrentPos - m_pData);
}
const BYTE* ExtendedClipboardDataMessage::GetData()
{
return m_pData;
}
BYTE* ExtendedClipboardDataMessage::GetBuffer()
{
return m_pData;
}
int ExtendedClipboardDataMessage::GetBufferLength()
{
return m_nInternalLength;
}
const BYTE* ExtendedClipboardDataMessage::GetCurrentPos()
{
return m_pCurrentPos;
}
void ExtendedClipboardDataMessage::AppendInt(CARD32 val)
{
EnsureBufferLength(GetDataLength() + sizeof(val));
val = Swap32IfLE(val);
memcpy(m_pCurrentPos, &val, sizeof(val));
m_pCurrentPos += sizeof(val);
}
void ExtendedClipboardDataMessage::AppendBytes(BYTE* pData, int length)
{
EnsureBufferLength(GetDataLength() + length, false);
memcpy(m_pCurrentPos, pData, length);
m_pCurrentPos += length;
}
void ExtendedClipboardDataMessage::Advance(int len)
{
EnsureBufferLength(GetDataLength() + len, false);
m_pCurrentPos += len;
}
CARD32 ExtendedClipboardDataMessage::ReadInt()
{
CARD32 val = 0;
memcpy(&val, m_pCurrentPos, sizeof(val));
m_pCurrentPos += sizeof(val);
return Swap32IfLE(val);
}
void ExtendedClipboardDataMessage::EnsureBufferLength(int len, bool bGrowBeyond)
{
if (m_nInternalLength < len) {
int nCurrentOffset = GetDataLength();
int nNewLength = bGrowBeyond ? len * 2 : len;
BYTE* pNewBuffer = new BYTE[nNewLength];
::ZeroMemory(pNewBuffer, nNewLength);
if (m_pData) {
memcpy(pNewBuffer, m_pData, GetDataLength());
delete[] m_pData;
}
m_pData = pNewBuffer;
m_pExtendedData = (rfbExtendedClipboardData*)m_pData;
m_pCurrentPos = m_pData + nCurrentOffset;
m_nInternalLength = nNewLength;
}
}
int ExtendedClipboardDataMessage::CountFormats()
{
CARD32 flags = GetFlags();
flags = flags & 0x0000FFFF;
// from Brian W. Kernighan
int c = 0;
for (c = 0; flags; c++) {
flags &= flags - 1;
}
return c;
}
CARD32 ExtendedClipboardDataMessage::GetFlags()
{
return Swap32IfLE(m_pExtendedData->flags);
}
const UINT ClipboardSettings::formatUnicodeText = CF_UNICODETEXT;
const UINT ClipboardSettings::formatRTF = RegisterClipboardFormat("Rich Text Format");
const UINT ClipboardSettings::formatHTML = RegisterClipboardFormat("HTML Format");
const UINT ClipboardSettings::formatDIB = CF_DIBV5;
const int ClipboardSettings::defaultLimitText = ((int)0x00A00000); // 10 megabytes uncompressed. Pretty huge, but not a problem for a LAN. Better than the previous no limit, though.
const int ClipboardSettings::defaultLimitRTF = ((int)0x00200000); // Limit these to 2 megabytes so they don't end up adding too much strain by being enabled by default
const int ClipboardSettings::defaultLimitHTML = ((int)0x00200000); // besides, every 2mb rtf/html data I have seen will DEFLATE very well.
const int ClipboardSettings::defaultLimitDIB = ((int)0x00000000); // no DIB by default
const int ClipboardSettings::defaultLimit = ((int)0x00200000);
ClipboardSettings::ClipboardSettings(CARD32 caps)
: m_bSupportsEx(false)
, m_nLimitText(defaultLimitText)
, m_nLimitRTF(defaultLimitRTF)
, m_nLimitHTML(defaultLimitHTML)
, m_nLimitDIB(defaultLimitDIB)
, m_nRequestedLimitText(m_nLimitText)
, m_nRequestedLimitRTF(m_nLimitRTF)
, m_nRequestedLimitHTML(m_nLimitHTML)
, m_nRequestedLimitDIB(m_nLimitDIB)
, m_myCaps(caps)
, m_remoteCaps(ClipboardSettings::defaultCaps)
{
}
CARD32 ClipboardSettings::defaultCaps =
(clipCaps | clipRequest | clipProvide) // capabilities
|
(clipText | clipRTF | clipHTML | clipDIB); // supports Unicode text, RTF, and HTML, and DIB
CARD32 ClipboardSettings::defaultViewerCaps = defaultCaps | clipNotify;
CARD32 ClipboardSettings::defaultServerCaps = defaultCaps | clipPeek;
void ClipboardSettings::PrepareCapsPacket(ExtendedClipboardDataMessage& extendedDataMessage)
{
// messages and formats that we can handle
extendedDataMessage.m_pExtendedData->flags = Swap32IfLE(m_myCaps);
// now include our limits in order of enum value
extendedDataMessage.AppendInt(m_nLimitText);
extendedDataMessage.AppendInt(m_nLimitRTF);
extendedDataMessage.AppendInt(m_nLimitHTML);
extendedDataMessage.AppendInt(m_nLimitDIB);
}
void ClipboardSettings::HandleCapsPacket(ExtendedClipboardDataMessage& extendedDataMessage, bool bSetLimits)
{
int nCount = extendedDataMessage.CountFormats();
m_remoteCaps = extendedDataMessage.GetFlags();
if (m_remoteCaps & clipText) {
m_nRequestedLimitText = (int)extendedDataMessage.ReadInt();
nCount--;
} else {
m_nRequestedLimitText = 0;
}
if (m_remoteCaps & clipRTF) {
m_nRequestedLimitRTF = (int)extendedDataMessage.ReadInt();
nCount--;
} else {
m_nRequestedLimitRTF = 0;
}
if (m_remoteCaps & clipHTML) {
m_nRequestedLimitHTML = (int)extendedDataMessage.ReadInt();
nCount--;
} else {
m_nRequestedLimitHTML = 0;
}
if (m_remoteCaps & clipDIB) {
m_nRequestedLimitDIB = (int)extendedDataMessage.ReadInt();
nCount--;
} else {
m_nRequestedLimitDIB = 0;
}
if (bSetLimits) {
m_nLimitText = m_nRequestedLimitText;
m_nLimitRTF = m_nRequestedLimitRTF;
m_nLimitHTML = m_nRequestedLimitHTML;
m_nLimitDIB = m_nRequestedLimitDIB;
}
// read any unsupported values
while (nCount) {
extendedDataMessage.ReadInt();
nCount--;
}
}
ClipboardHolder::ClipboardHolder(HWND hwndOwner)
{
m_bIsOpen = ::OpenClipboard(hwndOwner) ? true : false;
}
ClipboardHolder::~ClipboardHolder()
{
if (m_bIsOpen) {
::CloseClipboard();
}
}
ClipboardData::ClipboardData()
: m_crc(0)
, m_lengthText(0)
, m_lengthRTF(0)
, m_lengthHTML(0)
, m_lengthDIB(0)
, m_pDataText(NULL)
, m_pDataRTF(NULL)
, m_pDataHTML(NULL)
, m_pDataDIB(NULL)
{
}
ClipboardData::~ClipboardData()
{
FreeData();
}
void ClipboardData::FreeData()
{
delete[] m_pDataText;
delete[] m_pDataRTF;
delete[] m_pDataHTML;
delete[] m_pDataDIB;
m_pDataText = NULL;
m_pDataRTF = NULL;
m_pDataHTML = NULL;
m_pDataDIB = NULL;
}
bool ClipboardData::Load(HWND hwndOwner) // will return false on failure
{
// This can be improved by not making copies of the clipboard data and simply keeping the handles open; however
// I seemed to notice some issues with having multiple clipboard format data handles open when an application
// uses clipboard formats that it must render on demand. Regardless, I am not too concerned about this now.
ClipboardHolder holder(hwndOwner);
if (!holder.m_bIsOpen) {
return false;
}
m_crc = 0;
FreeData();
m_crc = crc32(0L, Z_NULL, 0);
// text
{
m_lengthText = 0;
HANDLE hText = NULL;
if (IsClipboardFormatAvailable(ClipboardSettings::formatUnicodeText)) {
hText = ::GetClipboardData(ClipboardSettings::formatUnicodeText);
}
if (hText) {
BYTE* pData = (BYTE*)GlobalLock(hText);
int nLength = (int)GlobalSize(hText);
if (pData != NULL && nLength > 0) {
// Convert from UTF-16 to UTF-8
int nConvertedSize = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)pData, -1, NULL, 0, NULL, NULL);
if (nConvertedSize > 0) {
m_pDataText = new BYTE[nConvertedSize];
//memcpy(m_pDataText, pData, nLength);
int nFinalConvertedSize = WideCharToMultiByte(CP_UTF8, 0, (LPCWSTR)pData, -1, (LPSTR)m_pDataText, nConvertedSize, NULL, NULL);
if (nFinalConvertedSize > 0) {
m_lengthText = nFinalConvertedSize;
m_crc = crc32(m_crc, m_pDataText, nFinalConvertedSize);
} else {
delete[] m_pDataText;
}
}
GlobalUnlock(hText);
}
}
}
// RTF
{
m_lengthRTF = 0;
HANDLE hRTF = NULL;
if (IsClipboardFormatAvailable(ClipboardSettings::formatRTF)) {
hRTF = ::GetClipboardData(ClipboardSettings::formatRTF);
}
if (hRTF) {
BYTE* pData = (BYTE*)GlobalLock(hRTF);
int nLength = (int)GlobalSize(hRTF);
if (pData != NULL && nLength > 0) {
m_pDataRTF = new BYTE[nLength];
memcpy(m_pDataRTF, pData, nLength);
m_lengthRTF = nLength;
GlobalUnlock(hRTF);
}
}
}
// HTML
{
m_lengthHTML = 0;
HANDLE hHTML = NULL;
if (IsClipboardFormatAvailable(ClipboardSettings::formatHTML)) {
hHTML = ::GetClipboardData(ClipboardSettings::formatHTML);
}
if (hHTML) {
BYTE* pData = (BYTE*)GlobalLock(hHTML);
int nLength = (int)GlobalSize(hHTML);
if (pData != NULL && nLength > 0) {
m_pDataHTML = new BYTE[nLength];
memcpy(m_pDataHTML, pData, nLength);
m_lengthHTML = nLength;
GlobalUnlock(hHTML);
}
}
}
// DIB
{
m_lengthDIB = 0;
HANDLE hDIB = NULL;
if (IsClipboardFormatAvailable(ClipboardSettings::formatDIB)) {
hDIB = ::GetClipboardData(ClipboardSettings::formatDIB);
}
if (hDIB) {
BYTE* pData = (BYTE*)GlobalLock(hDIB);
int nLength = (int)GlobalSize(hDIB);
if (pData != NULL && nLength > 0) {
m_pDataDIB = new BYTE[nLength];
memcpy(m_pDataDIB, pData, nLength);
m_lengthDIB = nLength;
GlobalUnlock(hDIB);
}
}
}
return m_lengthText + m_lengthRTF + m_lengthHTML + m_lengthDIB > 0;
}
bool ClipboardData::Restore(HWND hwndOwner, ExtendedClipboardDataMessage& extendedClipboardDataMessage)
{
ClipboardHolder holder(hwndOwner);
if (!holder.m_bIsOpen) {
return false;
}
if (!::EmptyClipboard()) {
return false;
}
m_lengthText = m_lengthRTF = m_lengthHTML = m_lengthDIB = 0;
int nCompressedDataLength = extendedClipboardDataMessage.GetBufferLength() - extendedClipboardDataMessage.GetDataLength();
m_crc = crc32(0L, Z_NULL, 0);
if (nCompressedDataLength == 0) {
// no data beyond the flags
return true;
}
rdr::MemInStream inStream(extendedClipboardDataMessage.GetCurrentPos(), nCompressedDataLength);
rdr::ZlibInStream compressedStream;
compressedStream.setUnderlying(&inStream, nCompressedDataLength);
int length = 0;
bool bFailed = false;
if (extendedClipboardDataMessage.HasFlag(clipText)) {
length = (int)compressedStream.readU32();
if (length > 0) {
// get the incoming UTF-8 text
BYTE* pIncomingText = new BYTE[length];
compressedStream.readBytes(pIncomingText, length);
m_crc = crc32(m_crc, pIncomingText, length);
// now we have to translate to UTF-16
int nConvertedSize = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)pIncomingText, length, NULL, 0);
if (nConvertedSize > 0) {
HGLOBAL hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, nConvertedSize * sizeof(wchar_t));
if (hData) {
BYTE* pData = (BYTE*)GlobalLock(hData);
if (pData) {
int nFinalConvertedSize = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)pIncomingText, length, (LPWSTR)pData, nConvertedSize);
GlobalUnlock(hData);
if (nFinalConvertedSize > 0) {
if (::SetClipboardData(ClipboardSettings::formatUnicodeText, hData)) {
hData = NULL;
m_lengthText = nConvertedSize * sizeof(wchar_t);
} else {
bFailed = true;
}
}
}
}
if (hData) {
GlobalFree(hData);
}
}
if (pIncomingText) {
delete[] pIncomingText;
}
if (bFailed) {
return false;
}
}
}
if (extendedClipboardDataMessage.HasFlag(clipRTF)) {
length = (int)compressedStream.readU32();
if (length > 0) {
HGLOBAL hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, length);
if (!hData) return false;
BYTE* pData = (BYTE*)GlobalLock(hData);
if (pData) {
compressedStream.readBytes(pData, length);
GlobalUnlock(hData);
if (::SetClipboardData(ClipboardSettings::formatRTF, hData)) {
hData = NULL;
m_lengthRTF = length;
} else {
bFailed = true;
}
}
if (hData) {
GlobalFree(hData);
}
}
}
if (extendedClipboardDataMessage.HasFlag(clipHTML)) {
length = (int)compressedStream.readU32();
if (length > 0) {
HGLOBAL hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, length);
if (!hData) return false;
BYTE* pData = (BYTE*)GlobalLock(hData);
if (pData) {
compressedStream.readBytes(pData, length);
GlobalUnlock(hData);
if (!::SetClipboardData(ClipboardSettings::formatHTML, hData)) {
hData = NULL;
m_lengthHTML = length;
} else {
bFailed = true;
}
}
if (hData) {
GlobalFree(hData);
}
}
}
if (extendedClipboardDataMessage.HasFlag(clipDIB)) {
length = (int)compressedStream.readU32();
if (length > 0) {
HGLOBAL hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, length);
if (!hData) return false;
BYTE* pData = (BYTE*)GlobalLock(hData);
if (pData) {
compressedStream.readBytes(pData, length);
GlobalUnlock(hData);
if (!::SetClipboardData(ClipboardSettings::formatDIB, hData)) {
hData = NULL;
m_lengthDIB = length;
} else {
bFailed = true;
}
}
if (hData) {
GlobalFree(hData);
}
}
}
// we can ignore everything else
return true;
}
Clipboard::Clipboard(CARD32 caps)
: settings(caps)
, m_crc(0)
, m_bNeedToProvide(false)
, m_bNeedToNotify(false)
, m_notifiedRemoteFormats(0)
{
}
// returns true if something changed
bool Clipboard::UpdateClipTextEx(ClipboardData& clipboardData, CARD32 overrideFlags)
{
if (m_crc == clipboardData.m_crc && overrideFlags == 0) {
return false;
}
if (overrideFlags & clipPeek) {
// don't reset anything regarding providing new data, just 'include' any
// formats into the notify response.
if (clipboardData.m_lengthText != 0) {
extendedClipboardDataNotifyMessage.AddFlag(clipText);
m_bNeedToNotify = true;
}
if (clipboardData.m_lengthRTF != 0) {
extendedClipboardDataNotifyMessage.AddFlag(clipRTF);
m_bNeedToNotify = true;
}
if (clipboardData.m_lengthHTML != 0) {
extendedClipboardDataNotifyMessage.AddFlag(clipHTML);
m_bNeedToNotify = true;
}
if (clipboardData.m_lengthDIB != 0) {
extendedClipboardDataNotifyMessage.AddFlag(clipDIB);
m_bNeedToNotify = true;
}
} else {
m_bNeedToProvide = false;
m_bNeedToNotify = false;
extendedClipboardDataMessage.Reset();
extendedClipboardDataNotifyMessage.Reset();
extendedClipboardDataMessage.AddFlag(clipProvide);
extendedClipboardDataNotifyMessage.AddFlag(clipNotify);
rdr::MemOutStream memStream;
{
rdr::ZlibOutStream compressedStream(&memStream, 0, 9); //Z_BEST_COMPRESSION
if (clipboardData.m_lengthText != 0) {
extendedClipboardDataNotifyMessage.AddFlag(clipText);
if (clipboardData.m_lengthText <= settings.m_nLimitText || (overrideFlags & clipText)) {
compressedStream.writeU32(clipboardData.m_lengthText);
compressedStream.writeBytes(clipboardData.m_pDataText, clipboardData.m_lengthText);
extendedClipboardDataMessage.AddFlag(clipText);
m_bNeedToProvide = true;
} else {
m_bNeedToNotify = true;
}
}
if (clipboardData.m_lengthRTF != 0) {
extendedClipboardDataNotifyMessage.AddFlag(clipRTF);
if (clipboardData.m_lengthRTF <= settings.m_nLimitRTF || (overrideFlags & clipRTF)) {
compressedStream.writeU32(clipboardData.m_lengthRTF);
compressedStream.writeBytes(clipboardData.m_pDataRTF, clipboardData.m_lengthRTF);
extendedClipboardDataMessage.AddFlag(clipRTF);
m_bNeedToProvide = true;
} else {
m_bNeedToNotify = true;
}
}
if (clipboardData.m_lengthHTML != 0) {
extendedClipboardDataNotifyMessage.AddFlag(clipHTML);
if (clipboardData.m_lengthHTML <= settings.m_nLimitHTML || (overrideFlags & clipHTML)) {
compressedStream.writeU32(clipboardData.m_lengthHTML);
compressedStream.writeBytes(clipboardData.m_pDataHTML, clipboardData.m_lengthHTML);
extendedClipboardDataMessage.AddFlag(clipHTML);
m_bNeedToProvide = true;
} else {
m_bNeedToNotify = true;
}
}
if (clipboardData.m_lengthDIB != 0) {
extendedClipboardDataNotifyMessage.AddFlag(clipDIB);
if (clipboardData.m_lengthDIB <= settings.m_nLimitDIB || (overrideFlags & clipDIB)) {
compressedStream.writeU32(clipboardData.m_lengthDIB);
compressedStream.writeBytes(clipboardData.m_pDataDIB, clipboardData.m_lengthDIB);
extendedClipboardDataMessage.AddFlag(clipDIB);
m_bNeedToProvide = true;
} else {
m_bNeedToNotify = true;
}
}
compressedStream.flush();
}
if (m_bNeedToProvide) {
extendedClipboardDataMessage.AppendBytes((BYTE*)memStream.data(), memStream.length());
memStream.clear();
}
m_strLastCutText = "";
if (!settings.m_bSupportsEx && clipboardData.m_lengthText > 0 && clipboardData.m_lengthText < settings.m_nLimitText) {
// now we have to translate to UTF-16
int nConvertedSize = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)clipboardData.m_pDataText, clipboardData.m_lengthText, NULL, 0);
if (nConvertedSize > 0) {
wchar_t* clipStr = new wchar_t[nConvertedSize];
int nFinalConvertedSize = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)clipboardData.m_pDataText, clipboardData.m_lengthText, (LPWSTR)clipStr, nConvertedSize);
if (nFinalConvertedSize > 0) {
std::wstring wstrClipboard(clipStr);
m_strLastCutText.assign(wstrClipboard.begin(), wstrClipboard.end());
}
delete[] clipStr;
}
}
m_crc = clipboardData.m_crc;
if ( (!(settings.m_remoteCaps & clipNotify)) || (overrideFlags != 0) ) {
m_bNeedToNotify = false;
extendedClipboardDataNotifyMessage.Reset();
}
}
return m_bNeedToProvide || m_bNeedToNotify;
}
| [
"d.vasant@gmail.com"
] | d.vasant@gmail.com |
3eed0c48ffec4f6d10e08076d3e8b4d72ff12fe5 | 43d75cb95c2440057fac58c4775e880b1b9004d1 | /CameraCalibration/src/frameselect.cpp | 3fc1804c9f27134b1413a3b89e287734ce3506fe | [] | no_license | grisellycooper/CV_Project1 | 3613238c251c40bf062c27f258200c5ea1894061 | 554e4fcb385446e5bc903483477e9d3dc689143f | refs/heads/master | 2020-04-09T06:22:11.595886 | 2019-02-18T12:25:15 | 2019-02-18T12:25:15 | 160,109,013 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,268 | cpp | #include "../include/frameselect.h"
#define displaySelector 0
#define i 8
bool
isGoodFrame(cv::Mat src,
std::vector<cv::Point2f>& pointbuf,
std::vector<cv::Point2f>& previousCornersBuf,
bool previousCorners,
int patternWidth,
int patternHeigh,
float &minDistControlPoints)
{
int qtWidth, qtHeigh;
bool good = true;
float patternArea, totalArea;
float totalDistDisplace = 0.0f;
std::vector<cv::Point2f> patternCorners;
std::vector<cv::Point2f> frameCorners;
cv::Mat selector = cv::Mat::zeros(src.rows, src.cols, CV_8UC3);
patternCorners.push_back(pointbuf[0]);
patternCorners.push_back(pointbuf[patternWidth-1]);
patternCorners.push_back(pointbuf[pointbuf.size()-patternWidth]);
patternCorners.push_back(pointbuf[pointbuf.size()-1]);
frameCorners.push_back(cv::Point2f(0,0));
frameCorners.push_back(cv::Point2f(0,src.cols));
frameCorners.push_back(cv::Point2f(src.rows,0));
frameCorners.push_back(cv::Point2f(src.rows,src.cols));
qtWidth = src.cols/(i-1);
qtHeigh = src.rows/(i-1);
if(displaySelector == 1)
{
/// Vertical lines
line(selector, cv::Point2f(qtWidth,0), cv::Point2f(qtWidth, src.rows), cv::Scalar(0,0,255), 2, 8, 0);
line(selector, cv::Point2f(src.cols-qtWidth,0), cv::Point2f(src.cols-qtWidth, src.rows), cv::Scalar(0,0,255), 2, 8, 0);
/// Horizontal lines
line(selector, cv::Point2f(0, qtHeigh), cv::Point2f(src.cols, qtHeigh), cv::Scalar(0,0,255), 2, 8, 0);
line(selector, cv::Point2f(0, src.rows-qtHeigh), cv::Point2f(src.cols, src.rows-qtHeigh), cv::Scalar(0,0,255), 2, 8, 0);
/// Draw pattern corners
circle(selector, patternCorners[0], 1, cv::Scalar(255,0,0),6, 8, 0);
circle(selector, patternCorners[1], 1, cv::Scalar(255,0,0),6, 8, 0);
circle(selector, patternCorners[2], 1, cv::Scalar(255,0,0),6, 8, 0);
circle(selector, patternCorners[3], 1, cv::Scalar(255,0,0),6, 8, 0);
}
/// Check pattern distribution
if(good && (patternCorners[0].x < qtWidth || patternCorners[0].y < qtHeigh))
good = false;
if(good && (patternCorners[1].x > (i-1)*qtWidth || patternCorners[1].y < qtHeigh))
good = false;
if(good && (patternCorners[2].x < qtWidth || patternCorners[2].y > (i-1)*qtHeigh))
good = false;
if(good && (patternCorners[3].x > (i-1)*qtWidth || patternCorners[3].y > (i-1)*qtHeigh))
good = false;
/// Get Area realation
cv::RotatedRect minRect = cv::minAreaRect(patternCorners);
cv::RotatedRect minRect_ = cv::minAreaRect(frameCorners);
patternArea = minRect.size.width * minRect.size.height;
totalArea = minRect_.size.width * minRect_.size.height;
//std::cout<<"T: " <<totalArea <<" - P: "<< patternArea <<std::endl;
if(good && (patternArea < totalArea/(i-1))){
good = false;
}
if(displaySelector == 1)
{
cv::Point2f rect_points[4]; minRect.points(rect_points);
for( int j = 0; j < 4; j++ )
line( selector, rect_points[j], rect_points[(j+1)%4], cv::Scalar(255,0,0), 1, 8 );
cv::namedWindow("Selector", cv::WINDOW_NORMAL);
imshow("Selector", selector);
}
if(good)
{
//std::cout<<" - 0" <<std::endl;
if(previousCorners)
{
//std::cout<<" - 1" <<std::endl;
for( int k = 0; k < previousCornersBuf.size(); k++ ){
totalDistDisplace += cv::norm(previousCornersBuf[k] - patternCorners[k]);
}
if((totalDistDisplace/previousCornersBuf.size()) > (minDistControlPoints/2))
{
//std::cout<<" - 3" <<std::endl;
previousCornersBuf.clear();
previousCornersBuf = patternCorners;
return true;
}
}
else
{
//std::cout<<" - 2" <<std::endl;
previousCornersBuf = patternCorners;
return true;
}
}
return false;
}
bool
isGoodFrameImp( cv::Mat src,
std::vector<cv::Point2f>& pointbuf,
std::vector<cv::Point2f>& previousCornersBuf,
bool previousCorners,
int patternWidth,
int patternHeigh,
float &minDistControlPoints)
{
int magicNumber = 16;
float a, b, c;
a = 2.0; b = 4.5; c = 3.0;
int qtWidth, qtHeigh;
bool good = true;
float totalDistDisplace = 0.0f;
std::vector<cv::Point2f> patternCorners;
cv::Mat selector = cv::Mat::zeros(src.rows, src.cols, CV_8UC3);
patternCorners.push_back(pointbuf[0]);
patternCorners.push_back(pointbuf[patternWidth-1]);
patternCorners.push_back(pointbuf[pointbuf.size()-patternWidth]);
patternCorners.push_back(pointbuf[pointbuf.size()-1]);
qtWidth = src.cols/magicNumber;
qtHeigh = src.rows/magicNumber;
if(displaySelector == 1)
{
/// Vertical lines
line(selector, cv::Point2f(a*qtWidth,0), cv::Point2f(a*qtWidth, src.rows), cv::Scalar(0,0,255), 2, 8, 0);
line(selector, cv::Point2f(src.cols-(a*qtWidth),0), cv::Point2f(src.cols-(a*qtWidth), src.rows), cv::Scalar(0,0,255), 2, 8, 0);
line(selector, cv::Point2f((a+b)*qtWidth,0), cv::Point2f((a+b)*qtWidth, src.rows), cv::Scalar(0,0,255), 2, 8, 0);
line(selector, cv::Point2f(src.cols-(a+b)*qtWidth,0), cv::Point2f(src.cols-(a+b)*qtWidth, src.rows), cv::Scalar(0,0,255), 2, 8, 0);
/// Horizontal lines
line(selector, cv::Point2f(0, a*qtHeigh), cv::Point2f(src.cols, a*qtHeigh), cv::Scalar(0,0,255), 2, 8, 0);
line(selector, cv::Point2f(0, src.rows-a*qtHeigh), cv::Point2f(src.cols, src.rows-a*qtHeigh), cv::Scalar(0,0,255), 2, 8, 0);
line(selector, cv::Point2f(0, (a+b)*qtHeigh), cv::Point2f(src.cols, (a+b)*qtHeigh), cv::Scalar(0,0,255), 2, 8, 0);
line(selector, cv::Point2f(0, src.rows-(a+b)*qtHeigh), cv::Point2f(src.cols, src.rows-(a+b)*qtHeigh), cv::Scalar(0,0,255), 2, 8, 0);
/// Draw pattern corners
circle(selector, patternCorners[0], 1, cv::Scalar(255,0,0),6, 8, 0);
circle(selector, patternCorners[1], 1, cv::Scalar(255,0,0),6, 8, 0);
circle(selector, patternCorners[2], 1, cv::Scalar(255,0,0),6, 8, 0);
circle(selector, patternCorners[3], 1, cv::Scalar(255,0,0),6, 8, 0);
}
/// Check pattern distribution
if(good && (patternCorners[0].x > (a+b)*qtWidth || patternCorners[0].y > (a+b)*qtHeigh))
good = false;
if(good && (patternCorners[1].x < (magicNumber-(a+b))*qtWidth || patternCorners[1].y > (a+b)*qtHeigh))
good = false;
if(good && (patternCorners[2].x > (a+b)*qtWidth || patternCorners[2].y < (magicNumber-(a+b))*qtHeigh))
good = false;
if(good && (patternCorners[3].x < (magicNumber-(a+b))*qtWidth || patternCorners[3].y < (magicNumber-(a+b))*qtHeigh))
good = false;
if(good && (patternCorners[0].x < a*qtWidth || patternCorners[0].y < a*qtHeigh))
good = false;
if(good && (patternCorners[1].x > (magicNumber-a)*qtWidth || patternCorners[1].y < a*qtHeigh))
good = false;
if(good && (patternCorners[2].x < a*qtWidth || patternCorners[2].y > (magicNumber-a)*qtHeigh))
good = false;
if(good && (patternCorners[3].x > (magicNumber-a)*qtWidth || patternCorners[3].y > (magicNumber-a)*qtHeigh))
good = false;
/// Get Area realation
/*cv::RotatedRect minRect = cv::minAreaRect(patternCorners);
cv::RotatedRect minRect_ = cv::minAreaRect(frameCorners);
patternArea = minRect.size.width * minRect.size.height;
totalArea = minRect_.size.width * minRect_.size.height;
*/
//std::cout<<"T: " <<totalArea <<" - P: "<< patternArea <<std::endl;
/*if(good && (patternArea < totalArea/(i-1))){
good = false;
}*/
if(displaySelector == 1)
{
//cv::Point2f rect_points[4]; minRect.points(rect_points);
/*for( int j = 0; j < 4; j++ )
line( selector, rect_points[j], rect_points[(j+1)%4], cv::Scalar(255,0,0), 1, 8 );
*/
cv::namedWindow("Selector", cv::WINDOW_NORMAL);
imshow("Selector", selector);
}
if(good)
{
//std::cout<<" - 0" <<std::endl;
if(previousCorners)
{
//std::cout<<" - 1" <<std::endl;
for( int k = 0; k < previousCornersBuf.size(); k++ ){
totalDistDisplace += cv::norm(previousCornersBuf[k] - patternCorners[k]);
}
if((totalDistDisplace/previousCornersBuf.size()) > minDistControlPoints/2)
{
//std::cout<<" - 3" <<std::endl;
previousCornersBuf.clear();
previousCornersBuf = patternCorners;
return true;
}
}
else
{
//std::cout<<" - 2" <<std::endl;
previousCornersBuf = patternCorners;
return true;
}
}
return false;
} | [
"griselly.ramos.c@gmail.com"
] | griselly.ramos.c@gmail.com |
565bb57047f908e1dead197f490c066bef8a5123 | b263e47a748a74a7b1e49b4d8dd16e6d91b08612 | /AbstractField_p.h | 32900808892bfd90b80fe7538194c1ddefe65170 | [] | no_license | Weinbery/flat-gui | 0d3794f55e51b69ef7862ac5835cd0c1b2fa6d15 | 4645f23b8121d70dc6a8bbbec69ffefea4e45950 | refs/heads/master | 2022-12-13T09:33:28.014059 | 2020-09-12T00:31:23 | 2020-09-12T00:31:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,510 | h | /**
MIT License
Copyright (c) 2018 Michael Scopchanov
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 FIELD_P_H
#define FIELD_P_H
#include <QtCore/qglobal.h>
#include <QString>
class AbstractDataModel;
class AbstractDecoration;
class ToolButton;
class AbstractFieldPrivate {
explicit AbstractFieldPrivate();
AbstractDataModel *model;
AbstractDecoration *decoration;
ToolButton *btnClear;
QString text;
QString placeholderText;
bool required;
bool active;
friend class AbstractField;
};
#endif // FIELD_P_H
| [
"michael_scopchanov@yahoo.com"
] | michael_scopchanov@yahoo.com |
959ee17b03f2a7d2a39db439f75183a76d969cec | 6ae31c10583e5d8e2e7cb884dae4c82aec5b471a | /fake_docker/clone.cpp | cc6eed281d8ce8f9e4de6d8031fbce2204cf28e6 | [] | no_license | fliaping/docker_learning | b53cd6dcf11f3a82fd46c7c24c2378d4c75a7cf7 | 4edf24d21523f46eeca0e4c5c720dd779fa2da66 | refs/heads/master | 2021-07-12T11:49:32.921461 | 2017-10-08T13:51:32 | 2017-10-08T13:51:32 | 104,034,843 | 7 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,257 | cpp | #define _GNU_SOURCE
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <sched.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
/* 定义一个给 clone 用的栈，栈大小1M */
#define STACK_SIZE (1024 * 1024)
static char container_stack[STACK_SIZE];
#define errExit(code, msg); {if(code == -1){perror(msg); exit(-1);} }
char* const container_args[] = {
"/bin/bash",
NULL
};
static int container_main(void* arg)
{
pid_t pid = getpid();
printf("Container[%d] - inside the container!\n", pid);
/* 直接执行一个shell，以便我们观察这个进程空间里的资源是否被隔离了 */
execv(container_args[0], container_args);
printf("Something's wrong!\n");
return 1;
}
int main()
{
pid_t pid = getpid();
printf("Parent[%d] - start a container!\n", pid);
/* 调用clone函数，其中传出一个函数，还有一个栈空间的（为什么传尾指针，因为栈是反着的） */
int container_pid = clone(container_main, container_stack+STACK_SIZE, SIGCHLD, NULL);
/* 等待子进程结束 */
errExit(container_pid, "clone");
waitpid(container_pid, NULL, 0);
printf("Parent - container stopped!\n");
return 0;
}
| [
"xavierrpayne@gmail.com"
] | xavierrpayne@gmail.com |
98a9b4014825afadfeec1de7450f5b0cd9ba1e70 | 730535c28e76b897ee8ec33cc643e38915f68772 | /google/cloud/status_or_test.cc | 4b440d5b30a8c8869724d16dfb9ce54229b2f522 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | dopiera/google-cloud-cpp | ae833e82aba5edf9d0ad5f0f9be0256d1e0cedef | 9f4ae11bbae26730f46abfc5becdcc25c92a7e83 | refs/heads/master | 2021-06-11T03:19:44.268455 | 2019-01-26T16:05:44 | 2019-01-26T16:05:44 | 153,084,592 | 0 | 0 | Apache-2.0 | 2019-02-13T15:20:12 | 2018-10-15T09:11:59 | C++ | UTF-8 | C++ | false | false | 16,873 | cc | // Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "google/cloud/status_or.h"
#include "google/cloud/testing_util/expect_exception.h"
#include "google/cloud/testing_util/testing_types.h"
#include <gmock/gmock.h>
namespace google {
namespace cloud {
inline namespace GOOGLE_CLOUD_CPP_NS {
namespace {
using ::testing::HasSubstr;
TEST(StatusOrTest, DefaultConstructor) {
StatusOr<int> actual;
EXPECT_FALSE(actual.ok());
EXPECT_FALSE(actual.status().ok());
EXPECT_FALSE(actual);
}
TEST(StatusOrTest, StatusConstructorNormal) {
StatusOr<int> actual(Status(StatusCode::kNotFound, "NOT FOUND"));
EXPECT_FALSE(actual.ok());
EXPECT_FALSE(actual);
EXPECT_EQ(StatusCode::kNotFound, actual.status().code());
EXPECT_EQ("NOT FOUND", actual.status().message());
}
TEST(StatusOrTest, StatusConstructorInvalid) {
testing_util::ExpectException<std::invalid_argument>(
[&] { StatusOr<int> actual(Status{}); },
[&](std::invalid_argument const& ex) {
EXPECT_THAT(ex.what(), HasSubstr("StatusOr"));
},
"exceptions are disabled: "
);
}
TEST(StatusOrTest, ValueConstructor) {
StatusOr<int> actual(42);
EXPECT_TRUE(actual.ok());
EXPECT_TRUE(actual);
EXPECT_EQ(42, actual.value());
EXPECT_EQ(42, std::move(actual).value());
}
TEST(StatusOrTest, ValueConstAccessors) {
StatusOr<int> const actual(42);
EXPECT_TRUE(actual.ok());
EXPECT_EQ(42, actual.value());
EXPECT_EQ(42, std::move(actual).value());
}
TEST(StatusOrTest, ValueAccessorNonConstThrows) {
StatusOr<int> actual(Status(StatusCode::kInternal, "BAD"));
testing_util::ExpectException<RuntimeStatusError>(
[&] { actual.value(); },
[&](RuntimeStatusError const& ex) {
EXPECT_EQ(StatusCode::kInternal, ex.status().code());
EXPECT_EQ("BAD", ex.status().message());
},
"exceptions are disabled: BAD \\[INTERNAL\\]"
);
testing_util::ExpectException<RuntimeStatusError>(
[&] { std::move(actual).value(); },
[&](RuntimeStatusError const& ex) {
EXPECT_EQ(StatusCode::kInternal, ex.status().code());
EXPECT_EQ("BAD", ex.status().message());
},
"exceptions are disabled: BAD \\[INTERNAL\\]"
);
}
TEST(StatusOrTest, ValueAccessorConstThrows) {
StatusOr<int> actual(Status(StatusCode::kInternal, "BAD"));
testing_util::ExpectException<RuntimeStatusError>(
[&] { actual.value(); },
[&](RuntimeStatusError const& ex) {
EXPECT_EQ(StatusCode::kInternal, ex.status().code());
EXPECT_EQ("BAD", ex.status().message());
},
"exceptions are disabled: BAD \\[INTERNAL\\]"
);
testing_util::ExpectException<RuntimeStatusError>(
[&] { std::move(actual).value(); },
[&](RuntimeStatusError const& ex) {
EXPECT_EQ(StatusCode::kInternal, ex.status().code());
EXPECT_EQ("BAD", ex.status().message());
},
"exceptions are disabled: BAD \\[INTERNAL\\]"
);
}
TEST(StatusOrTest, StatusConstAccessors) {
StatusOr<int> const actual(Status(StatusCode::kInternal, "BAD"));
EXPECT_EQ(StatusCode::kInternal, actual.status().code());
EXPECT_EQ(StatusCode::kInternal, std::move(actual).status().code());
}
TEST(StatusOrTest, ValueDeference) {
StatusOr<std::string> actual("42");
EXPECT_TRUE(actual.ok());
EXPECT_EQ("42", *actual);
EXPECT_EQ("42", std::move(actual).value());
}
TEST(StatusOrTest, ValueConstDeference) {
StatusOr<std::string> const actual("42");
EXPECT_TRUE(actual.ok());
EXPECT_EQ("42", *actual);
EXPECT_EQ("42", std::move(actual).value());
}
TEST(StatusOrTest, ValueArrow) {
StatusOr<std::string> actual("42");
EXPECT_TRUE(actual.ok());
EXPECT_EQ(std::string("42"), actual->c_str());
}
TEST(StatusOrTest, ValueConstArrow) {
StatusOr<std::string> const actual("42");
EXPECT_TRUE(actual.ok());
EXPECT_EQ(std::string("42"), actual->c_str());
}
TEST(StatusOrVoidTest, DefaultConstructor) {
StatusOr<void> actual;
EXPECT_FALSE(actual.ok());
EXPECT_FALSE(actual.status().ok());
}
TEST(StatusOrVoidTest, StatusConstructorNormal) {
StatusOr<void> actual(Status(StatusCode::kNotFound, "NOT FOUND"));
EXPECT_FALSE(actual.ok());
EXPECT_EQ(StatusCode::kNotFound, actual.status().code());
EXPECT_EQ("NOT FOUND", actual.status().message());
}
TEST(StatusOrVoidTest, ValueConstructor) {
StatusOr<void> actual(Status{});
EXPECT_TRUE(actual.ok());
testing_util::ExpectNoException([&] { actual.value(); });
testing_util::ExpectNoException([&] { std::move(actual).value(); });
}
TEST(StatusOrVoidTest, ValueConstAccessors) {
StatusOr<void> const actual(Status{});
EXPECT_TRUE(actual.ok());
testing_util::ExpectNoException([&] { actual.value(); });
testing_util::ExpectNoException([&] { std::move(actual).value(); });
}
TEST(StatusOrVoidTest, ValueAccessorNonConstThrows) {
StatusOr<void> actual(Status(StatusCode::kInternal, "BAD"));
testing_util::ExpectException<RuntimeStatusError>(
[&] { actual.value(); },
[&](RuntimeStatusError const& ex) {
EXPECT_EQ(StatusCode::kInternal, ex.status().code());
EXPECT_EQ("BAD", ex.status().message());
},
"exceptions are disabled: BAD \\[INTERNAL\\]"
);
testing_util::ExpectException<RuntimeStatusError>(
[&] { std::move(actual).value(); },
[&](RuntimeStatusError const& ex) {
EXPECT_EQ(StatusCode::kInternal, ex.status().code());
EXPECT_EQ("BAD", ex.status().message());
},
"exceptions are disabled: BAD \\[INTERNAL\\]"
);
}
TEST(StatusOrVoidTest, ValueAccessorConstThrows) {
StatusOr<void> actual(Status(StatusCode::kInternal, "BAD"));
testing_util::ExpectException<RuntimeStatusError>(
[&] { actual.value(); },
[&](RuntimeStatusError const& ex) {
EXPECT_EQ(StatusCode::kInternal, ex.status().code());
EXPECT_EQ("BAD", ex.status().message());
},
"exceptions are disabled: BAD \\[INTERNAL\\]"
);
testing_util::ExpectException<RuntimeStatusError>(
[&] { std::move(actual).value(); },
[&](RuntimeStatusError const& ex) {
EXPECT_EQ(StatusCode::kInternal, ex.status().code());
EXPECT_EQ("BAD", ex.status().message());
},
"exceptions are disabled: BAD \\[INTERNAL\\]"
);
}
TEST(StatusOrVoidTest, StatusConstAccessors) {
StatusOr<void> const actual(Status(StatusCode::kInternal, "BAD"));
EXPECT_EQ(StatusCode::kInternal, actual.status().code());
EXPECT_EQ(StatusCode::kInternal, std::move(actual).status().code());
}
using testing_util::NoDefaultConstructor;
TEST(StatusOrNoDefaultConstructor, DefaultConstructed) {
StatusOr<NoDefaultConstructor> empty;
EXPECT_FALSE(empty.ok());
}
TEST(StatusOrNoDefaultConstructor, ValueConstructed) {
StatusOr<NoDefaultConstructor> actual(
NoDefaultConstructor(std::string("foo")));
EXPECT_TRUE(actual.ok());
EXPECT_EQ(actual->str(), "foo");
}
using testing_util::Observable;
/// @test A default-constructed status does not call the default constructor.
TEST(StatusOrObservableTest, NoDefaultConstruction) {
Observable::reset_counters();
StatusOr<Observable> other;
EXPECT_EQ(0, Observable::default_constructor);
EXPECT_FALSE(other.ok());
}
/// @test A copy-constructed status calls the copy constructor for T.
TEST(StatusOrObservableTest, Copy) {
Observable::reset_counters();
StatusOr<Observable> other(Observable("foo"));
EXPECT_EQ("foo", other.value().str());
EXPECT_EQ(1, Observable::move_constructor);
Observable::reset_counters();
StatusOr<Observable> copy(other);
EXPECT_EQ(1, Observable::copy_constructor);
EXPECT_TRUE(copy.ok());
EXPECT_TRUE(other.ok());
EXPECT_EQ("foo", copy->str());
}
/// @test A move-constructed status calls the move constructor for T.
TEST(StatusOrObservableTest, MoveCopy) {
Observable::reset_counters();
StatusOr<Observable> other(Observable("foo"));
EXPECT_EQ("foo", other.value().str());
EXPECT_EQ(1, Observable::move_constructor);
Observable::reset_counters();
StatusOr<Observable> copy(std::move(other));
EXPECT_EQ(1, Observable::move_constructor);
EXPECT_TRUE(copy.ok());
EXPECT_EQ("foo", copy->str());
EXPECT_TRUE(other.ok());
EXPECT_EQ("moved-out", other->str());
}
/// @test A move-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, MoveAssignment_NoValue_NoValue) {
StatusOr<Observable> other;
StatusOr<Observable> assigned;
EXPECT_FALSE(other.ok());
EXPECT_FALSE(assigned.ok());
Observable::reset_counters();
assigned = std::move(other);
EXPECT_FALSE(other.ok());
EXPECT_FALSE(assigned.ok());
EXPECT_EQ(0, Observable::destructor);
EXPECT_EQ(0, Observable::move_assignment);
EXPECT_EQ(0, Observable::copy_assignment);
EXPECT_EQ(0, Observable::move_constructor);
EXPECT_EQ(0, Observable::copy_constructor);
}
/// @test A move-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, MoveAssignment_NoValue_Value) {
StatusOr<Observable> other(Observable("foo"));
StatusOr<Observable> assigned;
EXPECT_TRUE(other.ok());
EXPECT_FALSE(assigned.ok());
Observable::reset_counters();
assigned = std::move(other);
EXPECT_TRUE(other.ok());
EXPECT_TRUE(assigned.ok());
EXPECT_EQ("foo", assigned->str());
EXPECT_EQ("moved-out", other->str());
EXPECT_EQ(0, Observable::destructor);
EXPECT_EQ(0, Observable::move_assignment);
EXPECT_EQ(0, Observable::copy_assignment);
EXPECT_EQ(1, Observable::move_constructor);
EXPECT_EQ(0, Observable::copy_constructor);
}
/// @test A move-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, MoveAssignment_NoValue_T) {
Observable other("foo");
StatusOr<Observable> assigned;
EXPECT_FALSE(assigned.ok());
Observable::reset_counters();
assigned = std::move(other);
EXPECT_TRUE(assigned.ok());
EXPECT_EQ("foo", assigned->str());
EXPECT_EQ("moved-out", other.str());
EXPECT_EQ(0, Observable::destructor);
EXPECT_EQ(0, Observable::move_assignment);
EXPECT_EQ(0, Observable::copy_assignment);
EXPECT_EQ(1, Observable::move_constructor);
EXPECT_EQ(0, Observable::copy_constructor);
}
/// @test A move-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, MoveAssignment_Value_NoValue) {
StatusOr<Observable> other;
StatusOr<Observable> assigned(Observable("bar"));
EXPECT_FALSE(other.ok());
EXPECT_TRUE(assigned.ok());
Observable::reset_counters();
assigned = std::move(other);
EXPECT_FALSE(other.ok());
EXPECT_FALSE(assigned.ok());
EXPECT_EQ(1, Observable::destructor);
EXPECT_EQ(0, Observable::move_assignment);
EXPECT_EQ(0, Observable::copy_assignment);
EXPECT_EQ(0, Observable::move_constructor);
EXPECT_EQ(0, Observable::copy_constructor);
}
/// @test A move-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, MoveAssignment_Value_Value) {
StatusOr<Observable> other(Observable("foo"));
StatusOr<Observable> assigned(Observable("bar"));
EXPECT_TRUE(other.ok());
EXPECT_TRUE(assigned.ok());
Observable::reset_counters();
assigned = std::move(other);
EXPECT_TRUE(other.ok());
EXPECT_TRUE(assigned.ok());
EXPECT_EQ(0, Observable::destructor);
EXPECT_EQ(1, Observable::move_assignment);
EXPECT_EQ(0, Observable::copy_assignment);
EXPECT_EQ(0, Observable::move_constructor);
EXPECT_EQ(0, Observable::copy_constructor);
EXPECT_EQ("foo", assigned->str());
EXPECT_EQ("moved-out", other->str());
}
/// @test A move-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, MoveAssignment_Value_T) {
Observable other("foo");
StatusOr<Observable> assigned(Observable("bar"));
EXPECT_TRUE(assigned.ok());
Observable::reset_counters();
assigned = std::move(other);
EXPECT_TRUE(assigned.ok());
EXPECT_EQ(0, Observable::destructor);
EXPECT_EQ(1, Observable::move_assignment);
EXPECT_EQ(0, Observable::copy_assignment);
EXPECT_EQ(0, Observable::move_constructor);
EXPECT_EQ(0, Observable::copy_constructor);
EXPECT_EQ("foo", assigned->str());
EXPECT_EQ("moved-out", other.str());
}
/// @test A copy-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, CopyAssignment_NoValue_NoValue) {
StatusOr<Observable> other;
StatusOr<Observable> assigned;
EXPECT_FALSE(other.ok());
EXPECT_FALSE(assigned.ok());
Observable::reset_counters();
assigned = other;
EXPECT_FALSE(other.ok());
EXPECT_FALSE(assigned.ok());
EXPECT_EQ(0, Observable::destructor);
EXPECT_EQ(0, Observable::move_assignment);
EXPECT_EQ(0, Observable::copy_assignment);
EXPECT_EQ(0, Observable::move_constructor);
EXPECT_EQ(0, Observable::copy_constructor);
}
/// @test A copy-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, CopyAssignment_NoValue_Value) {
StatusOr<Observable> other(Observable("foo"));
StatusOr<Observable> assigned;
EXPECT_TRUE(other.ok());
EXPECT_FALSE(assigned.ok());
Observable::reset_counters();
assigned = other;
EXPECT_TRUE(other.ok());
EXPECT_TRUE(assigned.ok());
EXPECT_EQ("foo", assigned->str());
EXPECT_EQ("foo", other->str());
EXPECT_EQ(0, Observable::destructor);
EXPECT_EQ(0, Observable::move_assignment);
EXPECT_EQ(0, Observable::copy_assignment);
EXPECT_EQ(0, Observable::move_constructor);
EXPECT_EQ(1, Observable::copy_constructor);
}
/// @test A copy-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, CopyAssignment_NoValue_T) {
Observable other("foo");
StatusOr<Observable> assigned;
EXPECT_FALSE(assigned.ok());
Observable::reset_counters();
assigned = other;
EXPECT_TRUE(assigned.ok());
EXPECT_EQ("foo", assigned->str());
EXPECT_EQ("foo", other.str());
EXPECT_EQ(0, Observable::destructor);
EXPECT_EQ(0, Observable::move_assignment);
EXPECT_EQ(0, Observable::copy_assignment);
EXPECT_EQ(0, Observable::move_constructor);
EXPECT_EQ(1, Observable::copy_constructor);
}
/// @test A copy-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, CopyAssignment_Value_NoValue) {
StatusOr<Observable> other;
StatusOr<Observable> assigned(Observable("bar"));
EXPECT_FALSE(other.ok());
EXPECT_TRUE(assigned.ok());
Observable::reset_counters();
assigned = other;
EXPECT_FALSE(other.ok());
EXPECT_FALSE(assigned.ok());
EXPECT_EQ(1, Observable::destructor);
EXPECT_EQ(0, Observable::move_assignment);
EXPECT_EQ(0, Observable::copy_assignment);
EXPECT_EQ(0, Observable::move_constructor);
EXPECT_EQ(0, Observable::copy_constructor);
}
/// @test A copy-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, CopyAssignment_Value_Value) {
StatusOr<Observable> other(Observable("foo"));
StatusOr<Observable> assigned(Observable("bar"));
EXPECT_TRUE(other.ok());
EXPECT_TRUE(assigned.ok());
Observable::reset_counters();
assigned = other;
EXPECT_TRUE(other.ok());
EXPECT_TRUE(assigned.ok());
EXPECT_EQ(0, Observable::destructor);
EXPECT_EQ(0, Observable::move_assignment);
EXPECT_EQ(1, Observable::copy_assignment);
EXPECT_EQ(0, Observable::move_constructor);
EXPECT_EQ(0, Observable::copy_constructor);
EXPECT_EQ("foo", assigned->str());
EXPECT_EQ("foo", other->str());
}
/// @test A copy-assigned status calls the right assignments and destructors.
TEST(StatusOrObservableTest, CopyAssignment_Value_T) {
Observable other("foo");
StatusOr<Observable> assigned(Observable("bar"));
EXPECT_TRUE(assigned.ok());
Observable::reset_counters();
assigned = other;
EXPECT_TRUE(assigned.ok());
EXPECT_EQ(0, Observable::destructor);
EXPECT_EQ(0, Observable::move_assignment);
EXPECT_EQ(1, Observable::copy_assignment);
EXPECT_EQ(0, Observable::move_constructor);
EXPECT_EQ(0, Observable::copy_constructor);
EXPECT_EQ("foo", assigned->str());
EXPECT_EQ("foo", other.str());
}
TEST(StatusOrObservableTest, MoveValue) {
StatusOr<Observable> other(Observable("foo"));
EXPECT_EQ("foo", other.value().str());
Observable::reset_counters();
auto observed = std::move(other).value();
EXPECT_EQ("foo", observed.str());
EXPECT_TRUE(other.ok());
EXPECT_EQ("moved-out", other->str());
}
} // namespace
} // namespace GOOGLE_CLOUD_CPP_NS
} // namespace cloud
} // namespace google
| [
"noreply@github.com"
] | noreply@github.com |
2f90fb3f1b407645e88ccce0a0cecba75d0f083e | 5336e15bd3f2c6423ad76420512cfcab35e72370 | /qptk/utils/matlabexport.h | d7aaeb1ac4c197096be28e6b806501d39c0d4a85 | [
"Apache-2.0"
] | permissive | kulikovv/ProcessingSDK | 29d01ffb1bedb9c9e75444a0cd898fff0163b722 | 5e1046c9a361b0e321d3df2094d596709be39325 | refs/heads/master | 2021-01-09T20:52:43.773542 | 2018-01-16T11:25:45 | 2018-01-16T11:25:45 | 59,268,639 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 509 | h | #ifndef MATLABEXPORT_H
#define MATLABEXPORT_H
#include <utils/rawdataexport.h>
namespace utils{
namespace debug{
class MatlabExport : public RawDataExport
{
Q_OBJECT
public:
explicit MatlabExport(QObject *parent);
~MatlabExport();
static void writeMat( cv::Mat const& mat, const char* filename, const char* varName="RGB", bool bgr2rgb=true );
protected:
virtual void saveData(QString name,cv::Mat img,QString varname);
};
}
}
#endif // MATLABEXPORT_H
| [
"kulikov.victor@gmail.com"
] | kulikov.victor@gmail.com |
3720e0451001caf891bbc99b53e9e69b9d1c2b90 | 470fae08316b55246ab01675ac5013febfb13eee | /src/common/Threading/ProcessPriority.cpp | 0bec4684de3dbc7850ec23519712fb12715909f1 | [] | no_license | adde13372/shadowcore | 8db6fb6ccc99821e6bd40237a0c284ce7cf543c2 | aa87944193ce02f6e99f7b35eceac5023abfca1b | refs/heads/main | 2023-04-01T07:38:39.359558 | 2021-04-03T07:54:17 | 2021-04-03T07:54:17 | 354,320,611 | 4 | 8 | null | 2021-04-03T15:02:49 | 2021-04-03T15:02:49 | null | UTF-8 | C++ | false | false | 3,289 | cpp | /*
* Copyright 2021 ShadowCore
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "ProcessPriority.h"
#include "Log.h"
#ifdef _WIN32 // Windows
#include <Windows.h>
#elif defined(__linux__)
#include <sched.h>
#include <sys/resource.h>
#define PROCESS_HIGH_PRIORITY -15 // [-20, 19], default is 0
#endif
void SetProcessPriority(std::string const& logChannel, uint32 affinity, bool highPriority)
{
///- Handle affinity for multiple processors and process priority
#ifdef _WIN32 // Windows
HANDLE hProcess = GetCurrentProcess();
if (affinity > 0)
{
ULONG_PTR appAff;
ULONG_PTR sysAff;
if (GetProcessAffinityMask(hProcess, &appAff, &sysAff))
{
// remove non accessible processors
ULONG_PTR currentAffinity = affinity & appAff;
if (!currentAffinity)
TC_LOG_ERROR(logChannel, "Processors marked in UseProcessors bitmask (hex) %x are not accessible. Accessible processors bitmask (hex): %x", affinity, appAff);
else if (SetProcessAffinityMask(hProcess, currentAffinity))
TC_LOG_INFO(logChannel, "Using processors (bitmask, hex): %x", currentAffinity);
else
TC_LOG_ERROR(logChannel, "Can't set used processors (hex): %x", currentAffinity);
}
}
if (highPriority)
{
if (SetPriorityClass(hProcess, HIGH_PRIORITY_CLASS))
TC_LOG_INFO(logChannel, "Process priority class set to HIGH");
else
TC_LOG_ERROR(logChannel, "Can't set process priority class.");
}
#elif defined(__linux__) // Linux
if (affinity > 0)
{
cpu_set_t mask;
CPU_ZERO(&mask);
for (unsigned int i = 0; i < sizeof(affinity) * 8; ++i)
if (affinity & (1 << i))
CPU_SET(i, &mask);
if (sched_setaffinity(0, sizeof(mask), &mask))
TC_LOG_ERROR(logChannel, "Can't set used processors (hex): %x, error: %s", affinity, strerror(errno));
else
{
CPU_ZERO(&mask);
sched_getaffinity(0, sizeof(mask), &mask);
TC_LOG_INFO(logChannel, "Using processors (bitmask, hex): %lx", *(__cpu_mask*)(&mask));
}
}
if (highPriority)
{
if (setpriority(PRIO_PROCESS, 0, PROCESS_HIGH_PRIORITY))
TC_LOG_ERROR(logChannel, "Can't set process priority class, error: %s", strerror(errno));
else
TC_LOG_INFO(logChannel, "Process priority class set to %i", getpriority(PRIO_PROCESS, 0));
}
#else
// Suppresses unused argument warning for all other platforms
(void)logChannel;
(void)affinity;
(void)highPriority;
#endif
}
| [
"81566364+NemoPRM@users.noreply.github.com"
] | 81566364+NemoPRM@users.noreply.github.com |
471413c9e88e252b2ca92bee1b77e3dccffd4a96 | d3e63156dfc1bd6e068cce3325d56055f7b0ef7d | /CMinus/CMinus/evaluator/generic_evaluator_object.h | 330473ad5bc3f2860003fd32aaa4e3fb44fa03d0 | [
"MIT"
] | permissive | benbraide/CMinusMinus | 7c3a6110606e4ca27c67b3465e1dad83a3482575 | 6e32b825f192634538b3adde6ca579a548ca3f7e | refs/heads/master | 2020-07-25T17:26:11.035770 | 2019-12-24T06:35:28 | 2019-12-24T06:35:28 | 208,368,689 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,016 | h | #pragma once
#include "comparison.h"
#include "assignment.h"
namespace cminus::evaluator{
template <class target_type>
class generic_object : public object, public assignment, public generic_comparison<target_type>{
public:
virtual ~generic_object() = default;
virtual memory_ptr_type evaluate_unary_left(operators::id op, memory_ptr_type target) const override{
throw exception::unsupported_op();
return nullptr;
}
virtual memory_ptr_type evaluate_unary_right(operators::id op, memory_ptr_type target) const override{
throw exception::unsupported_op();
return nullptr;
}
protected:
virtual memory_ptr_type evaluate_binary_(operators::id op, memory_ptr_type left_value, node_ptr_type right) const override{
if (assignment::assign(op, left_value, right))
return left_value;
if (auto result = generic_comparison<target_type>::template evaluate(op, left_value, right); result != nullptr)
return result;
throw exception::unsupported_op();
return nullptr;
}
};
}
| [
"benbraide@yahoo.com"
] | benbraide@yahoo.com |
86eb2839002dede1a8ff50b3bc8893a829995b7c | 560090526e32e009e2e9331e8a2b4f1e7861a5e8 | /Compiled/blaze-3.2/blaze/math/lapack/heev.h | b3f720411ad21596a9a98d8754f90f2878bfea6f | [
"BSD-3-Clause"
] | permissive | jcd1994/MatlabTools | 9a4c1f8190b5ceda102201799cc6c483c0a7b6f7 | 2cc7eac920b8c066338b1a0ac495f0dbdb4c75c1 | refs/heads/master | 2021-01-18T03:05:19.351404 | 2018-02-14T02:17:07 | 2018-02-14T02:17:07 | 84,264,330 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,372 | h | //=================================================================================================
/*!
// \file blaze/math/lapack/heev.h
// \brief Header file for the LAPACK Hermitian matrix eigenvalue functions (heev)
//
// Copyright (C) 2012-2017 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or modify it under
// the terms of the New (Revised) BSD License. Redistribution and use in source and binary
// forms, with or without modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other materials
// provided with the distribution.
// 3. Neither the names of the Blaze development group nor the names of its contributors
// may be used to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
// SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
// TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
// BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
*/
//=================================================================================================
#ifndef _BLAZE_MATH_LAPACK_HEEV_H_
#define _BLAZE_MATH_LAPACK_HEEV_H_
//*************************************************************************************************
// Includes
//*************************************************************************************************
#include <memory>
#include <blaze/math/Aliases.h>
#include <blaze/math/constraints/Adaptor.h>
#include <blaze/math/constraints/BLASCompatible.h>
#include <blaze/math/constraints/Computation.h>
#include <blaze/math/constraints/MutableDataAccess.h>
#include <blaze/math/Exception.h>
#include <blaze/math/expressions/DenseMatrix.h>
#include <blaze/math/expressions/DenseVector.h>
#include <blaze/math/lapack/clapack/heev.h>
#include <blaze/math/typetraits/IsResizable.h>
#include <blaze/math/typetraits/IsRowMajorMatrix.h>
#include <blaze/util/Assert.h>
#include <blaze/util/constraints/Complex.h>
#include <blaze/util/NumericCast.h>
namespace blaze {
//=================================================================================================
//
// LAPACK HERMITIAN MATRIX EIGENVALUE FUNCTIONS (HEEV)
//
//=================================================================================================
//*************************************************************************************************
/*!\name LAPACK Hermitian matrix eigenvalue functions (heev) */
//@{
template< typename MT, bool SO, typename VT, bool TF >
inline void heev( DenseMatrix<MT,SO>& A, DenseVector<VT,TF>& w, char jobz, char uplo );
//@}
//*************************************************************************************************
//*************************************************************************************************
/*!\brief LAPACK kernel for computing the eigenvalues of the given dense Hermitian matrix.
// \ingroup lapack_eigenvalue
//
// \param A The given Hermitian matrix.
// \param w The resulting vector of eigenvalues.
// \param jobz \c 'V' to compute the eigenvectors of \a A, \c 'N' to only compute the eigenvalues.
// \param uplo \c 'L' to use the lower part of the matrix, \c 'U' to use the upper part.
// \return void
// \exception std::invalid_argument Invalid non-square matrix provided.
// \exception std::invalid_argument Vector cannot be resized.
// \exception std::invalid_argument Invalid jobz argument provided.
// \exception std::invalid_argument Invalid uplo argument provided.
// \exception std::runtime_error Eigenvalue computation failed.
//
// This function computes the eigenvalues of a Hermitian \a n-by-\a n matrix based on the LAPACK
// heev() functions. Optionally, it computes the left and right eigenvectors.
//
// The real eigenvalues are returned in ascending order in the given vector \a w. \a w is resized
// to the correct size (if possible and necessary). In case \a A is a row-major matrix, the left
// eigenvectors are returned in the rows of \a A, in case \a A is a column-major matrix, the right
// eigenvectors are returned in the columns of \a A.
//
// The function fails if ...
//
// - ... the given matrix \a A is not a square matrix;
// - ... the given vector \a w is a fixed size vector and the size doesn't match;
// - ... the given \a jobz argument is neither \c 'V' nor \c 'N';
// - ... the given \a uplo argument is neither \c 'L' nor \c 'U';
// - ... the eigenvalue computation fails.
//
// In all failure cases a \a std::invalid_argument exception is thrown.
//
// Examples:
\code
using blaze::DynamicMatrix;
using blaze::DynamicVector;
using blaze::rowMajor;
using blaze::columnVector;
DynamicMatrix<complex<double>,rowMajor> A( 5UL, 5UL ); // The Hermitian matrix A
// ... Initialization
DynamicVector<double,columnVector> w( 5UL ); // The vector for the real eigenvalues
heev( A, w, 'V', 'L' );
\endcode
// For more information on the heev() functions (i.e. cheev() and zheev()) see the LAPACK online
// documentation browser:
//
// http://www.netlib.org/lapack/explore-html/
//
// \note This function can only be used if a fitting LAPACK library, which supports this function,
// is available and linked to the executable. Otherwise a call to this function will result in a
// linker error.
*/
template< typename MT // Type of the matrix A
, bool SO // Storage order of the matrix A
, typename VT // Type of the vector w
, bool TF > // Transpose flag of the vector w
inline void heev( DenseMatrix<MT,SO>& A, DenseVector<VT,TF>& w, char jobz, char uplo )
{
BLAZE_CONSTRAINT_MUST_NOT_BE_ADAPTOR_TYPE( MT );
BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE( MT );
BLAZE_CONSTRAINT_MUST_HAVE_MUTABLE_DATA_ACCESS( MT );
BLAZE_CONSTRAINT_MUST_BE_BLAS_COMPATIBLE_TYPE( ElementType_<MT> );
BLAZE_CONSTRAINT_MUST_BE_COMPLEX_TYPE( ElementType_<MT> );
BLAZE_CONSTRAINT_MUST_NOT_BE_COMPUTATION_TYPE( VT );
BLAZE_CONSTRAINT_MUST_HAVE_MUTABLE_DATA_ACCESS( VT );
BLAZE_CONSTRAINT_MUST_BE_BLAS_COMPATIBLE_TYPE( ElementType_<VT> );
BLAZE_CONSTRAINT_MUST_BE_BUILTIN_TYPE( ElementType_<VT> );
using CT = ElementType_<MT>;
using BT = UnderlyingElement_<CT>;
if( !isSquare( ~A ) ) {
BLAZE_THROW_INVALID_ARGUMENT( "Invalid non-square matrix provided" );
}
if( jobz != 'V' && jobz != 'N' ) {
BLAZE_THROW_INVALID_ARGUMENT( "Invalid jobz argument provided" );
}
if( uplo != 'L' && uplo != 'U' ) {
BLAZE_THROW_INVALID_ARGUMENT( "Invalid uplo argument provided" );
}
resize( ~w, (~A).rows(), false );
int n ( numeric_cast<int>( (~A).rows() ) );
int lda ( numeric_cast<int>( (~A).spacing() ) );
int info( 0 );
if( n == 0 ) {
return;
}
int lwork( 10*n + 2 );
const std::unique_ptr<CT[]> work ( new CT[lwork] );
const std::unique_ptr<BT[]> rwork( new BT[3*n-2] );
if( IsRowMajorMatrix<MT>::value ) {
( uplo == 'L' )?( uplo = 'U' ):( uplo = 'L' );
}
heev( jobz, uplo, n, (~A).data(), lda, (~w).data(), work.get(), lwork, rwork.get(), &info );
BLAZE_INTERNAL_ASSERT( info >= 0, "Invalid argument for eigenvalue computation" );
if( info > 0 ) {
BLAZE_THROW_LAPACK_ERROR( "Eigenvalue computation failed" );
}
}
//*************************************************************************************************
} // namespace blaze
#endif
| [
"jonathan.doucette@alumni.ubc.ca"
] | jonathan.doucette@alumni.ubc.ca |
3bc434a90fcf5f64644cacdefd57bf359c744465 | c58e108e7cf54254dea3f755e7c9a03e2fe64a46 | /src/qt/oro/sendmemodialog.cpp | d526108f85b38e544df2fb6b19cbd3faa0e6bdf7 | [
"MIT"
] | permissive | ORO-mlm/ORO-Core | 9888490355db1ce55b43998086af7dc589d19d10 | 770e4728e1b67023f2f52da2850e058732e7583f | refs/heads/main | 2023-06-17T02:07:47.355318 | 2021-07-13T11:43:51 | 2021-07-13T11:43:51 | 317,410,361 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,726 | cpp | // Copyright (c) 2019-2020 The PIVX developers
// Copyright (c) 2021- The ORO developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "qt/oro/sendmemodialog.h"
#include "qt/oro/forms/ui_sendmemodialog.h"
#include "qt/oro/snackbar.h"
#include "qt/oro/qtutils.h"
SendMemoDialog::SendMemoDialog(QWidget* parent, WalletModel* model) :
FocusedDialog(parent),
walletModel(model),
ui(new Ui::SendMemoDialog)
{
if (!walletModel) {
throw std::runtime_error(strprintf("%s: No wallet model set", __func__));
}
ui->setupUi(this);
this->setStyleSheet(parent->styleSheet());
// Container
ui->frame->setProperty("cssClass", "container-dialog");
// Text
ui->labelTitle->setProperty("cssClass", "text-title-dialog");
ui->labelMessage->setProperty("cssClass", "text-main-grey");
setCssProperty(ui->textEdit, "edit-text-dialog");
// Buttons
ui->btnEsc->setText("");
ui->btnEsc->setProperty("cssClass", "ic-close");
ui->btnCancel->setProperty("cssClass", "btn-dialog-cancel");
setCssBtnPrimary(ui->btnSave);
connect(ui->textEdit, &QTextEdit::textChanged, this, &SendMemoDialog::textChanged);
connect(ui->btnEsc, &QPushButton::clicked, [this]() {
operationResult = false;
close();
});
connect(ui->btnCancel, &QPushButton::clicked, this, &SendMemoDialog::reset);
connect(ui->btnSave, &QPushButton::clicked, this, &SendMemoDialog::accept);
}
void SendMemoDialog::setMemo(QString text)
{
ui->textEdit->setText(text);
ui->btnCancel->setText(tr("RESET"));
}
QString SendMemoDialog::getMemo()
{
return ui->textEdit->toPlainText();
}
void SendMemoDialog::textChanged()
{
if (ui->textEdit->toPlainText().length() > 512) {
ui->textEdit->textCursor().deletePreviousChar();
}
}
void SendMemoDialog::showEvent(QShowEvent *event)
{
if (ui->textEdit) ui->textEdit->setFocus();
}
void SendMemoDialog::reset()
{
if (!ui->textEdit->toPlainText().isEmpty()) {
ui->textEdit->clear();
ui->btnCancel->setText(tr("CANCEL"));
}
// caller reset memo on the recipient
operationResult = true;
close();
}
void SendMemoDialog::accept()
{
operationResult = true;
if (ui->textEdit->toPlainText().isEmpty()) {
QDialog::close();
} else {
QDialog::accept();
}
}
void SendMemoDialog::inform(const QString& text)
{
if (!snackBar) snackBar = new SnackBar(nullptr, this);
snackBar->setText(text);
snackBar->resize(this->width(), snackBar->height());
openDialog(snackBar, this);
}
SendMemoDialog::~SendMemoDialog()
{
delete ui;
}
| [
"brandon2davincci@gmail.com"
] | brandon2davincci@gmail.com |
1f8cdf4eceb65ca212e7487849c1e081b1da86ce | fe579365a3aa41d26254c4eaff26e80b21a43060 | /task 6.cpp | de11a6e69910e4a26d0d59063c04df4a267948b3 | [] | no_license | Dimash1905/dimash | 9f563a19fc3fc02eb806308d644b66bdbba075ab | 4af9b74438b30abaea2e9f29beef8962f53c9e90 | refs/heads/master | 2020-09-13T01:15:41.511358 | 2019-11-19T07:33:29 | 2019-11-19T07:33:29 | 222,618,068 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 122 | cpp | #include<iostream>
using namespace std;
int main (){
int a=1,b=2,c=4;
cout<<a+b-c;
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
00e92bb39d641673bba5e16c914297a090481876 | 8cb3c8b6686cf5f73a5b104c14c3829b0d28b4d6 | /NodeMCU wifi/AccessPt/OLED_Functs.ino | b13d22f7c6b5303484c8dc9905151af7d864d9ae | [] | no_license | hollywright03/4810Code | 883add872c0057e0c86865419c17e0423d9547fc | ba508212dd14d9eb71209eccda0533dd9dbe062c | refs/heads/master | 2021-01-21T11:39:35.391130 | 2016-05-15T09:08:03 | 2016-05-15T09:08:03 | 55,884,861 | 0 | 0 | null | 2016-04-12T03:30:47 | 2016-04-10T06:47:40 | Arduino | UTF-8 | C++ | false | false | 5,285 | ino | #include "font.h"
#define OLED_address 0x3c //OLED I2C bus address... even if OLED states 0x78 !!!
#define TOP2BOTTOM
// Actually this sends a byte, not a char to draw in the display.
static void SendChar(unsigned char data)
{
Wire.beginTransmission(OLED_address); // begin transmitting
Wire.write(0x40); //data mode
Wire.write(data);
Wire.endTransmission(); // stop transmitting
}
static void sendcommand(unsigned char com)
{
Wire.beginTransmission(OLED_address); //begin transmitting
Wire.write(0x80); //command mode
Wire.write(com);
Wire.endTransmission(); // stop transmitting
}
// Set the cursor position in a 16 COL * 8 ROW map.
static void setXY(unsigned char row,unsigned char col)
{
sendcommand(0xb0+row); //set page address
sendcommand(0x00+(8*col&0x0f)); //set low col address
sendcommand(0x10+((8*col>>4)&0x0f)); //set high col address
}
static void clear_display(void)
{
unsigned char i,k;
for(k=0;k<8;k++)
{
setXY(k,0);
{
for(i=0;i<128;i++) //clear all COL
{
SendChar(0); //clear all COL
}
}
}
setXY(0,0); // added MRB
}
// Prints a display char (not just a byte) in coordinates X Y,
static void sendCharXY(unsigned char data, int X, int Y)
{ /*
//if(interrupt && !doing_menu) return;// Stop printing only if interrupt is call but not in button functions
setXY(X, Y);
Wire.beginTransmission(OLED_address); // begin transmitting
Wire.write(0x40); //data mode
for(int i=0;i<8;i++)
Wire.write(pgm_read_byte(myFont[data-0x20]+i));
Wire.endTransmission(); // stop transmitting */
}
// Prints a string regardless the cursor position.
// static void sendStr(unsigned char *string)
static void sendStr( char *string)
{
unsigned char i=0;
while(*string)
{
for(i=0;i<8;i++)
{
SendChar(pgm_read_byte(myFont[*string-0x20]+i));
}
*string++;
}
}
// Prints a string in coordinates X Y, being multiples of 8.
// This means we have 16 COLS (0-15) and 8 ROWS (0-7).
static void sendStrXY( char *string, int X, int Y)
{
setXY(X,Y);
unsigned char i=0;
while(*string)
{
for(i=0;i<8;i++)
{
SendChar(pgm_read_byte(myFont[*string-0x20]+i));
}
*string++;
}
}
// Inits oled and draws logo at startup
static void init_OLED(void)
{
sendcommand(0xae); //display off
sendcommand(0xa6); //Set Normal Display (default)
sendcommand(0xAE); //DISPLAYOFF
sendcommand(0xD5); //SETDISPLAYCLOCKDIV
sendcommand(0x80); // the suggested ratio 0x80
sendcommand(0xA8); //SSD1306_SETMULTIPLEX
sendcommand(0x3F);
sendcommand(0xD3); //SETDISPLAYOFFSET
sendcommand(0x0); //no offset
sendcommand(0x40 | 0x0); //SETSTARTLINE
sendcommand(0x8D); //CHARGEPUMP
sendcommand(0x14);
sendcommand(0x20); //MEMORYMODE
sendcommand(0x00); //0x0 act like ks0108
//sendcommand(0xA0 | 0x1); //SEGREMAP //Rotate screen 180 deg
sendcommand(0xA0);
//sendcommand(0xC8); //COMSCANDEC Rotate screen 180 Deg
sendcommand(0xC0);
sendcommand(0xDA); //0xDA
sendcommand(0x12); //COMSCANDEC
sendcommand(0x81); //SETCONTRAS
sendcommand(0xCF);
sendcommand(0xd9); //SETPRECHARGE
sendcommand(0xF1);
sendcommand(0xDB); //SETVCOMDETECT
sendcommand(0x40);
sendcommand(0xA4); //DISPLAYALLON_RESUME
sendcommand(0xA6); //NORMALDISPLAY
clear_display();
sendcommand(0x2e); // stop scroll
//----------------------------REVERSE comments----------------------------//
// Next 3 command lines control display top-bottom or bottom-top MRB 20150718
#ifdef TOP2BOTTOM
sendcommand(0xa0); //seg re-map 0->127(default)
sendcommand(0xa1); //seg re-map 127->0
sendcommand(0xc8);
#endif
// delay(1000);
//----------------------------REVERSE comments----------------------------//
// sendcommand(0xa7); //Set Inverse Display
// sendcommand(0xae); //display off
sendcommand(0x20); //Set Memory Addressing Mode
sendcommand(0x00); //Set Memory Addressing Mode ab Horizontal addressing mode
// sendcommand(0x02); // Set Memory Addressing Mode ab Page addressing mode(RESET)
// setXY(0,0);
// Display Logo here :)
// for(int i=0;i<128*8;i++) // show 128* 64 Logo
// {
// SendChar(pgm_read_byte(logo+i));
// }
// sendcommand(0xaf); //display on
// delay(5000);
}
void displayOn(void)
{
sendcommand(0xaf); //display on
}
void displayOff(void)
{
sendcommand(0xae); //display off
}
static void reset_display(void)
{
displayOff();
clear_display();
displayOn();
}
void StartUp_OLED()
{
init_OLED();
reset_display();
displayOff();
setXY(0,0);
clear_display();
displayOn();
}
| [
"weberca94@gmail.com"
] | weberca94@gmail.com |
0d7bc6c62a956e63b14e625413862f51418126d0 | c618bbf2719431999b1007461df0865bab60c883 | /dali/kernels/reduce/reduce_gpu.h | 2e44a72d75e2df40a884b8b28ded3492160fdfbb | [
"Apache-2.0"
] | permissive | NVIDIA/DALI | 3d0d061135d19e092647e6522046b2ff23d4ef03 | 92ebbe5c20e460050abd985acb590e6c27199517 | refs/heads/main | 2023-09-04T01:53:59.033608 | 2023-09-01T13:45:03 | 2023-09-01T13:45:03 | 135,768,037 | 4,851 | 648 | Apache-2.0 | 2023-09-12T18:00:22 | 2018-06-01T22:18:01 | C++ | UTF-8 | C++ | false | false | 26,814 | h | // Copyright (c) 2020, NVIDIA CORPORATION. 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.
#ifndef DALI_KERNELS_REDUCE_REDUCE_GPU_H_
#define DALI_KERNELS_REDUCE_REDUCE_GPU_H_
/**
* @file
*
* This file contains classes for performing various reductions on GPU.
*/
#include <memory>
#include "dali/kernels/kernel.h"
#include "dali/core/host_dev.h"
#include "dali/core/tensor_view.h"
namespace dali {
namespace kernels {
/**
* @brief Calculates the sum of elements in the tensor(s) along given axes
*
* @details
* The reduction can be described by the following algorithm:
*
* ```
* function reduce(out, in, dim, in_coords, out_coords, in_size, axes)
* if dim == number_of_dimensions(in) - 1
* if in_size[dim] == 0:
* out[out_coords] = neutral_element
* else
* out[out_coords] = reduce(out[out_coords], in[in_coords])
* else
* for i = 0 to in_size[dim]
* if axes contains dim
* out_coords[dim] = 0
* else
* out_coords[dim] = i
* reduce(out, in, dim + 1, in_coords, out_coords, in_size, axes)
* ```
*
* If batch reduction is requested, the corresponding elements of the output tensors
* (calculated as in the algorithm above) are also reduced and the output batch contains
* just one tensor.
*
* For batch reduction to be possible, non-reduced extents of all samples must be equal.
*/
template <typename Out, typename In>
class DLL_PUBLIC SumGPU {
public:
SumGPU();
~SumGPU();
/**
* @brief Sets up the reduction
*
* Sets up the reduction according to the parameters. The indices of dimensions to be reduced
* are provided in `axes` parameter.
* For a successful batch reduction, the reduced shape of all samples must be equal (but the
* input may have non-uniform shape, as long as the non-uniform dimensions are reduced).
*
* @param ctx the execution environment
* @param in_shape shape of the input tensor list
* @param axes indices of axes to reduce along
* @param keep_dims if true, the reduced dimensions are kept in the output shape, with the
* extent of 1
* @param reduce_batch if true, reduces respective output values of all samples in the batch
* and outputs a single tensor
*/
KernelRequirements Setup(KernelContext &ctx,
const TensorListShape<> &in_shape,
span<const int> axes, bool keep_dims, bool reduce_batch);
/**
* @brief Performs the reduction, according to the parameters specified in Setup.
*/
void Run(KernelContext &ctx, const OutListGPU<Out> &out, const InListGPU<In> &in);
private:
class Impl;
std::unique_ptr<Impl> impl_;
};
extern template class SumGPU<uint64_t, uint8_t>;
extern template class SumGPU<float, uint8_t>;
extern template class SumGPU<int64_t, int8_t>;
extern template class SumGPU<float, int8_t>;
extern template class SumGPU<uint64_t, uint16_t>;
extern template class SumGPU<float, uint16_t>;
extern template class SumGPU<int64_t, int16_t>;
extern template class SumGPU<float, int16_t>;
extern template class SumGPU<uint64_t, uint32_t>;
extern template class SumGPU<float, uint32_t>;
extern template class SumGPU<int64_t, int32_t>;
extern template class SumGPU<float, int32_t>;
extern template class SumGPU<uint8_t, uint8_t>;
extern template class SumGPU<int8_t, int8_t>;
extern template class SumGPU<uint16_t, uint16_t>;
extern template class SumGPU<int16_t, int16_t>;
extern template class SumGPU<uint32_t, uint32_t>;
extern template class SumGPU<int32_t, int32_t>;
extern template class SumGPU<uint64_t, uint64_t>;
extern template class SumGPU<int64_t, int64_t>;
extern template class SumGPU<float, float>;
/**
* @brief Calculates the min of elements in the tensor(s) along given axes
*
* @details
* The reduction can be described by the following algorithm:
*
* ```
* function reduce(out, in, dim, in_coords, out_coords, in_size, axes)
* if dim == number_of_dimensions(in) - 1
* if in_size[dim] == 0:
* out[out_coords] = neutral_element
* else
* out[out_coords] = reduce(out[out_coords], in[in_coords])
* else
* for i = 0 to in_size[dim]
* if axes contains dim
* out_coords[dim] = 0
* else
* out_coords[dim] = i
* reduce(out, in, dim + 1, in_coords, out_coords, in_size, axes)
* ```
*
* If batch reduction is requested, the corresponding elements of the output tensors
* (calculated as in the algorithm above) are also reduced and the output batch contains
* just one tensor.
*
* For batch reduction to be possible, non-reduced extents of all samples must be equal.
*/
template <typename Out, typename In>
class DLL_PUBLIC MinGPU {
public:
MinGPU();
~MinGPU();
/**
* @brief Sets up the reduction
*
* Sets up the reduction according to the parameters. The indices of dimensions to be reduced
* are provided in `axes` parameter.
* For a successful batch reduction, the reduced shape of all samples must be equal (but the
* input may have non-uniform shape, as long as the non-uniform dimensions are reduced).
*
* @param ctx the execution environment
* @param in_shape shape of the input tensor list
* @param axes indices of axes to reduce along
* @param keep_dims if true, the reduced dimensions are kept in the output shape, with the
* extent of 1
* @param reduce_batch if true, reduces respective output values of all samples in the batch
* and outputs a single tensor
*/
KernelRequirements Setup(KernelContext &ctx,
const TensorListShape<> &in_shape,
span<const int> axes, bool keep_dims, bool reduce_batch);
/**
* @brief Performs the reduction, according to the parameters specified in Setup.
*/
void Run(KernelContext &ctx, const OutListGPU<Out> &out, const InListGPU<In> &in);
private:
class Impl;
std::unique_ptr<Impl> impl_;
};
extern template class MinGPU<uint8_t, uint8_t>;
extern template class MinGPU<int8_t, int8_t>;
extern template class MinGPU<uint16_t, uint16_t>;
extern template class MinGPU<int16_t, int16_t>;
extern template class MinGPU<uint32_t, uint32_t>;
extern template class MinGPU<int32_t, int32_t>;
extern template class MinGPU<uint64_t, uint64_t>;
extern template class MinGPU<int64_t, int64_t>;
extern template class MinGPU<float, float>;
/**
* @brief Calculates the max of elements in the tensor(s) along given axes
*
* @details
* The reduction can be described by the following algorithm:
*
* ```
* function reduce(out, in, dim, in_coords, out_coords, in_size, axes)
* if dim == number_of_dimensions(in) - 1
* if in_size[dim] == 0:
* out[out_coords] = neutral_element
* else
* out[out_coords] = reduce(out[out_coords], in[in_coords])
* else
* for i = 0 to in_size[dim]
* if axes contains dim
* out_coords[dim] = 0
* else
* out_coords[dim] = i
* reduce(out, in, dim + 1, in_coords, out_coords, in_size, axes)
* ```
*
* If batch reduction is requested, the corresponding elements of the output tensors
* (calculated as in the algorithm above) are also reduced and the output batch contains
* just one tensor.
*
* For batch reduction to be possible, non-reduced extents of all samples must be equal.
*/
template <typename Out, typename In>
class DLL_PUBLIC MaxGPU {
public:
MaxGPU();
~MaxGPU();
/**
* @brief Sets up the reduction
*
* Sets up the reduction according to the parameters. The indices of dimensions to be reduced
* are provided in `axes` parameter.
* For a successful batch reduction, the reduced shape of all samples must be equal (but the
* input may have non-uniform shape, as long as the non-uniform dimensions are reduced).
*
* @param ctx the execution environment
* @param in_shape shape of the input tensor list
* @param axes indices of axes to reduce along
* @param keep_dims if true, the reduced dimensions are kept in the output shape, with the
* extent of 1
* @param reduce_batch if true, reduces respective output values of all samples in the batch
* and outputs a single tensor
*/
KernelRequirements Setup(KernelContext &ctx,
const TensorListShape<> &in_shape,
span<const int> axes, bool keep_dims, bool reduce_batch);
/**
* @brief Performs the reduction, according to the parameters specified in Setup.
*/
void Run(KernelContext &ctx, const OutListGPU<Out> &out, const InListGPU<In> &in);
private:
class Impl;
std::unique_ptr<Impl> impl_;
};
extern template class MaxGPU<uint8_t, uint8_t>;
extern template class MaxGPU<int8_t, int8_t>;
extern template class MaxGPU<uint16_t, uint16_t>;
extern template class MaxGPU<int16_t, int16_t>;
extern template class MaxGPU<uint32_t, uint32_t>;
extern template class MaxGPU<int32_t, int32_t>;
extern template class MaxGPU<uint64_t, uint64_t>;
extern template class MaxGPU<int64_t, int64_t>;
extern template class MaxGPU<float, float>;
/**
* @brief Calculates the mean of elements in the tensor(s) along given axes
*
* @copydetails SumGPU
*
* Output elements are calculated as the sum of input elements divided by the reduction factor,
* given as:
* per-sample reduction:
* ```
* reduction_factor[sample] = product(in_shape[sample][i] for i in axes)
* ```
* batch reduction:
* ```
* reduction_factor =
* sum(
* product(in_shape[sample][i] for i in axes)
* for sample from 0 to number_of_samples
* )
* ```
*
* The reduction factor cannot be zero - if it is, an exception is thrown.
*/
template <typename Out, typename In>
class DLL_PUBLIC MeanGPU {
public:
MeanGPU();
~MeanGPU();
/**
* @brief Sets up the reduction
*
* Sets up the reduction according to the parameters. The indices of dimensions to be reduced
* are provided in `axes` parameter.
* For a successful batch reduction, the reduced shape of all samples must be equal (but the
* input may have non-uniform shape, as long as the non-uniform dimensions are reduced).
*
* @param ctx the execution environment
* @param in_shape shape of the input tensor list
* @param axes indices of axes to reduce along
* @param keep_dims if true, the reduced dimensions are kept in the output shape, with the
* extent of 1
* @param reduce_batch if true, reduces respective output values of all samples in the batch
* and outputs a single tensor
*/
KernelRequirements Setup(KernelContext &ctx,
const TensorListShape<> &in_shape,
span<const int> axes, bool keep_dims, bool reduce_batch);
/**
* @brief Performs the reduction, according to the parameters specified in Setup.
*/
void Run(KernelContext &ctx, const OutListGPU<Out> &out, const InListGPU<In> &in);
private:
class Impl;
std::unique_ptr<Impl> impl_;
};
extern template class MeanGPU<uint8_t, uint8_t>;
extern template class MeanGPU<float, uint8_t>;
extern template class MeanGPU<int8_t, int8_t>;
extern template class MeanGPU<float, int8_t>;
extern template class MeanGPU<uint16_t, uint16_t>;
extern template class MeanGPU<float, uint16_t>;
extern template class MeanGPU<int16_t, int16_t>;
extern template class MeanGPU<float, int16_t>;
extern template class MeanGPU<uint32_t, uint32_t>;
extern template class MeanGPU<float, uint32_t>;
extern template class MeanGPU<int32_t, int32_t>;
extern template class MeanGPU<float, int32_t>;
extern template class MeanGPU<int64_t, int64_t>;
extern template class MeanGPU<float, int64_t>;
extern template class MeanGPU<uint64_t, uint64_t>;
extern template class MeanGPU<float, uint64_t>;
extern template class MeanGPU<float, float>;
/**
* @brief Calculates the mean square of elements in the tensor(s) along given axes
*
* Output elements are calculated as a mean of squared input elements.
* See MeanGPU for details on calculating the mean.
*/
template <typename Out, typename In>
class DLL_PUBLIC MeanSquareGPU {
public:
MeanSquareGPU();
~MeanSquareGPU();
/**
* @brief Sets up the reduction
*
* Sets up the reduction according to the parameters. The indices of dimensions to be reduced
* are provided in `axes` parameter.
* For a successful batch reduction, the reduced shape of all samples must be equal (but the
* input may have non-uniform shape, as long as the non-uniform dimensions are reduced).
*
* @param ctx the execution environment
* @param in_shape shape of the input tensor list
* @param axes indices of axes to reduce along
* @param keep_dims if true, the reduced dimensions are kept in the output shape, with the
* extent of 1
* @param reduce_batch if true, reduces respective output values of all samples in the batch
* and outputs a single tensor
*/
KernelRequirements Setup(KernelContext &ctx,
const TensorListShape<> &in_shape,
span<const int> axes, bool keep_dims, bool reduce_batch);
/**
* @brief Performs the reduction, according to the parameters specified in Setup.
*/
void Run(KernelContext &ctx, const OutListGPU<Out> &out, const InListGPU<In> &in);
private:
class Impl;
std::unique_ptr<Impl> impl_;
};
extern template class MeanSquareGPU<uint64_t, uint8_t>;
extern template class MeanSquareGPU<float, uint8_t>;
extern template class MeanSquareGPU<int64_t, int8_t>;
extern template class MeanSquareGPU<float, int8_t>;
extern template class MeanSquareGPU<uint64_t, uint16_t>;
extern template class MeanSquareGPU<float, uint16_t>;
extern template class MeanSquareGPU<int64_t, int16_t>;
extern template class MeanSquareGPU<float, int16_t>;
extern template class MeanSquareGPU<uint64_t, uint32_t>;
extern template class MeanSquareGPU<float, uint32_t>;
extern template class MeanSquareGPU<int64_t, int32_t>;
extern template class MeanSquareGPU<float, int32_t>;
extern template class MeanSquareGPU<uint64_t, uint64_t>;
extern template class MeanSquareGPU<float, uint64_t>;
extern template class MeanSquareGPU<int64_t, int64_t>;
extern template class MeanSquareGPU<float, int64_t>;
extern template class MeanSquareGPU<float, float>;
/**
* @brief Calculates the root mean square of elements in the tensor(s) along given axes
*
* Output elements are calculated as a squre root of the mean of squared input elements.
* See MeanGPU for details on calculating the mean.
*/
template <typename Out, typename In>
class DLL_PUBLIC RootMeanSquareGPU {
public:
RootMeanSquareGPU();
~RootMeanSquareGPU();
/**
* @brief Sets up the reduction
*
* Sets up the reduction according to the parameters. The indices of dimensions to be reduced
* are provided in `axes` parameter.
* For a successful batch reduction, the reduced shape of all samples must be equal (but the
* input may have non-uniform shape, as long as the non-uniform dimensions are reduced).
*
* @param ctx the execution environment
* @param in_shape shape of the input tensor list
* @param axes indices of axes to reduce along
* @param keep_dims if true, the reduced dimensions are kept in the output shape, with the
* extent of 1
* @param reduce_batch if true, reduces respective output values of all samples in the batch
* and outputs a single tensor
*/
KernelRequirements Setup(KernelContext &ctx,
const TensorListShape<> &in_shape,
span<const int> axes, bool keep_dims, bool reduce_batch);
/**
* @brief Performs the reduction, according to the parameters specified in Setup.
*/
void Run(KernelContext &ctx, const OutListGPU<Out> &out, const InListGPU<In> &in);
private:
class Impl;
std::unique_ptr<Impl> impl_;
};
extern template class RootMeanSquareGPU<uint8_t, uint8_t>;
extern template class RootMeanSquareGPU<float, uint8_t>;
extern template class RootMeanSquareGPU<int8_t, int8_t>;
extern template class RootMeanSquareGPU<float, int8_t>;
extern template class RootMeanSquareGPU<uint16_t, uint16_t>;
extern template class RootMeanSquareGPU<float, uint16_t>;
extern template class RootMeanSquareGPU<int16_t, int16_t>;
extern template class RootMeanSquareGPU<float, int16_t>;
extern template class RootMeanSquareGPU<uint32_t, uint32_t>;
extern template class RootMeanSquareGPU<float, uint32_t>;
extern template class RootMeanSquareGPU<int32_t, int32_t>;
extern template class RootMeanSquareGPU<float, int32_t>;
extern template class RootMeanSquareGPU<uint64_t, uint64_t>;
extern template class RootMeanSquareGPU<float, uint64_t>;
extern template class RootMeanSquareGPU<int64_t, int64_t>;
extern template class RootMeanSquareGPU<float, int64_t>;
extern template class RootMeanSquareGPU<float, float>;
/**
* @brief Calculates the standard deviation of input elements along given axes, given externally
* provided mean values.
*
* True standard deviation would be calculated as:
* ```
* sqrt(mean( (in - mean(in)) ^ 2 )
* ```
* Here, the `mean(in)` term is not calculated internally, but externally provided as a tensor.
*
* For more details on how directional reductions work, see SumGPU, MeanGPU, RootMeanSquareGPU
*/
template <typename Out, typename In, typename Mean = Out>
class DLL_PUBLIC StdDevGPU {
public:
StdDevGPU();
~StdDevGPU();
/**
* @brief Sets up the reduction
*
* Sets up the reduction according to the parameters. The indices of dimensions to be reduced
* are provided in `axes` parameter.
* For a successful batch reduction, the reduced shape of all samples must be equal (but the
* input may have non-uniform shape, as long as the non-uniform dimensions are reduced).
*
* @param ctx the execution environment
* @param in_shape shape of the input tensor list
* @param axes indices of axes to reduce along
* @param keep_dims if true, the reduced dimensions are kept in the output shape, with the
* extent of 1
* @param reduce_batch if true, reduces respective output values of all samples in the batch
* and outputs a single tensor
*/
KernelRequirements Setup(KernelContext &ctx,
const TensorListShape<> &in_shape,
span<const int> axes, bool keep_dims, bool reduce_batch);
/**
* @brief Performs the reduction, according to the parameters specified in Setup.
*
* @param ddof delta degrees of freedom for Bessel's correction
*/
void Run(KernelContext &ctx, const OutListGPU<Out> &out,
const InListGPU<In> &in, const InListGPU<Mean> &mean, int ddof = 0);
private:
class Impl;
std::unique_ptr<Impl> impl_;
};
extern template class StdDevGPU<uint8_t, uint8_t>;
extern template class StdDevGPU<float, uint8_t>;
extern template class StdDevGPU<int8_t, int8_t>;
extern template class StdDevGPU<float, int8_t>;
extern template class StdDevGPU<uint16_t, uint16_t>;
extern template class StdDevGPU<float, uint16_t>;
extern template class StdDevGPU<int16_t, int16_t>;
extern template class StdDevGPU<float, int16_t>;
extern template class StdDevGPU<uint32_t, uint32_t>;
extern template class StdDevGPU<float, uint32_t>;
extern template class StdDevGPU<int32_t, int32_t>;
extern template class StdDevGPU<float, int32_t>;
extern template class StdDevGPU<uint64_t, uint64_t>;
extern template class StdDevGPU<float, uint64_t>;
extern template class StdDevGPU<int64_t, int64_t>;
extern template class StdDevGPU<float, int64_t>;
extern template class StdDevGPU<float, float>;
/**
* @brief Calculates the variance of input elements along given axes, given externally
* provided mean values.
*
* Here, the `mean(in)` term is not calculated internally, but externally provided as a tensor.
*
* For more details on how directional reductions work, see SumGPU, MeanGPU, RootMeanSquareGPU
*/
template <typename Out, typename In, typename Mean = Out>
class DLL_PUBLIC VarianceGPU {
public:
VarianceGPU();
~VarianceGPU();
/**
* @brief Sets up the reduction
*
* Sets up the reduction according to the parameters. The indices of dimensions to be reduced
* are provided in `axes` parameter.
* For a successful batch reduction, the reduced shape of all samples must be equal (but the
* input may have non-uniform shape, as long as the non-uniform dimensions are reduced).
*
* @param ctx the execution environment
* @param in_shape shape of the input tensor list
* @param axes indices of axes to reduce along
* @param keep_dims if true, the reduced dimensions are kept in the output shape, with the
* extent of 1
* @param reduce_batch if true, reduces respective output values of all samples in the batch
* and outputs a single tensor
*/
KernelRequirements Setup(KernelContext &ctx,
const TensorListShape<> &in_shape,
span<const int> axes, bool keep_dims, bool reduce_batch);
/**
* @brief Performs the reduction, according to the parameters specified in Setup.
*
* @param ddof delta degrees of freedom for Bessel's correction
*/
void Run(KernelContext &ctx, const OutListGPU<Out> &out,
const InListGPU<In> &in, const InListGPU<Mean> &mean, int ddof = 0);
private:
class Impl;
std::unique_ptr<Impl> impl_;
};
extern template class VarianceGPU<uint8_t, uint8_t>;
extern template class VarianceGPU<float, uint8_t>;
extern template class VarianceGPU<int8_t, int8_t>;
extern template class VarianceGPU<float, int8_t>;
extern template class VarianceGPU<uint16_t, uint16_t>;
extern template class VarianceGPU<float, uint16_t>;
extern template class VarianceGPU<int16_t, int16_t>;
extern template class VarianceGPU<float, int16_t>;
extern template class VarianceGPU<uint32_t, uint32_t>;
extern template class VarianceGPU<float, uint32_t>;
extern template class VarianceGPU<int32_t, int32_t>;
extern template class VarianceGPU<float, int32_t>;
extern template class VarianceGPU<uint64_t, uint64_t>;
extern template class VarianceGPU<float, uint64_t>;
extern template class VarianceGPU<int64_t, int64_t>;
extern template class VarianceGPU<float, int64_t>;
extern template class VarianceGPU<float, float>;
/**
* @brief Calculates the inverse of standard deviation of input elements along given axes,
* given externally provided mean values.
*
* The output values are calculated as:
* ```
* s = sum( (in[pos] - mean[reduced_pos])^2 )
* out[reduced_pos] = s > 0 || reg > 0
* ? 1/sqrt(s / reduction_factor + reg)
* : 0
* ```
* where `reduction_factor` is the number of input elements contributing to a single output.
*
* For more details on how directional reductions work, see SumGPU, MeanGPU, RootMeanSquareGPU.
*
* @see StdDevGPU
*/
template <typename Out, typename In, typename Mean = Out>
class DLL_PUBLIC InvStdDevGPU {
public:
InvStdDevGPU();
~InvStdDevGPU();
/**
* @brief Sets up the reduction
*
* Sets up the reduction according to the parameters. The indices of dimensions to be reduced
* are provided in `axes` parameter.
* For a successful batch reduction, the reduced shape of all samples must be equal (but the
* input may have non-uniform shape, as long as the non-uniform dimensions are reduced).
*
* @param ctx the execution environment
* @param in_shape shape of the input tensor list
* @param axes indices of axes to reduce along
* @param keep_dims if true, the reduced dimensions are kept in the output shape, with the
* extent of 1
* @param reduce_batch if true, reduces respective output values of all samples in the batch
* and outputs a single tensor
*/
KernelRequirements Setup(KernelContext &ctx,
const TensorListShape<> &in_shape,
span<const int> axes, bool keep_dims, bool reduce_batch);
using param_t = std::conditional_t<std::is_same<Out, double>::value, double, float>;
/**
* @brief Calculates regularized inverse standard deviation
*
* The output values are calculated as:
* ```
* s = sum( (in[pos] - mean[reduced_pos])^2 )
* out[reduced_pos] = (s > 0 || reg > 0) && reduction_factor - ddof > 0
* ? 1/sqrt(s / (reduction_factor - ddof) + reg)
* : 0
* ```
* where `reduction_factor` is the number of input elements contributing to a single output.
*
* @param ctx the execution environment
* @param out (regularized) inverse standard deviation
* @param in input tensor
* @param mean mean, used for centering the data
* @param ddof delta degrees of freedom, for Bessel's correction
* @param reg regularizing term to avoid division by zero (or small numbers);
* it's added to the sum of squares in variance calculation, preventing
* it from being close to zero; if reg = 0, the results that would
* cause division by zero are forced to 0, but small denominators
* may still cause problems
*/
void Run(KernelContext &ctx, const OutListGPU<Out> &out,
const InListGPU<In> &in, const InListGPU<Mean> &mean, int ddof = 0, param_t epsilon = 0);
private:
class Impl;
std::unique_ptr<Impl> impl_;
};
extern template class InvStdDevGPU<float, uint8_t>;
extern template class InvStdDevGPU<float, int8_t>;
extern template class InvStdDevGPU<float, uint16_t>;
extern template class InvStdDevGPU<float, int16_t>;
extern template class InvStdDevGPU<float, uint32_t>;
extern template class InvStdDevGPU<float, int32_t>;
extern template class InvStdDevGPU<float, float>;
} // namespace kernels
} // namespace dali
#endif // DALI_KERNELS_REDUCE_REDUCE_GPU_H_
| [
"noreply@github.com"
] | noreply@github.com |
c12da0d7888346fd24922c1ccebb48e1ad332140 | 5456502f97627278cbd6e16d002d50f1de3da7bb | /ui/views/touchui/touch_selection_controller_impl_unittest.cc | c431a045d5f478fb622caf5f020b34689bdc73dd | [
"BSD-3-Clause"
] | permissive | TrellixVulnTeam/Chromium_7C66 | 72d108a413909eb3bd36c73a6c2f98de1573b6e5 | c8649ab2a0f5a747369ed50351209a42f59672ee | refs/heads/master | 2023-03-16T12:51:40.231959 | 2017-12-20T10:38:26 | 2017-12-20T10:38:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 36,071 | cc | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stddef.h>
#include "base/command_line.h"
#include "base/macros.h"
#include "base/strings/utf_string_conversions.h"
#include "ui/aura/client/screen_position_client.h"
#include "ui/aura/test/test_cursor_client.h"
#include "ui/aura/window.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/base/touch/touch_editing_controller.h"
#include "ui/base/ui_base_switches.h"
#include "ui/events/event_utils.h"
#include "ui/events/test/event_generator.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/render_text.h"
#include "ui/resources/grit/ui_resources.h"
#include "ui/views/controls/textfield/textfield.h"
#include "ui/views/controls/textfield/textfield_test_api.h"
#include "ui/views/resources/grit/views_resources.h"
#include "ui/views/test/views_test_base.h"
#include "ui/views/touchui/touch_selection_controller_impl.h"
#include "ui/views/views_touch_selection_controller_factory.h"
#include "ui/views/widget/widget.h"
#include "ui/views/widget/widget_delegate.h"
using base::ASCIIToUTF16;
using base::UTF16ToUTF8;
using base::WideToUTF16;
namespace {
// Should match kSelectionHandleBarMinHeight in touch_selection_controller.
const int kBarMinHeight = 5;
// Should match kSelectionHandleBarBottomAllowance in
// touch_selection_controller.
const int kBarBottomAllowance = 3;
// For selection bounds |b1| and |b2| in a paragraph of text, returns -1 if |b1|
// is physically before |b2|, +1 if |b2| is before |b1|, and 0 if they are at
// the same location.
int CompareTextSelectionBounds(const gfx::SelectionBound& b1,
const gfx::SelectionBound& b2) {
if (b1.edge_top().y() < b2.edge_top().y() ||
b1.edge_top().x() < b2.edge_top().x()) {
return -1;
}
if (b1 == b2)
return 0;
return 1;
}
} // namespace
namespace views {
class TouchSelectionControllerImplTest : public ViewsTestBase {
public:
TouchSelectionControllerImplTest()
: textfield_widget_(nullptr),
widget_(nullptr),
textfield_(nullptr),
views_tsc_factory_(new ViewsTouchEditingControllerFactory) {
ui::TouchEditingControllerFactory::SetInstance(views_tsc_factory_.get());
}
~TouchSelectionControllerImplTest() override {
ui::TouchEditingControllerFactory::SetInstance(nullptr);
}
void SetUp() override {
ViewsTestBase::SetUp();
// TODO: test uses GetContext(), which is not applicable to aura-mus.
// http://crbug.com/663809.
if (IsAuraMusClient())
return;
test_cursor_client_.reset(new aura::test::TestCursorClient(GetContext()));
}
void TearDown() override {
test_cursor_client_.reset();
if (textfield_widget_ && !textfield_widget_->IsClosed())
textfield_widget_->Close();
if (widget_ && !widget_->IsClosed())
widget_->Close();
ViewsTestBase::TearDown();
}
void CreateTextfield() {
textfield_ = new Textfield();
textfield_widget_ = new Widget;
Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
params.bounds = gfx::Rect(0, 0, 200, 200);
textfield_widget_->Init(params);
View* container = new View();
textfield_widget_->SetContentsView(container);
container->AddChildView(textfield_);
textfield_->SetBoundsRect(gfx::Rect(0, 0, 200, 21));
textfield_->set_id(1);
textfield_widget_->Show();
textfield_->RequestFocus();
textfield_test_api_.reset(new TextfieldTestApi(textfield_));
}
void CreateWidget() {
widget_ = new Widget;
Widget::InitParams params = CreateParams(Widget::InitParams::TYPE_POPUP);
params.bounds = gfx::Rect(0, 0, 200, 200);
widget_->Init(params);
widget_->Show();
}
protected:
static bool IsCursorHandleVisibleFor(
ui::TouchEditingControllerDeprecated* controller) {
TouchSelectionControllerImpl* impl =
static_cast<TouchSelectionControllerImpl*>(controller);
return impl->IsCursorHandleVisible();
}
gfx::Rect GetCursorRect(const gfx::SelectionModel& sel) {
return textfield_test_api_->GetRenderText()->GetCursorBounds(sel, true);
}
gfx::Point GetCursorPosition(const gfx::SelectionModel& sel) {
gfx::Rect cursor_bounds = GetCursorRect(sel);
return gfx::Point(cursor_bounds.x(), cursor_bounds.y());
}
TouchSelectionControllerImpl* GetSelectionController() {
return static_cast<TouchSelectionControllerImpl*>(
textfield_test_api_->touch_selection_controller());
}
void StartTouchEditing() {
textfield_test_api_->CreateTouchSelectionControllerAndNotifyIt();
}
void EndTouchEditing() {
textfield_test_api_->ResetTouchSelectionController();
}
void SimulateSelectionHandleDrag(gfx::Vector2d v, int selection_handle) {
TouchSelectionControllerImpl* controller = GetSelectionController();
views::WidgetDelegateView* handle = nullptr;
if (selection_handle == 1)
handle = controller->GetHandle1View();
else
handle = controller->GetHandle2View();
gfx::Point grip_location = gfx::Point(handle->size().width() / 2,
handle->size().height() / 2);
base::TimeTicks time_stamp = base::TimeTicks();
{
ui::GestureEventDetails details(ui::ET_GESTURE_SCROLL_BEGIN);
ui::GestureEvent scroll_begin(
grip_location.x(), grip_location.y(), 0, time_stamp, details);
handle->OnGestureEvent(&scroll_begin);
}
test_cursor_client_->DisableMouseEvents();
{
ui::GestureEventDetails details(ui::ET_GESTURE_SCROLL_UPDATE);
gfx::Point update_location = grip_location + v;
ui::GestureEvent scroll_update(
update_location.x(), update_location.y(), 0, time_stamp, details);
handle->OnGestureEvent(&scroll_update);
}
{
ui::GestureEventDetails details(ui::ET_GESTURE_SCROLL_END);
ui::GestureEvent scroll_end(
grip_location.x(), grip_location.y(), 0, time_stamp, details);
handle->OnGestureEvent(&scroll_end);
}
test_cursor_client_->EnableMouseEvents();
}
gfx::NativeView GetCursorHandleNativeView() {
return GetSelectionController()->GetCursorHandleNativeView();
}
gfx::SelectionBound::Type GetSelectionHandle1Type() {
return GetSelectionController()->GetSelectionHandle1Type();
}
gfx::Rect GetSelectionHandle1Bounds() {
return GetSelectionController()->GetSelectionHandle1Bounds();
}
gfx::Rect GetSelectionHandle2Bounds() {
return GetSelectionController()->GetSelectionHandle2Bounds();
}
gfx::Rect GetCursorHandleBounds() {
return GetSelectionController()->GetCursorHandleBounds();
}
gfx::Rect GetExpectedHandleBounds(const gfx::SelectionBound& bound) {
return GetSelectionController()->GetExpectedHandleBounds(bound);
}
bool IsSelectionHandle1Visible() {
return GetSelectionController()->IsSelectionHandle1Visible();
}
bool IsSelectionHandle2Visible() {
return GetSelectionController()->IsSelectionHandle2Visible();
}
bool IsCursorHandleVisible() {
return GetSelectionController()->IsCursorHandleVisible();
}
gfx::RenderText* GetRenderText() {
return textfield_test_api_->GetRenderText();
}
gfx::Point GetCursorHandleDragPoint() {
gfx::Rect rect = GetCursorHandleBounds();
const gfx::SelectionModel& sel = textfield_->GetSelectionModel();
int cursor_height = GetCursorRect(sel).height();
gfx::Point point = rect.CenterPoint();
point.Offset(0, cursor_height);
return point;
}
// If textfield has selection, this verifies that the selection handles
// are visible, at the correct positions (at the end points of selection), and
// (if |check_direction| is set to true), that they have the correct
// directionality.
// |cursor_at_selection_handle_1| is used to decide whether selection
// handle 1's position is matched against the start of selection or the end.
void VerifyHandlePositions(bool cursor_at_selection_handle_1,
bool check_direction,
const tracked_objects::Location& from_here) {
gfx::SelectionBound anchor, focus;
textfield_->GetSelectionEndPoints(&anchor, &focus);
std::string from_str = from_here.ToString();
if (textfield_->HasSelection()) {
EXPECT_TRUE(IsSelectionHandle1Visible()) << from_str;
EXPECT_TRUE(IsSelectionHandle2Visible()) << from_str;
EXPECT_FALSE(IsCursorHandleVisible());
gfx::Rect sh1_bounds = GetSelectionHandle1Bounds();
gfx::Rect sh2_bounds = GetSelectionHandle2Bounds();
if (cursor_at_selection_handle_1) {
EXPECT_EQ(sh1_bounds, GetExpectedHandleBounds(focus)) << from_str;
EXPECT_EQ(sh2_bounds, GetExpectedHandleBounds(anchor)) << from_str;
} else {
EXPECT_EQ(sh1_bounds, GetExpectedHandleBounds(anchor)) << from_str;
EXPECT_EQ(sh2_bounds, GetExpectedHandleBounds(focus)) << from_str;
}
} else {
EXPECT_FALSE(IsSelectionHandle1Visible()) << from_str;
EXPECT_FALSE(IsSelectionHandle2Visible()) << from_str;
EXPECT_TRUE(IsCursorHandleVisible());
gfx::Rect cursor_bounds = GetCursorHandleBounds();
DCHECK(anchor == focus);
EXPECT_EQ(cursor_bounds, GetExpectedHandleBounds(anchor)) << from_str;
}
if (check_direction) {
if (CompareTextSelectionBounds(anchor, focus) < 0) {
EXPECT_EQ(gfx::SelectionBound::LEFT, anchor.type()) << from_str;
EXPECT_EQ(gfx::SelectionBound::RIGHT, focus.type()) << from_str;
} else if (CompareTextSelectionBounds(anchor, focus) > 0) {
EXPECT_EQ(gfx::SelectionBound::LEFT, focus.type()) << from_str;
EXPECT_EQ(gfx::SelectionBound::RIGHT, anchor.type()) << from_str;
} else {
EXPECT_EQ(gfx::SelectionBound::CENTER, focus.type()) << from_str;
EXPECT_EQ(gfx::SelectionBound::CENTER, anchor.type()) << from_str;
}
}
}
// Sets up a textfield with a long text string such that it doesn't all fit
// into the textfield. Then selects the text - the first handle is expected
// to be invisible. |selection_start| is the position of the first handle.
void SetupSelectionInvisibleHandle(uint32_t selection_start) {
// Create a textfield with lots of text in it.
CreateTextfield();
std::string some_text("some text");
std::string textfield_text;
for (int i = 0; i < 10; ++i)
textfield_text += some_text;
textfield_->SetText(ASCIIToUTF16(textfield_text));
// Tap the textfield to invoke selection.
ui::GestureEventDetails details(ui::ET_GESTURE_TAP);
details.set_tap_count(1);
ui::GestureEvent tap(0, 0, 0, base::TimeTicks(), details);
textfield_->OnGestureEvent(&tap);
// Select some text such that one handle is hidden.
textfield_->SelectRange(gfx::Range(
selection_start, static_cast<uint32_t>(textfield_text.length())));
// Check that one selection handle is hidden.
EXPECT_FALSE(IsSelectionHandle1Visible());
EXPECT_TRUE(IsSelectionHandle2Visible());
EXPECT_EQ(gfx::Range(selection_start,
static_cast<uint32_t>(textfield_text.length())),
textfield_->GetSelectedRange());
}
Widget* textfield_widget_;
Widget* widget_;
Textfield* textfield_;
std::unique_ptr<TextfieldTestApi> textfield_test_api_;
std::unique_ptr<ViewsTouchEditingControllerFactory> views_tsc_factory_;
std::unique_ptr<aura::test::TestCursorClient> test_cursor_client_;
private:
DISALLOW_COPY_AND_ASSIGN(TouchSelectionControllerImplTest);
};
// Tests that the selection handles are placed appropriately when selection in
// a Textfield changes.
TEST_F(TouchSelectionControllerImplTest, SelectionInTextfieldTest) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
CreateTextfield();
textfield_->SetText(ASCIIToUTF16("some text"));
// Tap the textfield to invoke touch selection.
ui::GestureEventDetails details(ui::ET_GESTURE_TAP);
details.set_tap_count(1);
ui::GestureEvent tap(0, 0, 0, base::TimeTicks(), details);
textfield_->OnGestureEvent(&tap);
// Test selecting a range.
textfield_->SelectRange(gfx::Range(3, 7));
VerifyHandlePositions(false, true, FROM_HERE);
// Test selecting everything.
textfield_->SelectAll(false);
VerifyHandlePositions(false, true, FROM_HERE);
// Test with no selection.
textfield_->ClearSelection();
VerifyHandlePositions(false, true, FROM_HERE);
// Test with lost focus.
textfield_widget_->GetFocusManager()->ClearFocus();
EXPECT_FALSE(GetSelectionController());
// Test with focus re-gained.
textfield_widget_->GetFocusManager()->SetFocusedView(textfield_);
EXPECT_FALSE(GetSelectionController());
textfield_->OnGestureEvent(&tap);
VerifyHandlePositions(false, true, FROM_HERE);
}
// Tests that the selection handles are placed appropriately in bidi text.
TEST_F(TouchSelectionControllerImplTest, SelectionInBidiTextfieldTest) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
CreateTextfield();
textfield_->SetText(WideToUTF16(L"abc\x05d0\x05d1\x05d2"));
// Tap the textfield to invoke touch selection.
ui::GestureEventDetails details(ui::ET_GESTURE_TAP);
details.set_tap_count(1);
ui::GestureEvent tap(0, 0, 0, base::TimeTicks(), details);
textfield_->OnGestureEvent(&tap);
// Test cursor at run boundary and with empty selection.
textfield_->SelectSelectionModel(
gfx::SelectionModel(3, gfx::CURSOR_BACKWARD));
VerifyHandlePositions(false, true, FROM_HERE);
// Test selection range inside one run and starts or ends at run boundary.
textfield_->SelectRange(gfx::Range(2, 3));
VerifyHandlePositions(false, true, FROM_HERE);
textfield_->SelectRange(gfx::Range(3, 2));
VerifyHandlePositions(false, true, FROM_HERE);
// TODO(mfomitchev): crbug.com/429705
// The correct behavior for handles in mixed ltr/rtl text line is not known,
// so passing false for |check_direction| in some of these tests.
textfield_->SelectRange(gfx::Range(3, 4));
VerifyHandlePositions(false, false, FROM_HERE);
textfield_->SelectRange(gfx::Range(4, 3));
VerifyHandlePositions(false, false, FROM_HERE);
textfield_->SelectRange(gfx::Range(3, 6));
VerifyHandlePositions(false, false, FROM_HERE);
textfield_->SelectRange(gfx::Range(6, 3));
VerifyHandlePositions(false, false, FROM_HERE);
// Test selection range accross runs.
textfield_->SelectRange(gfx::Range(0, 6));
VerifyHandlePositions(false, true, FROM_HERE);
textfield_->SelectRange(gfx::Range(6, 0));
VerifyHandlePositions(false, true, FROM_HERE);
textfield_->SelectRange(gfx::Range(1, 4));
VerifyHandlePositions(false, true, FROM_HERE);
textfield_->SelectRange(gfx::Range(4, 1));
VerifyHandlePositions(false, true, FROM_HERE);
}
// Tests if the SelectRect callback is called appropriately when selection
// handles are moved.
TEST_F(TouchSelectionControllerImplTest, SelectRectCallbackTest) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
CreateTextfield();
textfield_->SetText(ASCIIToUTF16("textfield with selected text"));
// Tap the textfield to invoke touch selection.
ui::GestureEventDetails details(ui::ET_GESTURE_TAP);
details.set_tap_count(1);
ui::GestureEvent tap(0, 0, 0, base::TimeTicks(), details);
textfield_->OnGestureEvent(&tap);
textfield_->SelectRange(gfx::Range(3, 7));
gfx::Point textfield_origin;
textfield_->ConvertPointToScreen(&textfield_origin);
EXPECT_EQ("tfie", UTF16ToUTF8(textfield_->GetSelectedText()));
VerifyHandlePositions(false, true, FROM_HERE);
// Drag selection handle 2 to right by 3 chars.
const gfx::FontList& font_list = textfield_->GetFontList();
int x = gfx::Canvas::GetStringWidth(ASCIIToUTF16("ld "), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(x, 0), 2);
EXPECT_EQ("tfield ", UTF16ToUTF8(textfield_->GetSelectedText()));
VerifyHandlePositions(false, true, FROM_HERE);
// Drag selection handle 1 to the left by a large amount (selection should
// just stick to the beginning of the textfield).
SimulateSelectionHandleDrag(gfx::Vector2d(-50, 0), 1);
EXPECT_EQ("textfield ", UTF16ToUTF8(textfield_->GetSelectedText()));
VerifyHandlePositions(true, true, FROM_HERE);
// Drag selection handle 1 across selection handle 2.
x = gfx::Canvas::GetStringWidth(ASCIIToUTF16("textfield with "), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(x, 0), 1);
EXPECT_EQ("with ", UTF16ToUTF8(textfield_->GetSelectedText()));
VerifyHandlePositions(true, true, FROM_HERE);
// Drag selection handle 2 across selection handle 1.
x = gfx::Canvas::GetStringWidth(ASCIIToUTF16("with selected "), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(x, 0), 2);
EXPECT_EQ("selected ", UTF16ToUTF8(textfield_->GetSelectedText()));
VerifyHandlePositions(false, true, FROM_HERE);
}
TEST_F(TouchSelectionControllerImplTest, SelectRectInBidiCallbackTest) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
CreateTextfield();
textfield_->SetText(WideToUTF16(L"abc\x05e1\x05e2\x05e3" L"def"));
// Tap the textfield to invoke touch selection.
ui::GestureEventDetails details(ui::ET_GESTURE_TAP);
details.set_tap_count(1);
ui::GestureEvent tap(0, 0, 0, base::TimeTicks(), details);
textfield_->OnGestureEvent(&tap);
// Select [c] from left to right.
textfield_->SelectRange(gfx::Range(2, 3));
EXPECT_EQ(WideToUTF16(L"c"), textfield_->GetSelectedText());
VerifyHandlePositions(false, true, FROM_HERE);
// Drag selection handle 2 to right by 1 char.
const gfx::FontList& font_list = textfield_->GetFontList();
int x = gfx::Canvas::GetStringWidth(WideToUTF16(L"\x05e3"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(x, 0), 2);
EXPECT_EQ(WideToUTF16(L"c\x05e1\x05e2"), textfield_->GetSelectedText());
VerifyHandlePositions(false, true, FROM_HERE);
// Drag selection handle 1 to left by 1 char.
x = gfx::Canvas::GetStringWidth(WideToUTF16(L"b"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(-x, 0), 1);
EXPECT_EQ(WideToUTF16(L"bc\x05e1\x05e2"), textfield_->GetSelectedText());
VerifyHandlePositions(true, true, FROM_HERE);
// Select [c] from right to left.
textfield_->SelectRange(gfx::Range(3, 2));
EXPECT_EQ(WideToUTF16(L"c"), textfield_->GetSelectedText());
VerifyHandlePositions(false, true, FROM_HERE);
// Drag selection handle 1 to right by 1 char.
x = gfx::Canvas::GetStringWidth(WideToUTF16(L"\x05e3"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(x, 0), 1);
EXPECT_EQ(WideToUTF16(L"c\x05e1\x05e2"), textfield_->GetSelectedText());
VerifyHandlePositions(true, true, FROM_HERE);
// Drag selection handle 2 to left by 1 char.
x = gfx::Canvas::GetStringWidth(WideToUTF16(L"b"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(-x, 0), 2);
EXPECT_EQ(WideToUTF16(L"bc\x05e1\x05e2"), textfield_->GetSelectedText());
VerifyHandlePositions(false, true, FROM_HERE);
// Select [\x5e1] from right to left.
textfield_->SelectRange(gfx::Range(3, 4));
EXPECT_EQ(WideToUTF16(L"\x05e1"), textfield_->GetSelectedText());
// TODO(mfomitchev): crbug.com/429705
// The correct behavior for handles in mixed ltr/rtl text line is not known,
// so passing false for |check_direction| in some of these tests.
VerifyHandlePositions(false, false, FROM_HERE);
/* TODO(xji): for bidi text "abcDEF" whose display is "abcFEDhij", when click
right of 'D' and select [D] then move the left selection handle to left
by one character, it should select [ED], instead it selects [F].
Reason: click right of 'D' and left of 'h' return the same x-axis position,
pass this position to FindCursorPosition() returns index of 'h'. which
means the selection start changed from 3 to 6.
Need further investigation on whether this is a bug in Pango and how to
work around it.
// Drag selection handle 2 to left by 1 char.
x = gfx::Canvas::GetStringWidth(WideToUTF16(L"\x05e2"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(-x, 0), 2);
EXPECT_EQ(WideToUTF16(L"\x05e1\x05e2"), textfield_->GetSelectedText());
VERIFY_HANDLE_POSITIONS(false);
*/
// Drag selection handle 1 to right by 1 char.
x = gfx::Canvas::GetStringWidth(WideToUTF16(L"d"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(x, 0), 1);
EXPECT_EQ(WideToUTF16(L"\x05e2\x05e3" L"d"), textfield_->GetSelectedText());
VerifyHandlePositions(true, true, FROM_HERE);
// Select [\x5e1] from left to right.
textfield_->SelectRange(gfx::Range(4, 3));
EXPECT_EQ(WideToUTF16(L"\x05e1"), textfield_->GetSelectedText());
VerifyHandlePositions(false, false, FROM_HERE);
/* TODO(xji): see detail of above commented out test case.
// Drag selection handle 1 to left by 1 char.
x = gfx::Canvas::GetStringWidth(WideToUTF16(L"\x05e2"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(-x, 0), 1);
EXPECT_EQ(WideToUTF16(L"\x05e1\x05e2"), textfield_->GetSelectedText());
VERIFY_HANDLE_POSITIONS(true);
*/
// Drag selection handle 2 to right by 1 char.
x = gfx::Canvas::GetStringWidth(WideToUTF16(L"d"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(x, 0), 2);
EXPECT_EQ(WideToUTF16(L"\x05e2\x05e3" L"d"), textfield_->GetSelectedText());
VerifyHandlePositions(false, true, FROM_HERE);
// Select [\x05r3] from right to left.
textfield_->SelectRange(gfx::Range(5, 6));
EXPECT_EQ(WideToUTF16(L"\x05e3"), textfield_->GetSelectedText());
VerifyHandlePositions(false, false, FROM_HERE);
// Drag selection handle 2 to left by 1 char.
x = gfx::Canvas::GetStringWidth(WideToUTF16(L"c"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(-x, 0), 2);
EXPECT_EQ(WideToUTF16(L"c\x05e1\x05e2"), textfield_->GetSelectedText());
VerifyHandlePositions(false, true, FROM_HERE);
// Drag selection handle 1 to right by 1 char.
x = gfx::Canvas::GetStringWidth(WideToUTF16(L"\x05e2"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(x, 0), 1);
EXPECT_EQ(WideToUTF16(L"c\x05e1"), textfield_->GetSelectedText());
VerifyHandlePositions(true, true, FROM_HERE);
// Select [\x05r3] from left to right.
textfield_->SelectRange(gfx::Range(6, 5));
EXPECT_EQ(WideToUTF16(L"\x05e3"), textfield_->GetSelectedText());
VerifyHandlePositions(false, false, FROM_HERE);
// Drag selection handle 1 to left by 1 char.
x = gfx::Canvas::GetStringWidth(WideToUTF16(L"c"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(-x, 0), 1);
EXPECT_EQ(WideToUTF16(L"c\x05e1\x05e2"), textfield_->GetSelectedText());
VerifyHandlePositions(true, true, FROM_HERE);
// Drag selection handle 2 to right by 1 char.
x = gfx::Canvas::GetStringWidth(WideToUTF16(L"\x05e2"), font_list);
SimulateSelectionHandleDrag(gfx::Vector2d(x, 0), 2);
EXPECT_EQ(WideToUTF16(L"c\x05e1"), textfield_->GetSelectedText());
VerifyHandlePositions(false, false, FROM_HERE);
}
TEST_F(TouchSelectionControllerImplTest,
HiddenSelectionHandleRetainsCursorPosition) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
static const uint32_t selection_start = 10u;
SetupSelectionInvisibleHandle(selection_start);
// Drag the visible handle around and make sure the selection end point of the
// invisible handle does not change.
size_t visible_handle_position = textfield_->GetSelectedRange().end();
for (int i = 0; i < 10; ++i) {
static const int drag_diff = -10;
SimulateSelectionHandleDrag(gfx::Vector2d(drag_diff, 0), 2);
// Make sure that the visible handle is being dragged.
EXPECT_NE(visible_handle_position, textfield_->GetSelectedRange().end());
visible_handle_position = textfield_->GetSelectedRange().end();
EXPECT_EQ((size_t) 10, textfield_->GetSelectedRange().start());
}
}
// Tests that we can handle the hidden handle getting exposed as a result of a
// drag and that it maintains the correct orientation when exposed.
TEST_F(TouchSelectionControllerImplTest, HiddenSelectionHandleExposed) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
static const uint32_t selection_start = 0u;
SetupSelectionInvisibleHandle(selection_start);
// Drag the handle until the selection shrinks such that the other handle
// becomes visible.
while (!IsSelectionHandle1Visible()) {
static const int drag_diff = -10;
SimulateSelectionHandleDrag(gfx::Vector2d(drag_diff, 0), 2);
}
// Confirm that the exposed handle maintains the LEFT orientation
// (and does not reset to gfx::SelectionBound::Type::CENTER).
EXPECT_EQ(gfx::SelectionBound::Type::LEFT, GetSelectionHandle1Type());
}
TEST_F(TouchSelectionControllerImplTest,
DoubleTapInTextfieldWithCursorHandleShouldSelectText) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
CreateTextfield();
textfield_->SetText(ASCIIToUTF16("some text"));
ui::test::EventGenerator generator(
textfield_->GetWidget()->GetNativeView()->GetRootWindow());
// Tap the textfield to invoke touch selection.
generator.GestureTapAt(gfx::Point(10, 10));
// Cursor handle should be visible.
EXPECT_FALSE(textfield_->HasSelection());
VerifyHandlePositions(false, true, FROM_HERE);
// Double tap on the cursor handle position. We want to check that the cursor
// handle is not eating the event and that the event is falling through to the
// textfield.
gfx::Point cursor_pos = GetCursorHandleBounds().origin();
cursor_pos.Offset(GetCursorHandleBounds().width() / 2, 0);
generator.GestureTapAt(cursor_pos);
generator.GestureTapAt(cursor_pos);
EXPECT_TRUE(textfield_->HasSelection());
}
// A simple implementation of TouchEditable that allows faking cursor position
// inside its boundaries.
class TestTouchEditable : public ui::TouchEditable {
public:
explicit TestTouchEditable(aura::Window* window)
: window_(window) {
DCHECK(window);
}
void set_bounds(const gfx::Rect& bounds) {
bounds_ = bounds;
}
void set_cursor_rect(const gfx::RectF& cursor_rect) {
cursor_bound_.SetEdge(cursor_rect.origin(), cursor_rect.bottom_left());
cursor_bound_.set_type(gfx::SelectionBound::Type::CENTER);
}
~TestTouchEditable() override {}
private:
// Overridden from ui::TouchEditable.
void SelectRect(const gfx::Point& start, const gfx::Point& end) override {
NOTREACHED();
}
void MoveCaretTo(const gfx::Point& point) override { NOTREACHED(); }
void GetSelectionEndPoints(gfx::SelectionBound* anchor,
gfx::SelectionBound* focus) override {
*anchor = *focus = cursor_bound_;
}
gfx::Rect GetBounds() override { return gfx::Rect(bounds_.size()); }
gfx::NativeView GetNativeView() const override { return window_; }
void ConvertPointToScreen(gfx::Point* point) override {
aura::client::ScreenPositionClient* screen_position_client =
aura::client::GetScreenPositionClient(window_->GetRootWindow());
if (screen_position_client)
screen_position_client->ConvertPointToScreen(window_, point);
}
void ConvertPointFromScreen(gfx::Point* point) override {
aura::client::ScreenPositionClient* screen_position_client =
aura::client::GetScreenPositionClient(window_->GetRootWindow());
if (screen_position_client)
screen_position_client->ConvertPointFromScreen(window_, point);
}
bool DrawsHandles() override { return false; }
void OpenContextMenu(const gfx::Point& anchor) override { NOTREACHED(); }
void DestroyTouchSelection() override { NOTREACHED(); }
// Overridden from ui::SimpleMenuModel::Delegate.
bool IsCommandIdChecked(int command_id) const override {
NOTREACHED();
return false;
}
bool IsCommandIdEnabled(int command_id) const override {
NOTREACHED();
return false;
}
void ExecuteCommand(int command_id, int event_flags) override {
NOTREACHED();
}
aura::Window* window_;
// Boundaries of the client view.
gfx::Rect bounds_;
// Cursor position inside the client view.
//gfx::Rect cursor_rect_;
gfx::SelectionBound cursor_bound_;
DISALLOW_COPY_AND_ASSIGN(TestTouchEditable);
};
// Tests if the touch editing handle is shown or hidden properly according to
// the cursor position relative to the client boundaries.
TEST_F(TouchSelectionControllerImplTest,
VisibilityOfHandleRegardingClientBounds) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
CreateWidget();
TestTouchEditable touch_editable(widget_->GetNativeView());
std::unique_ptr<ui::TouchEditingControllerDeprecated>
touch_selection_controller(
ui::TouchEditingControllerDeprecated::Create(&touch_editable));
touch_editable.set_bounds(gfx::Rect(0, 0, 100, 20));
// Put the cursor completely inside the client bounds. Handle should be
// visible.
touch_editable.set_cursor_rect(gfx::RectF(2.f, 0.f, 1.f, 20.f));
touch_selection_controller->SelectionChanged();
EXPECT_TRUE(IsCursorHandleVisibleFor(touch_selection_controller.get()));
// Move the cursor up such that |kBarMinHeight| pixels are still in the client
// bounds. Handle should still be visible.
touch_editable.set_cursor_rect(
gfx::RectF(2.f, kBarMinHeight - 20.f, 1.f, 20.f));
touch_selection_controller->SelectionChanged();
EXPECT_TRUE(IsCursorHandleVisibleFor(touch_selection_controller.get()));
// Move the cursor up such that less than |kBarMinHeight| pixels are in the
// client bounds. Handle should be hidden.
touch_editable.set_cursor_rect(
gfx::RectF(2.f, kBarMinHeight - 20.f - 1.f, 1.f, 20.f));
touch_selection_controller->SelectionChanged();
EXPECT_FALSE(IsCursorHandleVisibleFor(touch_selection_controller.get()));
// Move the Cursor down such that |kBarBottomAllowance| pixels are out of the
// client bounds. Handle should be visible.
touch_editable.set_cursor_rect(
gfx::RectF(2.f, kBarBottomAllowance, 1.f, 20.f));
touch_selection_controller->SelectionChanged();
EXPECT_TRUE(IsCursorHandleVisibleFor(touch_selection_controller.get()));
// Move the cursor down such that more than |kBarBottomAllowance| pixels are
// out of the client bounds. Handle should be hidden.
touch_editable.set_cursor_rect(
gfx::RectF(2.f, kBarBottomAllowance + 1.f, 1.f, 20.f));
touch_selection_controller->SelectionChanged();
EXPECT_FALSE(IsCursorHandleVisibleFor(touch_selection_controller.get()));
touch_selection_controller.reset();
}
TEST_F(TouchSelectionControllerImplTest, HandlesStackAboveParent) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
ui::EventTarget* root = GetContext();
ui::EventTargeter* targeter = root->GetEventTargeter();
// Create the first window containing a Views::Textfield.
CreateTextfield();
aura::Window* window1 = textfield_widget_->GetNativeView();
// Start touch editing, check that the handle is above the first window, and
// end touch editing.
StartTouchEditing();
gfx::Point test_point = GetCursorHandleDragPoint();
ui::MouseEvent test_event1(ui::ET_MOUSE_MOVED, test_point, test_point,
ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
EXPECT_EQ(GetCursorHandleNativeView(),
targeter->FindTargetForEvent(root, &test_event1));
EndTouchEditing();
// Create the second (empty) window over the first one.
CreateWidget();
aura::Window* window2 = widget_->GetNativeView();
// Start touch editing (in the first window) and check that the handle is not
// above the second window.
StartTouchEditing();
ui::MouseEvent test_event2(ui::ET_MOUSE_MOVED, test_point, test_point,
ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
EXPECT_EQ(window2, targeter->FindTargetForEvent(root, &test_event2));
// Move the first window to top and check that the handle is kept above the
// first window.
window1->GetRootWindow()->StackChildAtTop(window1);
ui::MouseEvent test_event3(ui::ET_MOUSE_MOVED, test_point, test_point,
ui::EventTimeForNow(), ui::EF_NONE, ui::EF_NONE);
EXPECT_EQ(GetCursorHandleNativeView(),
targeter->FindTargetForEvent(root, &test_event3));
}
TEST_F(TouchSelectionControllerImplTest, MouseEventDeactivatesTouchSelection) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
CreateTextfield();
EXPECT_FALSE(GetSelectionController());
ui::test::EventGenerator generator(
textfield_widget_->GetNativeView()->GetRootWindow());
generator.set_current_location(gfx::Point(5, 5));
RunPendingMessages();
// Start touch editing; then move mouse over the textfield and ensure it
// deactivates touch selection.
StartTouchEditing();
EXPECT_TRUE(GetSelectionController());
generator.MoveMouseTo(gfx::Point(5, 10));
RunPendingMessages();
EXPECT_FALSE(GetSelectionController());
generator.MoveMouseTo(gfx::Point(5, 50));
RunPendingMessages();
// Start touch editing; then move mouse out of the textfield, but inside the
// winow and ensure it deactivates touch selection.
StartTouchEditing();
EXPECT_TRUE(GetSelectionController());
generator.MoveMouseTo(gfx::Point(5, 55));
RunPendingMessages();
EXPECT_FALSE(GetSelectionController());
generator.MoveMouseTo(gfx::Point(5, 500));
RunPendingMessages();
// Start touch editing; then move mouse out of the textfield and window and
// ensure it deactivates touch selection.
StartTouchEditing();
EXPECT_TRUE(GetSelectionController());
generator.MoveMouseTo(5, 505);
RunPendingMessages();
EXPECT_FALSE(GetSelectionController());
}
TEST_F(TouchSelectionControllerImplTest, MouseCaptureChangedEventIgnored) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
CreateTextfield();
EXPECT_FALSE(GetSelectionController());
ui::test::EventGenerator generator(
textfield_widget_->GetNativeView()->GetRootWindow());
RunPendingMessages();
// Start touch editing; then generate a mouse-capture-changed event and ensure
// it does not deactivate touch selection.
StartTouchEditing();
EXPECT_TRUE(GetSelectionController());
ui::MouseEvent capture_changed(ui::ET_MOUSE_CAPTURE_CHANGED, gfx::Point(5, 5),
gfx::Point(5, 5), base::TimeTicks(), 0, 0);
generator.Dispatch(&capture_changed);
RunPendingMessages();
EXPECT_TRUE(GetSelectionController());
}
TEST_F(TouchSelectionControllerImplTest, KeyEventDeactivatesTouchSelection) {
// TODO: see comment in SetUp().
if (IsAuraMusClient())
return;
CreateTextfield();
EXPECT_FALSE(GetSelectionController());
ui::test::EventGenerator generator(
textfield_widget_->GetNativeView()->GetRootWindow());
RunPendingMessages();
// Start touch editing; then press a key and ensure it deactivates touch
// selection.
StartTouchEditing();
EXPECT_TRUE(GetSelectionController());
generator.PressKey(ui::VKEY_A, 0);
RunPendingMessages();
EXPECT_FALSE(GetSelectionController());
}
} // namespace views
| [
"lixiaodonglove7@aliyun.com"
] | lixiaodonglove7@aliyun.com |
bc35b954a85740966d7cd1da5dccf50b46149b79 | 4edf91c17c2357eb3d685a897362ef4f2abeb560 | /Project_ex5/Dynamic.h | 5875beebe1c087759a6304bbc4f8784da63c1dc0 | [] | no_license | HofRonis/PacmanSFML | 69013003101b1993e81b3f1d1a46fd608e34c355 | 792ed23027dc7260eccedc8655e2032f72e7a9e9 | refs/heads/master | 2020-07-22T21:07:13.746302 | 2019-09-09T14:32:49 | 2019-09-09T14:32:49 | 207,327,761 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 300 | h | #pragma once
#include "Object.h"
class Dynamic :public Object
{
public:
Dynamic(sf::Color color, sf::Vector2f position, char c);
Dynamic();
sf::Vector2f get_first_position() const;
virtual void move(int direction)= 0;
~Dynamic();
protected:
sf::Vector2f m_first_position;
};
| [
"noreply@github.com"
] | noreply@github.com |
0168e42890dac89e70cf1185f40260652fdd0035 | 343966f68798615621ed7f6a17ebe782b7738dea | /src/net/third_party/quiche/src/quic/quic_transport/quic_transport_stream.h | dfe943f67d35481ce8977ac62d37751be8087fb5 | [
"BSD-3-Clause"
] | permissive | iuing/chromium.bb | 57745cdda62a8b0097b7139f86422e74c331c937 | e2c7771d2f79008f4c3b06b6cc024f3f1936156f | refs/heads/master | 2023-04-09T10:12:54.306426 | 2021-04-22T14:26:20 | 2021-04-22T14:26:20 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,710 | h | // Copyright (c) 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef QUICHE_QUIC_QUIC_TRANSPORT_QUIC_TRANSPORT_STREAM_H_
#define QUICHE_QUIC_QUIC_TRANSPORT_QUIC_TRANSPORT_STREAM_H_
#include <cstddef>
#include <memory>
#include "absl/base/attributes.h"
#include "absl/strings/string_view.h"
#include "net/third_party/quiche/src/quic/core/quic_session.h"
#include "net/third_party/quiche/src/quic/core/quic_stream.h"
#include "net/third_party/quiche/src/quic/core/quic_types.h"
#include "net/third_party/quiche/src/quic/quic_transport/quic_transport_session_interface.h"
namespace quic {
// QuicTransportStream is an extension of QuicStream that provides I/O interface
// that is safe to use in the QuicTransport context. The interface ensures no
// application data is processed before the client indication is processed.
class QUIC_EXPORT_PRIVATE QuicTransportStream : public QuicStream {
public:
class QUIC_EXPORT_PRIVATE Visitor {
public:
virtual ~Visitor() {}
virtual void OnCanRead() = 0;
virtual void OnFinRead() = 0;
virtual void OnCanWrite() = 0;
};
QuicTransportStream(QuicStreamId id,
QuicSession* session,
QuicTransportSessionInterface* session_interface);
// Reads at most |buffer_size| bytes into |buffer| and returns the number of
// bytes actually read.
size_t Read(char* buffer, size_t buffer_size);
// Reads all available data and appends it to the end of |output|.
size_t Read(std::string* output);
// Writes |data| into the stream. Returns true on success.
ABSL_MUST_USE_RESULT bool Write(absl::string_view data);
// Sends the FIN on the stream. Returns true on success.
ABSL_MUST_USE_RESULT bool SendFin();
// Indicates whether it is possible to write into stream right now.
bool CanWrite() const;
// Indicates the number of bytes that can be read from the stream.
size_t ReadableBytes() const;
// QuicSession method implementations.
void OnDataAvailable() override;
void OnCanWriteNewData() override;
Visitor* visitor() { return visitor_.get(); }
void set_visitor(std::unique_ptr<Visitor> visitor) {
visitor_ = std::move(visitor);
}
protected:
// Hide the methods that allow writing data without checking IsSessionReady().
using QuicStream::WriteMemSlices;
using QuicStream::WriteOrBufferData;
void MaybeNotifyFinRead();
QuicTransportSessionInterface* session_interface_;
std::unique_ptr<Visitor> visitor_ = nullptr;
bool fin_read_notified_ = false;
};
} // namespace quic
#endif // QUICHE_QUIC_QUIC_TRANSPORT_QUIC_TRANSPORT_STREAM_H_
| [
"copybara-worker@google.com"
] | copybara-worker@google.com |
e212cbe784da0f57e9f19681be4fab4e7121d6e4 | c9aca737b684272251db9a00c4df33c63cf90d1f | /osvr/Display/DisplayIO.h | 1451ce4a9654c511a2c795fb7553f3ad93253a3d | [
"BSD-3-Clause",
"Apache-2.0"
] | permissive | OSVR/OSVR-Display | 23fca4e2c3525fcd5aee18d8c942d11b68097ebf | 30910110b9f5365f3e8330f81d889b926967a734 | refs/heads/master | 2021-01-20T18:27:27.304467 | 2017-07-23T00:32:35 | 2017-07-23T00:32:35 | 65,091,174 | 8 | 8 | null | 2017-10-22T15:06:04 | 2016-08-06T16:20:16 | C++ | UTF-8 | C++ | false | false | 1,561 | h | /** @file
@brief I/O functions for printing enum values
@date 2016
@author
Sensics, Inc.
<http://sensics.com>
*/
// Copyright 2016 Sensics, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef INCLUDED_DisplayIO_h_GUID_3C0105D1_4C9C_47F8_82B9_88A7C6170EAD
#define INCLUDED_DisplayIO_h_GUID_3C0105D1_4C9C_47F8_82B9_88A7C6170EAD
// Internal Includes
// - none
// Library/third-party includes
// - none
// Standard includes
#include <iostream>
namespace osvr {
namespace display {
inline std::ostream& operator<<(std::ostream& ostr, const Rotation rotation)
{
ostr << to_string(rotation);
return ostr;
}
inline std::ostream& operator<<(std::ostream& ostr, const DesktopOrientation orientation)
{
ostr << to_string(orientation);
return ostr;
}
inline std::ostream& operator<<(std::ostream& ostr, const ScanOutOrigin origin)
{
ostr << to_string(origin);
return ostr;
}
} // end namespace display
} // end namespace osvr
#endif // INCLUDED_DisplayIO_h_GUID_3C0105D1_4C9C_47F8_82B9_88A7C6170EAD
| [
"kevin@godby.org"
] | kevin@godby.org |
ddecf6a818a7e70b98914f1256758b129a78ca4f | dc3e696025bca400aaabc0b3fce4aa334b067c84 | /1132B.cpp | 80c60702b4020b3db797f1a9b323787871bfb687 | [] | no_license | NguyenTheAn/Algorithm | 740170afb6d4e2db362f5e406fc48f014ce693a4 | 1fe154ae46658079b422e3a5198e239908939b6b | refs/heads/master | 2020-10-01T09:40:06.473488 | 2019-12-12T03:27:16 | 2019-12-12T03:27:16 | 227,510,768 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 422 | cpp | #include <bits/stdc++.h>
using namespace std;
int a[300001];
int q[300001];
int main(){
int n;
cin>>n;
for ( int i=0; i < n; i++ ) cin>>a[i];
int m;
cin>>m;
for (int i=0; i<m; i++) cin>>q[i];
sort(a, a+n);
long long sum = 0;
for (int i=0; i<n; i++){
sum+=a[i];
}
for (int i=0; i<m; i++){
cout<<sum - a[n-q[i]]<<endl;
}
return 0;
}
//https://codeforces.com/contest/1132/problem/B
| [
"nguyenthean.ligirk@gmail.com"
] | nguyenthean.ligirk@gmail.com |
e50122a992988507c5324a58d2ff116e517186aa | 9bf63f30a8c19317c5f772ca2b5b2853ff172c51 | /Practice Challenges/ReadingFiles/main.cpp | 640bad635ede6388f2377429d1cd2dfa6622e10e | [] | no_license | Programmer-Jet/Programming-Methodology | 7ba1202a86f4232e6e8e275536b6db97b368c87c | 2534b0b65b7a18635b59a065df2c94a20af39143 | refs/heads/master | 2020-03-27T14:49:54.642477 | 2018-08-30T02:21:18 | 2018-08-30T02:21:18 | 146,681,581 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 729 | cpp | #include <iostream>
#include <fstream>
#include <cstdlib>
#include <string>
using namespace std;
int main()
{
// ifstream is used for reading files
// We'll read from a file called Sample.dat
ifstream inf("Sample.dat");
// If we couldn't open the output file stream for reading
if (!inf)
{
// Print an error and exit
cerr << "Uh oh, Sample.dat could not be opened for reading!" << endl;
exit(1);
}
// While there's still stuff left to read
while (inf)
{
// read stuff from the file into a string and print it
string strInput;
getline(inf, strInput);
cout << strInput << endl;
}
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
59d4525a4caf9c06179d9c97286cad267ced74b0 | ad175197040b044b497b07a7d4838109caf05f12 | /Builds/AndroidStudio/app/src/main/jni/Source/View/CustomLook.cpp | 10c990f1304e433f5500ea5cc13862706f62bd9e | [] | no_license | eriser/SilverbirdApp | 0b91ba50b2b2b0d24128acd25fb2666926b4cf9a | de8fe14f5368a1f01c72e6bf222bce8bf7762a51 | refs/heads/master | 2020-07-17T04:58:03.715686 | 2016-06-01T14:09:29 | 2016-06-01T14:09:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 67 | cpp | /Users/logsol/Work/projects/c++/SilverbirdApp/Source/CustomLook.cpp | [
"logspum@gmail.com"
] | logspum@gmail.com |
20092d43b27fff4fce5c351272b9e69174fcf9f1 | ebaaaffb2a7ff5991441e9ce2110f40c36185798 | /C++/observer/simple/Observer.cpp | 32e758e4797fbff2f18fe1c49655b45558156ffa | [] | no_license | iMageChans/DesignModel | 6fa0e9322992f0003951e564c1e84449b4b76d33 | c4c59770b356db606e38f2c1bba278d8627cbac5 | refs/heads/master | 2020-12-28T01:39:44.541684 | 2020-02-18T00:02:57 | 2020-02-18T00:02:57 | 238,139,157 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 62 | cpp | //
// Created by Chans on 2020/2/5.
//
#include "Observer.h"
| [
"imagechans@gmail.com"
] | imagechans@gmail.com |
6b06faf28d34a9e0cae757e6f452c4045f274718 | 935f99f888a0c1bd5970a9abe74d788653f4dfcc | /Sample programs/Linkedlist_ReversePrint/Linkedlist_ReversePrint.cpp | 5d6c9924438ddc217fc63ca02cf6b0fdd6692d48 | [] | no_license | jeevanvenkataramana/Programming | 5e182b3d5d244ed147f86bdc32a48e8366e3e6c2 | c11ed6c26ffcb723a62359b6a0691d6328aa11b9 | refs/heads/master | 2020-03-18T21:02:38.134787 | 2019-03-11T02:24:16 | 2019-03-11T02:24:16 | 135,255,228 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,643 | cpp | /*
* Linkedlist_Reverse.cpp
*
* Created on: Sep 28, 2018
* Author: jeevan venkataramana
*/
#include<iostream>
using namespace std;
struct Node
{
int data;
struct Node *next;
};
Node* Insert(Node *head,int data);
void ReversePrint(Node *head);
void Print(Node *head);
int main()
{
Node* head = new Node;
head = nullptr;
int a[5]={1,2,3,4,5};
for(int i=0; i<5; i++)
{
head=Insert(head, a[i]);
}
Print(head);
cout<<endl<<endl<<"The linked list in reverse order: ";
ReversePrint(head);
return 0;
}
void ReversePrint(Node *head)
{
int count =0;
Node* temp = new Node;
temp = head;
while(temp!=nullptr)
{
temp=temp->next;
count++;
}
while(count>0)
{
temp=head;
int i= 1;
while(i<count)
{
temp=temp->next;
i++;
}
cout<<temp->data<<" <- ";
count--;
}
cout<<"head";
}
Node* Insert(Node *head,int data)
{
// Complete this method
Node* new_node = new Node;
new_node->data=data;
new_node->next = nullptr;
if(head == nullptr)
{
head = new_node;
return new_node;
}
else
{
Node* pos = new Node;
pos = head;
while(pos->next!=nullptr)
{
pos=pos->next;
}
pos->next=new_node;
return head;
}
}
void Print(Node *head)
{
Node* temp = new Node;
temp = head;
cout<<endl<<"The Elements in the linked list: ";
while(temp!=nullptr)
{
cout<<temp->data<<" -> ";
temp=temp->next;
}
cout<<"end";
delete [] temp;
return;
}
| [
"jeevan.venkataramana@gmail.com"
] | jeevan.venkataramana@gmail.com |
bcb49cdf42c05b3ca45eed3b4398be616f3ff0b2 | fbe08142475f1f4923ae8bfa6e2727e093e07510 | /Kurs_3/Programming_Methods/Lab_3/Cpp-files/generator.cpp | 20f687519314e949e7bfbf1dfa717216193b123c | [] | no_license | DrPopov/HSE | fbb423b7a353084a52c93583a9bb0aa0dfd62805 | 6f431ea0248851c932abad97ca0ad8e60af41804 | refs/heads/master | 2023-02-06T20:38:12.018444 | 2020-12-22T20:35:08 | 2020-12-22T20:35:08 | 263,942,379 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,760 | cpp | //
// Created by ypopov on 15.05.2020.
//
#include "../Headers/fio.h"
#include "../Headers/flightTime.h"
#include "../Headers/passenger.h"
#include "../Headers/generator.h"
#include "../Headers/hash.h"
#include <string>
#include <iostream>
#include <cstdlib>
#include <vector>
int Generator::random_flight_number() {
//return Generator::flight_number = rand();
return 1 + (rand() % static_cast<int>(10000 - 1 + 1));
}
int Generator::random_seat_number(){
//return Generator::seat_number = rand()%100;
return 1 + (rand() % static_cast<int>(100 - 1 + 1));
}
Fio Generator::random_fio(){
string temp1;
string temp2;
string temp3;
for(int j = 0; j <= rand() % 9; j++ ){
temp1.push_back(char('a' + rand() % ('z' - 'a')));
}
for(int j = 0; j <= rand() % 9; j++ ){
temp2.push_back(char('a' + rand() % ('z' - 'a')));
}
for(int j = 0; j <= rand() % 9; j++ ){
temp3.push_back(char('a' + rand() % ('z' - 'a')));
}
//Generator::fio = Fio(temp1, temp2, temp3);
return Fio(temp1, temp2, temp3);
}
FlightTime Generator::random_flight_data(){
int temp1= 1 + rand()%30;
int temp2= 1 + rand()%12;
int temp3 = rand()%2030;
//Generator::flight_data = FlightTime(temp1, temp2, temp3);
return FlightTime(temp1, temp2, temp3);
}
Passenger Generator::generate_passenger(bool bad_hash_bool){
Generator generator;
Passenger passenger;
passenger.set_fio(generator.random_fio());
passenger.set_flight_data(generator.random_flight_data());
passenger.set_flight_number(generator.random_flight_number());
passenger.set_seat_number(generator.random_seat_number());
//Passenger passenger = Passenger(Fio(generator.random_fio()), FlightTime(generator.random_flight_data()), generator.random_flight_number(), generator.random_seat_number(), bad_hash_bool);
passenger.set_hash(get_hash(passenger.get_fio(), bad_hash_bool));
/*
if(bad_hash_bool){
passenger.set_bad_hash(passenger.get_fio());
} else{
passenger.set_good_hash(passenger.get_fio());
}
*/
return passenger;
}
vector<Passenger> Generator::generate_passengers(int n, bool bad_hash_bool){
vector<Passenger> people;
for(int i = 0; i < n; i++){
people.push_back(generate_passenger(bad_hash_bool));
}
return people;
}
ostream &operator << (ostream &out, const vector<Passenger> &passengers) {
for(Passenger passenger:passengers){
out << "Flight_data is: " << passenger.get_flight_data() << ". Flight_number is: " << passenger.get_flight_number() << ". FIO of passenger is: " << passenger.get_fio() << ". Seat_number is: " << passenger.get_seat_number() << endl;
}
return out;
}
| [
"yulpopov67@gmail.com"
] | yulpopov67@gmail.com |
87d2e59b4150b55ac040ffe172f330ae02a481ae | 17bf8eca8ece516e65118a91d60134092a8f68e4 | /C++/1043. Partition Array for Maximum Sum/sol.cpp | c3231fbb5f868f1ed36a174e46502f5c6ab0d9d6 | [] | no_license | HaelC/LeetCode | a433bb49e62a3b331982cb6fa337a72726c45a11 | 549c0217e771726611287f7bcd43c704190a60f1 | refs/heads/master | 2022-12-29T16:53:56.159942 | 2020-10-11T05:50:25 | 2020-10-11T05:50:25 | 177,907,987 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 466 | cpp | class Solution {
public:
int maxSumAfterPartitioning(vector<int>& A, int K) {
int n = A.size();
vector<int> dp(n, 0);
for (int i = 0; i < n; i++) {
int maxInRange = 0;
for (int k = 1; k <= K && i - k + 1 >= 0; k++) {
maxInRange = max(maxInRange, A[i - k + 1]);
dp[i] = max(dp[i], (i >= k ? dp[i - k] : 0) + maxInRange * k);
}
}
return dp[n - 1];
}
}; | [
"f.procumbens@gmail.com"
] | f.procumbens@gmail.com |
e7c20dab4dab39cdae634805e57ff05cc9431e4c | 34aac694ccb9f953456a5cd2328ab1ea15abb799 | /UVa_ACM/100 - Volume C/UVa 10055(1.0, Ad-hoc, Comparison-operation).cpp | 171e05ec70e66f3185b1721a54c1f69f2e61a7f1 | [] | no_license | ottersome/Judge-1 | 98eca71c2f847032dc976cb1ffe63887bbc15339 | 1996a49293bde9bc15162501a23d7b51a3830185 | refs/heads/master | 2020-04-30T07:08:26.341120 | 2017-08-28T12:32:47 | 2017-08-28T12:32:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 186 | cpp | #include <stdio.h>
#include <iostream>
using namespace std;
int main()
{
long long a, b;
while (scanf("%lld%lld", &a, &b) != EOF)
printf("%lld\n", (a > b)? a - b: b - a);
} | [
"m80126colin@gmail.com"
] | m80126colin@gmail.com |
b25adb63fa2e775fb750563c88110426febd0c38 | 6c59732b0e9393ee6202f11cb13c9bbf6abbd03b | /BletcheryCodeBreakers/BletcheryCodeBreakers/dataLayer.h | 408423e6bb2899b2a7474eb39af75a76f2149c45 | [] | no_license | ISParashkevov18/Sossila.v2.ScaleFocus | 01a53ea9e8fecf63db9a305425bb80953a5f2f47 | 0d5a6751199d370c2b631b1d087b3a429b01c86d | refs/heads/main | 2023-02-10T01:17:59.362995 | 2021-01-12T08:00:13 | 2021-01-12T08:00:13 | 328,759,022 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 803 | h | #include <iostream>
using namespace std;
#pragma once
// --------------------------------------------------------------------DATA LAYER----------------------------------------------------------
void createVector(vector<int> arrayOfGuesses[], int userNumbers[], int numberOfGuesses, int vectorSize);
void generateNumNoDuplicates(int numbers[]);
void generateNumWithDuplicates(int numbers[]);
bool checkInteger(string str);
bool areEqual(int numbers[], int finalNumbers[]);
void compareNumbers(int numbers[], int userNumbers[], int numberOfGuesses, int& wins, int& loses);
void setNumWithDuplicates(int numbers[]);
void setNumNoDuplicates(int numbers[]);
// --------------------------------------------------------------------PRESENTATION LAYER---------------------------------------------------------- | [
"58163160+ViktorVelizarov@users.noreply.github.com"
] | 58163160+ViktorVelizarov@users.noreply.github.com |
497e2cd795d0644efeaac3786eb83815b8c6de3d | f75c80990d0c681d989e9aec4b45d38270721c50 | /ride/textctrllist.h | 7a048328ea31ffe550e833b79599652572257bb7 | [
"MIT"
] | permissive | arno-lee/ride | 095ec24d6fde49ceadcc1092311e5a80b431aa41 | 889ab448f44fc1a94268e35fbb3b8146ba593da1 | refs/heads/master | 2021-01-17T14:08:04.292126 | 2015-07-14T05:15:06 | 2015-07-14T05:15:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 756 | h | #ifndef RIDE_TEXTCTRLLIST_H
#define RIDE_TEXTCTRLLIST_H
#include "ride/wx.h"
class wxListCtrl;
class wxListEvent;
class TextCtrlCallback {
public:
virtual void OnTextUpdated() = 0;
virtual void OnTextEnter() = 0;
};
class TextCtrlList : public wxTextCtrl {
public:
TextCtrlList(wxWindow* parent, wxListCtrl* list);
~TextCtrlList();
void set_callback(TextCtrlCallback* callback);
protected:
void OnKeyUp(wxKeyEvent& event);
void OnUpdated(wxCommandEvent& event);
void OnEnter(wxCommandEvent& event);
void OnFileDeselected(wxListEvent& event);
void OnFileSelected(wxListEvent& event);
wxDECLARE_EVENT_TABLE();
private:
wxListCtrl* list_;
TextCtrlCallback* callback_;
int last_selected_;
};
#endif // RIDE_TEXTCTRLLIST_H
| [
"sir.gustav.the.coder@gmail.com"
] | sir.gustav.the.coder@gmail.com |
87c05f7a969b216c3d8aa0a085abaa38db36624f | b71b8bd385c207dffda39d96c7bee5f2ccce946c | /testcases/CWE122_Heap_Based_Buffer_Overflow/s04/CWE122_Heap_Based_Buffer_Overflow__cpp_CWE806_wchar_t_memmove_08.cpp | 2a6c450384f5446667d5ce32b7182f9dd292023f | [] | no_license | Sporknugget/Juliet_prep | e9bda84a30bdc7938bafe338b4ab2e361449eda5 | 97d8922244d3d79b62496ede4636199837e8b971 | refs/heads/master | 2023-05-05T14:41:30.243718 | 2021-05-25T16:18:13 | 2021-05-25T16:18:13 | 369,334,230 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,975 | cpp | /* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE122_Heap_Based_Buffer_Overflow__cpp_CWE806_wchar_t_memmove_08.cpp
Label Definition File: CWE122_Heap_Based_Buffer_Overflow__cpp_CWE806.label.xml
Template File: sources-sink-08.tmpl.cpp
*/
/*
* @description
* CWE: 122 Heap Based Buffer Overflow
* BadSource: Initialize data as a large string
* GoodSource: Initialize data as a small string
* Sink: memmove
* BadSink : Copy data to string using memmove
* Flow Variant: 08 Control flow: if(staticReturnsTrue()) and if(staticReturnsFalse())
*
* */
#include "std_testcase.h"
#include <wchar.h>
/* The two function below always return the same value, so a tool
should be able to identify that calls to the functions will always
return a fixed value. */
static int staticReturnsTrue()
{
return 1;
}
static int staticReturnsFalse()
{
return 0;
}
namespace CWE122_Heap_Based_Buffer_Overflow__cpp_CWE806_wchar_t_memmove_08
{
#ifndef OMITBAD
void bad()
{
wchar_t * data;
data = new wchar_t[100];
{
/* FLAW: Initialize data as a large buffer that is larger than the small buffer used in the sink */
wmemset(data, L'A', 100-1); /* fill with L'A's */
data[100-1] = L'\0'; /* null terminate */
}
{
wchar_t dest[50] = L"";
/* POTENTIAL FLAW: Possible buffer overflow if data is larger than dest */
memmove(dest, data, wcslen(data)*sizeof(wchar_t));
dest[50-1] = L'\0'; /* Ensure the destination buffer is null terminated */
printWLine(data);
delete [] data;
}
}
#endif /* OMITBAD */
#ifndef OMITGOOD
/* goodG2B1() - use goodsource and badsink by changing the staticReturnsTrue() to staticReturnsFalse() */
static void goodG2B1()
{
wchar_t * data;
data = new wchar_t[100];
{
/* FIX: Initialize data as a small buffer that as small or smaller than the small buffer used in the sink */
wmemset(data, L'A', 50-1); /* fill with L'A's */
data[50-1] = L'\0'; /* null terminate */
}
{
wchar_t dest[50] = L"";
/* POTENTIAL FLAW: Possible buffer overflow if data is larger than dest */
memmove(dest, data, wcslen(data)*sizeof(wchar_t));
dest[50-1] = L'\0'; /* Ensure the destination buffer is null terminated */
printWLine(data);
delete [] data;
}
}
/* goodG2B2() - use goodsource and badsink by reversing the blocks in the if statement */
static void goodG2B2()
{
wchar_t * data;
data = new wchar_t[100];
{
/* FIX: Initialize data as a small buffer that as small or smaller than the small buffer used in the sink */
wmemset(data, L'A', 50-1); /* fill with L'A's */
data[50-1] = L'\0'; /* null terminate */
}
{
wchar_t dest[50] = L"";
/* POTENTIAL FLAW: Possible buffer overflow if data is larger than dest */
memmove(dest, data, wcslen(data)*sizeof(wchar_t));
dest[50-1] = L'\0'; /* Ensure the destination buffer is null terminated */
printWLine(data);
delete [] data;
}
}
void good()
{
goodG2B1();
goodG2B2();
}
#endif /* OMITGOOD */
} /* close namespace */
/* Below is the main(). It is only used when building this testcase on
its own for testing or for building a binary to use in testing binary
analysis tools. It is not used when compiling all the testcases as one
application, which is how source code analysis tools are tested. */
#ifdef INCLUDEMAIN
using namespace CWE122_Heap_Based_Buffer_Overflow__cpp_CWE806_wchar_t_memmove_08; /* so that we can use good and bad easily */
int main(int argc, char * argv[])
{
/* seed randomness */
srand( (unsigned)time(NULL) );
#ifndef OMITGOOD
printLine("Calling good()...");
good();
printLine("Finished good()");
#endif /* OMITGOOD */
#ifndef OMITBAD
printLine("Calling bad()...");
bad();
printLine("Finished bad()");
#endif /* OMITBAD */
return 0;
}
#endif
| [
"jaredzap@rams.colostate.edu"
] | jaredzap@rams.colostate.edu |
7bddd7d452e701efee733d82daec8a7adb554b39 | 867cbc899c85011bf678177b2a279b887747e180 | /include/cgl/math/rasterization.hpp | 5fb4be49e950f8480a9a776984b7a933c0eb66b6 | [
"MIT"
] | permissive | sdragonx/cgl | d9354fafd4ac18aeb06100e259102f4d873d3a1c | d8d45d3a3930bc8f3d0851371760742fda4733b8 | refs/heads/master | 2021-01-17T18:25:46.248270 | 2021-01-01T02:06:14 | 2021-01-01T02:06:14 | 64,765,330 | 1 | 0 | null | 2018-11-24T20:04:10 | 2016-08-02T14:46:19 | C++ | GB18030 | C++ | false | false | 27,798 | hpp | /*
Copyright (c) 2005-2020 sdragonx (mail:sdragonx@foxmail.com)
rasterization.hpp
2019-11-18 19:58:17
rasterizer
光栅化
*/
#ifndef RASTERIZATION_HPP_20191118195817
#define RASTERIZATION_HPP_20191118195817
#include <cgl/public.h>
#include <cgl/vec.hpp>
#include <cgl/math/rasterization.hpp>
namespace cgl{
namespace math{
//---------------------------------------------------------------------------
//获得直线上面的点
//数据长度：max(abs(x2-x1), abs(y2-y1)) + 1
//Bresenham's line algorithm(布雷森汉姆直线算法)
//int init_lineBLA(int& x1, int& y1, int x2, int y2, int bits, int& xstep, int& ystep)
int line_points(vec2i *ls, int x1, int y1, int x2, int y2)
{
using namespace std;
const static int bits = 16;
const static int one = 1 << bits;
vec2i point;
int i;
int dx = x2 - x1;
int dy = y2 - y1;
int x_step, y_step;
int k = abs(dx);
if(k < abs(dy)){
k = abs(dy);
x_step = (dx << bits) / k;
y_step = y1 < y2 ? one : -one;
}
else{
if(k == 0){
return 0;
}
x_step = x1 < x2 ? one : -one;
y_step = (dy << bits) / k;
}
memset(ls, 0, sizeof(vec2i) * (k + 1));
x1 <<= bits;
y1 <<= bits;
x1 += one >> 1;//四舍五入
y1 += one >> 1;
for (i = 0; i < k; ++i){
point.x = x1 >> bits;
point.y = y1 >> bits;
ls[i] = point;
x1 += x_step;
y1 += y_step;
}
//最后压入p2
ls[k].x = x2;
ls[k].y = y2;
return k;
}
int line_points(vec2i *ls, const vec2i& p1, const vec2i& p2)
{
return line_points(ls, p1.x, p1.y, p2.x, p2.y);
}
int line_points(std::vector<vec2i>& ls, int x1, int y1, int x2, int y2)
{
using namespace std;
int k = std::max(abs(x2 - x1), abs(y2 - y1));
++k;
ls.resize(k);
return line_points(&ls[0], x1, y1, x2, y2);
}
int line_points(std::vector<vec2i>& ls, const vec2i& p1, const vec2i& p2)
{
return line_points(ls, p1.x, p1.y, p2.x, p2.y);
}
//
// set_point(context, x, y)
//
//default T == std::vector<vec2i>
template<typename T, typename CTX>
void set_point(CTX& context, int x, int y, T user)
{
context.push_back(vec2i(x, y));
}
template<typename T, typename CTX>
inline void plot_point4(CTX& context, int cx, int cy, int x, int y, T user)
{
math::set_point<T, CTX>(context, cx + x, cy + y, user);
math::set_point<T, CTX>(context, cx + x, cy - y, user);
math::set_point<T, CTX>(context, cx - x, cy + y, user);
math::set_point<T, CTX>(context, cx - x, cy - y, user);
}
template<typename T, typename CTX>
inline void plot_point8(CTX& context, int cx, int cy, int x, int y, T user)
{
math::set_point<T, CTX>(context, cx + x, cy + y, user);
math::set_point<T, CTX>(context, cx + y, cy + x, user); //关于y=x对称
math::set_point<T, CTX>(context, cx + y, cy + -x, user);
math::set_point<T, CTX>(context, cx + x, cy + -y, user); //关于x=0对称
math::set_point<T, CTX>(context, cx + -x, cy + -y, user); //关于原点对称
math::set_point<T, CTX>(context, cx + -y, cy + -x, user);
math::set_point<T, CTX>(context, cx + -y, cy + x, user);
math::set_point<T, CTX>(context, cx + -x, cy + y, user); //关于y=0对称
}
//
// set_point(context, x, y, alpha, user)
//
//default T == std::vector<vec3i>
template<typename T, typename CTX>
void set_point(CTX& context, int x, int y, int alpha, T user)
{
context.push_back(vec3i(x, y, alpha));
}
template<typename T, typename CTX>
inline void plot_point4(CTX& context, int cx, int cy, int x, int y, int alpha, T user)
{
math::set_point<T, CTX>(context, cx + x, cy + y, alpha, user);
math::set_point<T, CTX>(context, cx + x, cy - y, alpha, user);
math::set_point<T, CTX>(context, cx - x, cy + y, alpha, user);
math::set_point<T, CTX>(context, cx - x, cy - y, alpha, user);
}
template<typename T, typename CTX>
inline void plot_point8(CTX& context, int cx, int cy, int x, int y, int alpha, T user)
{
math::set_point<T, CTX>(context, cx + x, cy + y, alpha, user);
math::set_point<T, CTX>(context, cx + y, cy + x, alpha, user); //关于y=x对称
math::set_point<T, CTX>(context, cx + y, cy + -x, alpha, user);
math::set_point<T, CTX>(context, cx + x, cy + -y, alpha, user); //关于x=0对称
math::set_point<T, CTX>(context, cx + -x, cy + -y, alpha, user); //关于原点对称
math::set_point<T, CTX>(context, cx + -y, cy + -x, alpha, user);
math::set_point<T, CTX>(context, cx + -y, cy + x, alpha, user);
math::set_point<T, CTX>(context, cx + -x, cy + y, alpha, user); //关于y=0对称
}
//
// dda_points(T, x1, y1, x2, y2, finalpos)
//
template<typename T, typename CTX>
int solid_line(CTX& context, int x1, int y1, int x2, int y2, T user, bool finalpos = true)
{
using namespace std;
const static int DDA_BITS = 16;
const static int DDA_ONE = 1 << DDA_BITS;
int dx = x2 - x1;
int dy = y2 - y1;
int x_step, y_step;
int k = abs(dx);
if(k < abs(dy)){
k = abs(dy);
x_step = (dx << DDA_BITS) / k;
y_step = y1 < y2 ? DDA_ONE : -DDA_ONE;
}
else{
if(k == 0){
return 0;
}
x_step = x1 < x2 ? DDA_ONE : -DDA_ONE;
y_step = (dy << DDA_BITS) / k;
}
x1 <<= DDA_BITS;
y1 <<= DDA_BITS;
x1 += DDA_ONE >> 1;//四舍五入，移动半个像素
y1 += DDA_ONE >> 1;
int i;
int x, y;
for (i = 0; i < k; ++i){
x = x1 >> DDA_BITS;
y = y1 >> DDA_BITS;
set_point<T>(context, x, y, user);
x1 += x_step;
y1 += y_step;
}
//最后压入p2
if(finalpos){
set_point<T>(context, x2, y2, user);
}
return k;
}
//
// smooth_line(T, x1, y1, x2, y2, color)
//
template<typename T, typename CTX>
int smooth_line_impl(CTX& context, int x1, int y1, int x2, int y2, T user)
{
using namespace std;
const static int AA_BITS = 16;
const static int AA_ONE = 1 << AA_BITS;
const static int AA_MASK = 0xFF;
int dx = x2 - x1;
int dy = y2 - y1;
/*
if(dx == 0){
if(dy != 0){
//pixelbuf.vline(x1, y1, y2, color);
}
return 0;
}
else if(dy == 0){
//pixelbuf.hline(x1, x2, y1, color);
return 0;
}
*/
int x_step, y_step;
int k = abs(dx);
int i;
int x, y;
int alpha;
if(k < abs(dy)){
k = abs(dy) >> AA_BITS;
x_step = dx / k;
y_step = y1 < y2 ? AA_ONE : -AA_ONE;
// x1 += AA_ONE >> 1;//四舍五入
// y1 += AA_ONE >> 1;
for (i = 0; i < k; ++i){
x = x1 >> AA_BITS;
y = y1 >> AA_BITS;
alpha = (x1 >> 8) & AA_MASK;
// alpha = x1 & AA_MASK;
set_point<T, CTX>(context, x, y, 255 - alpha, user);
set_point<T, CTX>(context, x + 1, y, alpha, user);
x1 += x_step;
y1 += y_step;
}
}
else{
//斜线没有AA效果
k = abs(dx) >> AA_BITS;
if(k == 0){
return 0;
}
x_step = x1 < x2 ? AA_ONE : -AA_ONE;
y_step = dy / k;
// x1 += AA_ONE >> 1;//四舍五入
// y1 += AA_ONE >> 1;
for (i = 0; i < k; ++i){
x = x1 >> AA_BITS;
y = y1 >> AA_BITS;
alpha = (y1 >> 8) & AA_MASK;
// alpha = y1 & AA_MASK;
set_point<T, CTX>(context, x, y, 255 - alpha, user);
set_point<T, CTX>(context, x, y + 1, alpha, user);
x1 += x_step;
y1 += y_step;
}
}
set_point<T, CTX>(context, x2 >> AA_BITS, y2 >> AA_BITS, 255, user);
return k;
}
template<typename T, typename CTX>
int smooth_line(CTX& context, int x1, int y1, int x2, int y2, T user)
{
const int AA_BITS = 16;
return smooth_line_impl<T, CTX>(context, x1<<AA_BITS, y1<<AA_BITS, x2<<AA_BITS, y2<<AA_BITS, user);
}
template<typename T, typename CTX>
int smooth_line(CTX& context, float x1, float y1, float x2, float y2, T user)
{
float scale = 65535.0f;
return smooth_line_impl<T, CTX>(context,
round(x1 * scale), round(y1 * scale), round(x2 * scale), round(y2 * scale), user);
}
//---------------------------------------------------------------------------
namespace internal{
inline void plot_point4(std::vector<vec2i>& ls, int ox, int oy, int x, int y)
{
ls.push_back(vec2i(ox + x, oy + y));
ls.push_back(vec2i(ox - x, oy + y));
ls.push_back(vec2i(ox - x, oy - y));
ls.push_back(vec2i(ox + x, oy - y));
}
//反走样圆，vec3.z = alpha
inline void plot_point(std::vector<vec3i>& ls, int x, int y, float alpha)
{
ls.push_back(vec3i(x, y, round(alpha * 255.0f)));
}
//绘制反走样圆
inline void plot_point4(std::vector<vec3i>& ls, int cx, int cy, int x, int y, float alpha)
{
plot_point(ls, cx + x, cy + y, alpha);
plot_point(ls, cx + y, cy + -x, alpha);
plot_point(ls, cx + -y, cy + -x, alpha);
plot_point(ls, cx + -y, cy + x, alpha);
}
//绘制反走样圆
inline void plot_points(std::vector<vec3i>& ls, int cx, int cy, int x, int y, float alpha)
{
plot_point(ls, cx + x, cy + y, alpha);
plot_point(ls, cx + y, cy + x, alpha); //关于y=x对称
plot_point(ls, cx + y, cy + -x, alpha);
plot_point(ls, cx + x, cy + -y, alpha); //关于x=0对称
plot_point(ls, cx + -x, cy + -y, alpha); //关于原点对称
plot_point(ls, cx + -y, cy + -x, alpha);
plot_point(ls, cx + -y, cy + x, alpha);
plot_point(ls, cx + -x, cy + y, alpha); //关于y=0对称
}
}//internal
void smooth_circle(std::vector<vec3i>& ls, int cx, int cy, int r)
{
int y = r;
float e;
//画1/8圆
for(int x=0; x<=y; x++){
//算上下两点到理想圆的距离，作为亮度参数
e = y - sqrt((float)r * r - (x + 1) * (x + 1));
if(e >= 1.0f){
--e;
--y;
}
internal::plot_points(ls, cx, cy, x, y, 1.0f - e);
internal::plot_points(ls, cx, cy, x, y - 1, e);
}
}
//反锯齿画圆
template<typename T, typename CTX>
void smooth_circle(CTX& context, int cx, int cy, int r, T user)
{
if(r == 0)return ;
int x = 0;
int y = r;
//int p = 1.25 - r;
int p = 3 - 2 * r;
int a = (r * 4 * M_SQRT2);
int n = 0;
math::set_point<T, CTX>(context, cx, cy + r, 128, user);
math::set_point<T, CTX>(context, cx, cy - r, 128, user);
math::set_point<T, CTX>(context, cx + r, cy, 128, user);
math::set_point<T, CTX>(context, cx - r, cy, 128, user);
math::set_point<T, CTX>(context, cx, cy + r + 1, 128, user);
math::set_point<T, CTX>(context, cx, cy - r - 1, 128, user);
math::set_point<T, CTX>(context, cx + r + 1, cy, 128, user);
math::set_point<T, CTX>(context, cx - r - 1, cy, 128, user);
while(x < y){
if(p < 0){
p += 4 * x + 6;
}
else{
p += 4 * ( x - y ) + 10;
n += 1 - y * 2;
--y;
}
++x;
n += 1 + x * 2;
int alpha = ( n + 1 + y * 2 ) * 1448 / 1024 * 255 / a;
math::plot_point8(context, cx, cy, x, y, alpha, user);
math::plot_point8(context, cx, cy, x, y + 1, 255 - alpha, user);
}
}
//---------------------------------------------------------------------------
//获得椭圆上的点，ox oy为圆心，a b为椭圆水平和垂直半径
void ellipse_points(std::vector<vec2i>& ls, int x1, int y1, int x2, int y2)
{
using namespace math;
//整形模式，超过一定大小，就会失真
//if(a > 1024 || b > 1024)return ;
ls.clear();
float a = (x2 - x1) / 2.0f;
float b = (y2 - y1) / 2.0f;//b小于0的情况下，算法会失效
//计算中线
if(b < 0){
b = -b;
x1 += a;
y1 -= b;
}else{
x1 += a;
y1 += b;
}
float aa = a * a;
float bb = b * b;
//float aax2 = aa * 2;
//float bbx2 = bb * 2;
float p;
int x = 0;
int y = b;
//ellipsePlotPoints(ox, oy, x, y);
//中线
ls.push_back(vec2i(x1, y1 + b + 0.5f));
ls.push_back(vec2i(x1, y1 - b));
//第一部分
//float t = sqrt(aa + bb);
//while(x <= (aa / t) && y <= (bb / t))
p = bb + aa * (-b + 0.25f);
while (bb * (x + 1) < aa * (y - 0.5))
//int px = aa * 2;
//int py = 0;
//while(bb * x < aa * y)
{
if(p < 0){
//p += bb * (2 * x + 3);
//p += bb * 2 * x + bb * 3;
//p += bb * 2 * x + bb * 2 + bb;
//p += bbx2 * x + bbx2 + bb;
p += bb * (x + x + 3);
}
else{
//p += bb * (2 * x + 3) + aa * (2 - 2 * y);
//p += bb * 2 * x + bb * 3 + aa * 2 - aa * 2 * y;
p += bb * (x + x + 3) + aa * (2 - y - y);
--y;
}
++x;
//py += bb;
internal::plot_point4(ls, x1, y1, x, y);
}
//第二部分
ls.push_back(vec2i(x1 - a, y1 ));
ls.push_back(vec2i(x1 + a + 1, y1));
//p = bb * (x + 0.5) * (x + 0.5) + aa * (y - 1) * (y - 1) - aa * bb;
p = bb * (0.25 * x) + aa * (1 - (y * 2));
while(y > 1)
{
if(p < 0){
++x;
p += bb * (x + x + 2) + aa * (3 - y - y);
}
else{
p += aa * (3 - y - y);
}
--y;
internal::plot_point4(ls, x1, y1, x, y);
}
}
//---------------------------------------------------------------------------
//正六边形
int hexagon_points(std::vector<vec2i>& ls, int x, int y, int size)
{
ls.clear();
if(size < 1){
ls.push_back(vec2i(x, y));
return 1;
}
int half = size / 2;
int i, j;
int n;
//预先分配空间
ls.reserve(size * 6);
//左右两边
for(i=-half; i<=half; ++i){
ls.push_back(vec2i(x - size, y + i));
ls.push_back(vec2i(x + size, y + i));
}
//上下两个顶点
ls.push_back(vec2i(x, y + size));
ls.push_back(vec2i(x, y - size));
//四个斜边
for(i=1, j=0; i<size; ++i, ++j){
n = j >> 1;
n -= size;
++n;
internal::plot_point4(ls, x, y, i, n);
}
return ls.size();
}
int hexagon_points_htz(std::vector<vec2i>& ls, int x, int y, int size)
{
ls.clear();
if(size < 1){
ls.push_back(vec2i(x, y));
return 1;
}
int half = size / 2;
int i, j;
int n;
//预先分配空间
ls.reserve(size * 6);
//左右两边
for(i=-half; i<=half; ++i){
ls.push_back(vec2i(x + i, y - size));
ls.push_back(vec2i(x + i, y + size));
}
//上下两个顶点
ls.push_back(vec2i(x + size, y));
ls.push_back(vec2i(x - size, y));
//四个斜边
for(i=1, j=0; i<size; ++i, ++j){
n = j >> 1;
n -= size;
++n;
internal::plot_point4(ls, x, y, n, i);
}
return ls.size();
}
//---------------------------------------------------------------------------
//正八边形
//正方形切割八边形边长：sin(45)*R
void draw_octagon(std::vector<vec2i>& ls, int x, int y, int size)
{
int side = size * 0.70710678f + 0.5f;
int n;
ls.clear();
//中线
ls.push_back(vec2i(x - 0, y - size));
ls.push_back(vec2i(x - 0, y + size));
ls.push_back(vec2i(x - size, y - 0));
ls.push_back(vec2i(x + size, y - 0));
//斜边，有重复像素
n = side - 1;
internal::plot_point4(ls, x, y, n, n);
for(int i = 1; i < side; ++i){
//22.5度 0.3826834323650897717284599840304
n = i * 1696 / 4096;
//n = i * 424 / 1024;//424也有误差
n -= size;
++n;
internal::plot_point4(ls, x, y, i, n);
internal::plot_point4(ls, x, y, n, i);
}
}
//正八边形(平底)
//a = sqrt(2) / 2
//a = sqrt(a) = 0.84089641525371454303112547623321
//外接正方形边长 s = a + sqrt(2) + a
//sqrt(2) / s = 0.45678638313705510397806219881721
void draw_octagon_hzt(std::vector<vec2i> &ls, int x, int y, int size, bool regular = false)
{
//int half = size * 1870 / 4096;//0.45678638313705510397806219881721
//0.45效果好，但缝隙不规律
int half = regular ?
size * 1870 / 4096 :
size / 2;//方便填充
//横线、竖线
for(int i=-half; i<half + 1; ++i){
ls.push_back(vec2i(x - i, y - size));
ls.push_back(vec2i(x - i, y + size));
ls.push_back(vec2i(x - size, y - i));
ls.push_back(vec2i(x + size, y - i));
}
int n;
for(int i=1; i<size - half; ++i){
n = half + i;
ls.push_back(vec2i(x - size + i, y - n));
ls.push_back(vec2i(x + size - i, y - n));
ls.push_back(vec2i(x - size + i, y + n));
ls.push_back(vec2i(x + size - i, y + n));
}
//填充缝隙
if(!regular && (size + 1) & 1){
half -= 1;
for(int i=1; i<size - half; ++i){
n = half + i + 0;
ls.push_back(vec2i(x - size + i, y - n));
ls.push_back(vec2i(x + size - i, y - n));
ls.push_back(vec2i(x - size + i, y + n));
ls.push_back(vec2i(x + size - i, y + n));
}
}
}
}//end namespace math
}//end namespace cgl
#endif //RASTERIZATION_HPP_20191118195817
/*
//获得直线上面的点
int line_points(std::vector<vec2i>& ls, int x1, int y1, int x2, int y2)
{
using namespace std;
vec2i point;
int wx = x2-x1;
int wy = y2-y1;
int offset;
int dstp;
int step;
ls.clear();
if(abs(wx) < abs(wy))
{
step = wy < 0 ? -1 : 1;
if(wx){
offset = ( wx << 16 ) / wy;
offset *= step;
dstp = x1<<16;
dstp += 32767;//四舍五入
for(int i=y1; i!=y2; i+=step){
point.x = dstp>>16;
point.y = i;
ls.push_back(point);
dstp += offset;
}
}
else{
for(int i=y1; i!=y2; i+=step){
point.x = x1;
point.y = i;
ls.push_back(point);
}
}
}
else //if(abs(wy) < abs(wx))
{
step = wx < 0 ? -1 : 1;
if(wy){
offset = ( wy << 16 ) / wx;
offset *= step;
dstp = y1<<16;
dstp += 32767;
for(int i=x1; i!=x2; i+=step){
point.x = i;
point.y = dstp>>16;
ls.push_back(point);
dstp += offset;
}
}
else{
for(int i=x1; i!=x2; i+=step){
point.x = i;
point.y = y1;
ls.push_back(point);
}
}
}
point.x = x2;
point.y = y2;
ls.push_back(point);
return ls.size();
}
*/
/*
int smooth_line(int x1, int y1, int x2, int y2)
{
using namespace std;
const static int bits = 16;
const static int one = 1 << bits;
vec2i point;
int i;
int dx = x2 - x1;
int dy = y2 - y1;
int x_step, y_step;
int k = abs(dx);
int alpha;
if(k < abs(dy)){
k = abs(dy);
x_step = (dx << bits) / k;
y_step = y1 < y2 ? one : -one;
x1 <<= bits;
y1 <<= bits;
x1 += one >> 1;//四舍五入
y1 += one >> 1;
for (i = 0; i < k; ++i){
point.x = x1 >> bits;
point.y = y1 >> bits;
alpha = x1 & 0xFFFF;
// alpha *= 255;
// alpha >>= bits;
alpha >>= 8;
draw_pixel(Form1->Canvas, point.x, point.y, 255 - alpha);
draw_pixel(Form1->Canvas, point.x + 1, point.y, alpha);
x1 += x_step;
y1 += y_step;
}
}
else{
if(k == 0){
return 0;
}
x_step = x1 < x2 ? one : -one;
y_step = (dy << bits) / k;
x1 <<= bits;
y1 <<= bits;
x1 += one >> 1;//四舍五入
y1 += one >> 1;
for (i = 0; i < k; ++i){
point.x = x1 >> bits;
point.y = y1 >> bits;
alpha = y1 & 0xFFFF;
alpha >>= 8;
draw_pixel(Form1->Canvas, point.x, point.y, 255 - alpha);
draw_pixel(Form1->Canvas, point.x, point.y + 1, alpha);
x1 += x_step;
y1 += y_step;
}
}
return k;
}
//未完成
void smooth_ellipse(std::vector<vec3i>& ls, int x1, int y1, int x2, int y2)
{
using namespace math;
//整形模式，超过一定大小，就会失真
//if(a > 1024 || b > 1024)return ;
ls.clear();
float a = (x2 - x1) / 2.0f;
float b = (y2 - y1) / 2.0f;//b小于0的情况下，算法会失效
//计算中线
if(b < 0){
b = -b;
x1 += a;
y1 -= b;
}else{
x1 += a;
y1 += b;
}
float aa = a * a;
float bb = b * b;
//float aax2 = aa * 2;
//float bbx2 = bb * 2;
float alpha = 1;
float p;
int x = 0;
int y = b;
//ellipsePlotPoints(ox, oy, x, y);
//中线
ls.push_back(vec2i(x1, y1 + b + 0.5f));
ls.push_back(vec2i(x1, y1 - b));
//第一部分
//float t = sqrt(aa + bb);
//while(x <= (aa / t) && y <= (bb / t))
p = bb + aa * (-b + 0.25f);
while (bb * (x + 1) < aa * (y - 0.5))
//int px = aa * 2;
//int py = 0;
//while(bb * x < aa * y)
{
if(p < 0){
//p += bb * (2 * x + 3);
//p += bb * 2 * x + bb * 3;
//p += bb * 2 * x + bb * 2 + bb;
//p += bbx2 * x + bbx2 + bb;
p += bb * (x + x + 3);
}
else{
//p += bb * (2 * x + 3) + aa * (2 - 2 * y);
//p += bb * 2 * x + bb * 3 + aa * 2 - aa * 2 * y;
p += bb * (x + x + 3) + aa * (2 - y - y);
internal::plot_point(ls, x1 + x + 1, y1 + y, x / a);
--y;
internal::plot_point(ls, x1 + x, y1 + y, x / a);
}
++x;
//py += bb;
//internal::plot_point4(ls, x1, y1, x, y, alpha);
internal::plot_point(ls, x1 + x, y1 + y, 1 - x / a);
}
//第二部分
ls.push_back(vec2i(x1 - a, y1 ));
ls.push_back(vec2i(x1 + a + 1, y1));
//p = bb * (x + 0.5) * (x + 0.5) + aa * (y - 1) * (y - 1) - aa * bb;
p = bb * (0.25 * x) + aa * (1 - (y * 2));
while(y > 1)
{
if(p < 0){
++x;
p += bb * (x + x + 2) + aa * (3 - y - y);
}
else{
p += aa * (3 - y - y);
}
--y;
//internal::plot_point4(ls, x1, y1, x, y, alpha);
//internal::plot_point(ls, x1 + x, y1 + y, alpha);
}
}
//Bresenham画圆法
void draw_circle(pixelbuffer<uint32_t>& pixelbuf, int cx, int cy, int r, uint32_t c)
{
int x = 0;
int y = r;
//int p = 1.25 - r;
int p = 3 - 2 * r;
math::plot_point8(pixelbuf, cx, cy, x, y, 0u);
while(x < y){
if(p < 0){
p += 4 * x + 6;
}
else{
p += 4 * ( x - y ) + 10;
--y;
}
++x;
math::plot_point8(pixelbuf, cx, cy, x, y, c);
}
}
//正负画圆法。绘制像素拐角处是连续的
void draw_circle(pixelbuffer<uint32_t>& pixelbuf, int cx, int cy, int r, uint32_t c)
{
int x = 0; //x==1需要绘制中点
int y = r;
int p = 0;
while(x <= y){
plot_point8(pixelbuf, cx, cy, x, y, 0x1f000000u);
if(p <= 0){
p += 2 * x + 1;
++x;
}
else{
p -= 2 * y + 1;
--y;
}
}
}
//快速画圆法，没有乘法计算
void draw_circle(pixelbuffer<uint32_t>& pixelbuf, int cx , int cy , int r, uint32_t c)
{
int x = 0;
int y = r;
int d = -r / 2;
//CirclePlot(cx , cy , x , y);
if(r & 1 == 0){
while(x < y){
x++;
if(d < 0){
d += x;
}
else{
y--;
d += x - y;
}
plot_point8(pixelbuf, cx, cy, x, y, 0x1f000000u);
}
}
else{
while(x < y){
x++;
if(d < 0){
d += x + 1;
}
else{
y--;
d += x - y + 1;
}
plot_point8(pixelbuf, cx, cy, x, y, 0x1f000000u);
}
}
}
//反走样画圆，alpha计算原理没有明白
void smooth_circle1(pixelbuffer<uint32_t>& pixelbuf, int cx, int cy, int r, uint32_t color)
{
if(r == 0)return ;
int x = 0;
int y = r;
int p = 1 - r;
int dE = 3;
int dSE = -(y * 2)+5;
int dS = 0;
double a = 1.0 / ((r << 1) * 1.4142);
print(1 / a);
//put_pixel(pixelbuf, cx, cy, x, y, color, 0.20);
//put_pixel(pixelbuf, cx, cy, x, y - 1, color, 0.15);
while(x < y){
if(p < 0){
p += dE;
dE += 2;
dSE += 2;
}
else{
p += dSE;
dS += 1 - y * 2;
dE += 2;
dSE+= 4;
--y;
}
dS += 1 + x * 2;
++x;
// put_pixel(pixelbuf, cx, cy, x, y, color, 1 - a * abs(dS));
put_pixel(pixelbuf, cx, cy, x, y + 1, color, 1 - a * (dS+(y<<1)+1) );
// put_pixel(pixelbuf, cx, cy, x, y, color, 1 - a * (dS-(y<<1)+1) );
put_pixel(pixelbuf, cx, cy, x, y - 1, color, 1 + a * (dS-(y<<1)+1) );
}
}
void draw_ellipse(pixelbuffer<uint32_t>& pixelbuf, int cx, int cy, int rx, int ry)
{
int p; //评价参数
int aa = rx * rx;
int bb = ry * ry;
//x从0增加到45度位置
//使用x递增的最小y值，通过斜率为，计算得到
int minYofDeltaX = round(bb / sqrt(aa + bb));
int x = 0;
int y = ry;
// 计算区域中央决策参数的初始值
p = bb - aa * ry + aa / 4;
while(minYofDeltaX < y){
if(p < 0){
//如果p<0, 绘制下一个点(x+1,y), 并且计算
//p += rx*rx*(3+2*x);
p += bb * (x + x + 3);
}
else{
//如果P>=0, 绘制下一个点(x+1,y-1), 并且计算
//p += rx*rx*(3+2*x) - 2*r1*r1*(y-1)
--y;
p += bb * (3 + 2 * x) - 2 * aa * ( y - 1);
}
++x;
math::plot_point4(pixelbuf, cx, cy, x, y, 0x1f000000u);
}
//p = bb * (x + 0.5) * (x + 0.5) + aa * (y - 1) * (y - 1) - aa * bb;
// d = sqb * (x * x + x) + sqa * (y * y - y) - sqa * sqb;
p = bb * x / 4 + aa * (1 - y - y);
while(1 < y){
if(p < 0){
//P<0的情况下,下一个目标点为(x,y-1)，并且计算
++x;
p += bb * (x + x + 2) + aa * (3 - y - y);
}
else{
//如果p>=0的情况下，下一个目标点为(x+1,y-1)，并且计算
p += aa * (3 - y - y);
}
--y;
math::plot_point4(pixelbuf, cx, cy, x, y, 0x1fff0000u);
}
}
*/
| [
"noreply@github.com"
] | noreply@github.com |
60b0539b01889ebc804baac0321840b56d80ba40 | 859d3e0fc981a6149a3f5b1fd8b2d1161ccfa8e5 | /roadfighter/src/ObserverWorld.cpp | eb92d2e77828edb04b5a9985a86d99cc189b55cd | [] | no_license | miguelDagrain/road_fighter | c74240de2b8a77b34969057be4d18eef4bf3131d | fcbe0cc138b87425d61bef30eb28a692729d349e | refs/heads/master | 2021-10-10T21:46:21.319984 | 2019-01-17T18:27:40 | 2019-01-17T18:27:40 | 158,278,979 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,567 | cpp | #include "roadfighter/include/ObserverWorld.h"
/**
* @brief basis constructor van de ObserverWorld.
*/
RF::ObserverWorld::ObserverWorld(): existPlayer(false), score(0), timeScore(10000), finished(false)
{
RF::location loc(0, 0);
endWorld = loc;
}
/**
* @brief destructor van een ObserverWorld.
*/
RF::ObserverWorld::~ObserverWorld() = default;
/**
* @brief functie die de observer op de hoogte stelt dat er een nieuw stuk weg moet aangemaakt worden.
*
* @param loc locatie waar van het stuk weg is verwijderd.
*/
void RF::ObserverWorld::notifyEndWorld(const RF::location &loc)
{
endWorld = loc;
}
/**
* @brief functie die de de observer reset voor het einde van een stuk weg.
*/
void RF::ObserverWorld::resetEndWorld()
{
RF::location loc(0, 0);
endWorld = loc;
}
/**
* @brief functie die controleert of er een stuk weg is verwijderd.
*
* @return de locatie waar het stuk weg is verwijderd,
* loc(0, 0) betekent dat er geen stuk weg is verwijderd.
*/
const RF::location RF::ObserverWorld::checkEndWorld() {
return endWorld;
}
/**
* @brief functie die de observer op de hoogte stelt dat de speler is gecrasht.
*/
void RF::ObserverWorld::notifyExistPlayer() {
existPlayer = true;
}
/**
* @brief functie die het onbestaan van de speler reset.
*/
void RF::ObserverWorld::resetExistPlayer() {
existPlayer = false;
}
/**
* @brief functie die controleert of de speler nog bestaat.
*
* @return het al dan niet onbestaan van de speler.
*/
bool RF::ObserverWorld::checkExistPlayer() {
return existPlayer;
}
/**
* @brief functie die aangeeft dat er weer een bepaalde tijd is verstreken, belangrijk voor de tijdscore
*/
void RF::ObserverWorld::notifyTimePassed() {
timeScore = long(timeScore*0.9999);
}
/**
* @brief functie die aangeeft dat een entiteit is geschoten.
*/
void RF::ObserverWorld::notifyShotEntity() {
score += 100;
}
/**
* @brief functie die aangeeft dat de speler is gecrasht.
*/
void RF::ObserverWorld::notifyCrashed() {
score -= 200;
}
/**
* @brief functie die de observer op de hoogte stelt dat de speler is gefinished
*/
void RF::ObserverWorld::notifyFinished() {
finished = true;
score += timeScore;
}
/**
* @brief functie die controleert of de speler is gefinished.
*
* @return of de speler al dan niet is gefinished.
*/
bool RF::ObserverWorld::checkFinished() {
return finished;
}
/**
* @brief functie die de score controleert.
*
* @return de score die op dit moment al is behaald.
*/
long RF::ObserverWorld::checkScore() {
return score;
}
| [
"Miguel.Dagrain@student.uantwerpen.be"
] | Miguel.Dagrain@student.uantwerpen.be |
2f7bed79775bd6c1a3b1b0ef0b385679c344d0a1 | 62ad9db32df2f96aabe1ed94f28902d439073bb5 | /PacManState/include/util/EnumClassHash.h | 0f90867a7bd7d841ee34a8b1e1685f3c258f6111 | [
"MIT"
] | permissive | shamexln/PacMan | 31aacbb0faf9f6976ce0c7d899eb83ce3ee9009d | 319e9776582cf9118b38c72d31855fb4c598e986 | refs/heads/master | 2022-04-17T08:36:18.035379 | 2020-04-17T19:08:38 | 2020-04-17T19:08:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 211 | h | #pragma once
#define DllExport __declspec( dllexport )
namespace pacman {
struct DllExport EnumClassHash {
template <typename T>
size_t operator()(T t) const {
return static_cast<size_t>(t);
}
};
}
| [
"mwtegelaers@gmail.com"
] | mwtegelaers@gmail.com |
85b0147d29792734b333149b160a24fa0bcb1cf7 | 34b4c9797f23d00cf87fa992f2bf51251b5eb95d | /src/clientversion.h | 7c53bf033611a4eb50e862d7ab71b497c28a6550 | [
"MIT"
] | permissive | Cryptohelper1/Prufus-core | ab77ec6182cb459f8b40362f7dd3828fe44009f1 | 8dbefe51d3e89236ed185c6b6607694de928e69d | refs/heads/master | 2021-04-12T09:43:23.889338 | 2018-03-25T17:34:15 | 2018-03-25T17:34:15 | 126,622,123 | 1 | 5 | MIT | 2018-06-10T15:40:15 | 2018-03-24T17:13:23 | C++ | UTF-8 | C++ | false | false | 2,177 | h | // Copyright (c) 2009-2014 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_CLIENTVERSION_H
#define BITCOIN_CLIENTVERSION_H
#if defined(HAVE_CONFIG_H)
#include "config/prufus-config.h"
#else
/**
* client versioning and copyright year
*/
//! These need to be macros, as clientversion.cpp's and prufus*-res.rc's voodoo requires it
#define CLIENT_VERSION_MAJOR 1
#define CLIENT_VERSION_MINOR 0
#define CLIENT_VERSION_REVISION 0
#define CLIENT_VERSION_BUILD 0
//! Set to true for release, false for prerelease or test build
#define CLIENT_VERSION_IS_RELEASE true
/**
* Copyright year (2009-this)
* Todo: update this when changing our copyright comments in the source
*/
#define COPYRIGHT_YEAR 2018
#endif //HAVE_CONFIG_H
/**
* Converts the parameter X to a string after macro replacement on X has been performed.
* Don't merge these into one macro!
*/
#define STRINGIZE(X) DO_STRINGIZE(X)
#define DO_STRINGIZE(X) #X
//! Copyright string used in Windows .rc files
#define COPYRIGHT_STR "2009-" STRINGIZE(COPYRIGHT_YEAR) " The Bitcoin Core Developers, 2014-" STRINGIZE(COPYRIGHT_YEAR) " The Dash Core Developers, 2015-" STRINGIZE(COPYRIGHT_YEAR) " The PIVX Core Developers, 2015-" STRINGIZE(COPYRIGHT_YEAR) " The Prufus Developers"
/**
* prufusd-res.rc includes this file, but it cannot cope with real c++ code.
* WINDRES_PREPROC is defined to indicate that its pre-processor is running.
* Anything other than a define should be guarded below.
*/
#if !defined(WINDRES_PREPROC)
#include <string>
#include <vector>
static const int CLIENT_VERSION =
1000000 * CLIENT_VERSION_MAJOR ///
+ 10000 * CLIENT_VERSION_MINOR ///
+ 100 * CLIENT_VERSION_REVISION ///
+ 1 * CLIENT_VERSION_BUILD;
extern const std::string CLIENT_NAME;
extern const std::string CLIENT_BUILD;
extern const std::string CLIENT_DATE;
std::string FormatFullVersion();
std::string FormatSubVersion(const std::string& name, int nClientVersion, const std::vector<std::string>& comments);
#endif // WINDRES_PREPROC
#endif // BITCOIN_CLIENTVERSION_H
| [
"37479709+Cryptohelper1@users.noreply.github.com"
] | 37479709+Cryptohelper1@users.noreply.github.com |
47f9dbe1ca3b3d46a5184e1a02cc95ae795479c6 | 3fe13e073d1a7c3e8beacc71f1570fc8a2ec8692 | /src/cont2/force2.inc | 9a1c8c77e6a2575f1d61f876581e02924cb35974 | [
"MIT"
] | permissive | jerebenitez/IFE-simpact-openfoam | 7dbba4ae7ec3aa518277d7fa5f6e0fab42a2cd48 | 2dbcbf3195b22fca1c80ad0da6b3822b6cad5cdf | refs/heads/master | 2021-06-17T09:28:47.097398 | 2021-06-14T21:16:39 | 2021-06-14T21:16:39 | 205,249,068 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,718 | inc | SUBROUTINE force2(isn,issdb,rssdb,lcseg,indco,cprop,x,prdat,dtime, &
emass,fcont,surtf,cursl,tn,icnod,press,wear,wwear,&
mtdof,sldof,area,td)
!.... form contact residual force for a node-segment 2-d contact element
USE npo_db, ONLY : tempe,tresi
IMPLICIT NONE
! dummy arguments
LOGICAL, INTENT(IN) :: cursl,press,wear
INTEGER (kind=4), INTENT (IN) :: indco,isn,lcseg(:,:),icnod,mtdof,sldof
INTEGER (kind=4), INTENT (IN OUT) :: issdb(:)
REAL (kind=8), INTENT (IN) :: cprop(:),x(:,:),emass(:,:), &
dtime,tn(:,:),td
REAL(kind=8),POINTER :: area(:)
REAL (kind=8), INTENT (IN OUT) :: rssdb(:),surtf(:),fcont(:,:), &
prdat(:),wwear(:)
! local variables
LOGICAL :: last,same
INTEGER (kind=4) :: n1,n2,n1o,n2o,nearn,onear,n,node
REAL (kind=8) :: fc,r,s,ro,so,to,ds,dt,pgap,pnltc,cofri,m,maux, &
tslip,eslip,fricm,frict,lengt,auxil,xfact,pslip, &
vns(2,3),t1(2),ts(2),eresf(2,3)
INTERFACE
INCLUDE 'vecuni.h'
END INTERFACE
!.... read gap, normal direction and isoparametric coordinates of the
!.... projection point, from real-type slave surface database
IF( prdat(1) < cprop(4) )THEN
WRITE(58,"(' gap > cutof, node:',i6,2e15.4)",ERR=9999) isn,prdat(1),rssdb(2)
! WRITE(* ,"(' gap > cutof, node:',i6,2e15.4)")isn,prdat(1),rssdb(2)
END IF
pgap = - cprop(1) * prdat(1)*(1d0+prdat(1)/cprop(4)) !normal penalty * gap
IF( cursl .AND. indco /= 1)THEN
IF(indco == 0)THEN
t1 = (-tn(:,icnod)+prdat(2:3))/2d0 !average normal
vns(:,1) = t1/SQRT(DOT_PRODUCT(t1,t1))
ELSE ! IF(indco == 2)THEN
vns(:,1) = -tn(:,icnod) !node normal direction
END IF
ELSE
vns(:,1) = prdat(2:3) !normal direction
END IF
!segment linear shape functions
s = prdat(4) !node 2 (xita)
r = 1d0 - s !node 1 (1-xita)
nearn = issdb(1) !segment
! computes equivalent mass
m = 0d0 !initializes
maux = MAXVAL(emass(1:2,isn)) ! mass of slave node
IF( maux /= 0d0) m = 1d0/maux
!IF ((indco == 0) .OR. (indco == 2)) THEN ! IF forces in both surfaces or master
IF ( m == 0d0 ) THEN ! IF forces in both surfaces or master
!.... consider master nodes mass
DO n =1,2 !For each master node
node = lcseg(n,nearn) !global node number
maux = MAXVAL(emass(1:2,node)) !max mass in any direction
IF(maux > 0)THEN ! add to equivalent mass
SELECT CASE (n)
CASE (1) !first node
m = m + r**2/maux !use r
CASE (2) !second node
m = m + s**2/maux !use s
END SELECT
END IF
END DO
END IF
IF(m == 0d0) THEN
WRITE(*, *)' Error in nodal mass ',isn,lcseg(1:2,nearn)
WRITE(lures,*,ERR=9999) ' Error in nodal mass, Internal numbers are: Slave ',isn, &
& ' Master segment ',lcseg(1:2,nearn)
WRITE(lures,*,ERR=9999) ' Check data, at least one surface Must have mass'
CALL runen3('CONTA2: zero masses in contact pair')
END IF
xfact = 2d0/(m*dtime**2) !computes xfact
!.... form residual force vector
IF( indco == 0 .OR. indco == 2) THEN !forces on both surfaces or master
!.... form ns operator
vns(:,2) = -r*vns(:,1) !factor for node 1
vns(:,3) = -s*vns(:,1) !factor for node 2
eresf = pgap*vns !normal residual forces
ELSE IF(indco == 1)THEN !forces only in slave surface
eresf(:,1) = pgap*vns(:,1) !normal residual forces
END IF
n1 = lcseg(1,nearn) !nodes defining master segment
n2 = lcseg(2,nearn)
pslip = 0d0
! friction treatment
pnltc = cprop(2) !tangential penalty parameter
last = issdb(2) > 0 !contact at previous step
IF( issdb(3) < 1 ) issdb(3) = 1 !change to penetration
IF( issdb(3) == 1)THEN !no-slip in previous step
cofri = cprop(3) !Static friction coefficient
ELSE
cofri = cprop(6) !Kinetic friction coefficient
END IF
IF(cofri /= 0D0) THEN !if no friction, that's all
! computes friction forces tslip: total slip; eslip : elastic slip
IF( .NOT.last ) THEN ! IF no penetration in previous step
rssdb(1) = s ! stores onset natural coordinates
frict = 0d0
ELSE ! Penetration in previous step
fricm = cofri*pgap !maximum friction force
t1 = x(:,n2) - x(:,n1) !side vectors n1->n2
so = rssdb(1) !old onset coordinates
onear = issdb(2) !previous segment
same = onear == nearn !same of different segments
IF( same )THEN ! IF penetration in previous step was in the same segment
ds = s - so !differences in natural coordinates
ts = t1*ds !slip vector
CALL vecuni(2,ts,tslip) !ts = unit vector, tslip = total slip
frict = pnltc*tslip !tangential force (+)
IF(frict > fricm) THEN !compare with maximum force
! IF friction force > maximum friction force ==> slip
frict = fricm !assign maximum force
eslip = frict/pnltc !maximum slip
rssdb(1) = s - ds*eslip/tslip !updates onset natural coordinates
pslip = tslip - eslip ! (+)
issdb(3) = 2 !remember that point is sliding
ELSE
issdb(3) = 1 !point is fixed
END IF
ELSE ! segment in previous step was in other segment
n1o= lcseg(1,onear) !nodes defining previous master segment
n2o= lcseg(2,onear)
ro = 1d0-so !previous r coord.
!vector between actual and onset point
ts= r *x(:,n1) + s *x(:,n2) -ro*x(:,n1o) -so*x(:,n2o)
CALL vecuni(2,t1,lengt) ! side length
auxil = DOT_PRODUCT(ts,vns(:,1)) ! projects vector over normal
ts = ts - auxil*vns(:,1) ! orthogonal projection
CALL vecuni(2,ts,tslip) ! ts = unit vector, tslip = total slip
frict = pnltc*tslip ! friction force
IF(frict > fricm) THEN ! compare with maximum friction force
! IF friction force > maximum friction force ==> slip
eslip = fricm/pnltc ! maximum relative slip
frict = fricm ! assign maximum friction force
pslip = tslip - eslip
issdb(3) = 2 !remember that point is sliding
ELSE
eslip = tslip ! all tslip is elastic
issdb(3) = 1 !point is fixed
END IF !maximum tangential force exceded
auxil = DOT_PRODUCT(t1,ts)*eslip/lengt ! slip Ds coordinate
rssdb(1) = s - auxil ! store onset natural coordinate
END IF !same or different segment
IF( cursl .AND. indco /= 1 .AND. frict /= 0d0)THEN
auxil = DOT_PRODUCT(ts,vns(:,1))
ts = ts - auxil*vns(:,1)
ts = ts/SQRT(DOT_PRODUCT(ts,ts))
END IF
IF( indco == 0 .OR. indco == 2) THEN !forces in both surfaces or master
vns(1:2,1) = -ts(1:2) ! slave node
vns(1:2,2) = r*ts(1:2) ! master nodes
vns(1:2,3) = s*ts(1:2)
eresf = eresf + frict*vns ! add to normal forces
ELSE IF( indco == 1 )THEN ! forces in slave surface only
eresf(1:2,1) = eresf(1:2,1) - frict*ts(1:2) ! add to normal forces
END IF
IF ( pslip /= 0d0 ) pslip = ABS(frict*pslip*xfact)
END IF !projection in previous step
issdb(2) = nearn !store actual segment
END IF !if friction
! add to total forces if required
surtf = surtf - eresf(1:2,1)*xfact*dtime
IF( press ) prdat(1) = pgap*xfact*dtime
! Add forces into global contact forces
IF(indco == 0 .OR. indco == 1) & !forces on SLAVE
fcont(1:2,isn) = fcont(1:2,isn) - eresf(1:2,1)*xfact
IF(indco == 0 .OR. indco == 2)THEN !forces on MASTER
DO n=1,2 !for each node
node = lcseg(n,nearn) !global number
fcont(1:2,node) = fcont(1:2,node) - eresf(1:2,1+n)*xfact
END DO
END IF
IF( wear .AND. issdb(3) == 2 )THEN
wwear(isn) = wwear(isn) + pslip
node = lcseg(1,nearn) !global number
wwear(node) = wwear(node) + pslip*r
node = lcseg(2,nearn) !global number
wwear(node) = wwear(node) + pslip*s
END IF
! thermal part
IF (therm) THEN
! USE npo_db, ONLY : iftmp,tempe,tresi
! USE ctrl_db, ONLY : therm
n = iftmp(sldof,isn) ! thermal dof on slave
n1o = iftmp(mtdof,n1) ! thermal dof on master
n2o = iftmp(mtdof,n2) ! thermal dof on master
! CONDUCTION
IF( cprop(7) > 0d0 )THEN
fc = pgap * area(icnod) ! force/associated area
to = cprop(7)*(fc/cprop(9))**cprop(8) ! convection coefficient
so = tempe(sldof,isn) ! temperature on slave surface
ro = tempe(mtdof,n1)*r + tempe(mtdof,n2)*s !master
dt = (so - ro)*to ! thermal gap * h
IF( n > 0 ) tresi(n) = tresi(n) + dt
IF(n1o > 0) tresi(n1o) = tresi(n1o) - r*dt
IF(n2o > 0) tresi(n2o) = tresi(n2o) - s*dt
END IF
! FRICTION WORK
IF( issdb(3) == 2 )THEN
pslip = pslip/td !friction power
IF( n > 0 ) tresi(n) = tresi(n) - pslip*cprop(10)
pslip = pslip*(1d0-cprop(10))
IF(n1o > 0) tresi(n1o) = tresi(n1o) - pslip*r
IF(n2o > 0) tresi(n2o) = tresi(n2o) - pslip*s
END IF
END IF
RETURN
9999 CALL runen2('')
END SUBROUTINE force2
| [
"jerebntz@gmail.com"
] | jerebntz@gmail.com |
7ef5f19af5de476a131ec40a751fd842938527f1 | 3d80d68564da1f1d650988a1fafe221d749cdc31 | /tools/kopt/rebuild.cpp | 5b7b82e6489fcc03432591e787d30466bde4232b | [
"NCSA"
] | permissive | heyitsanthony/klee-mc | ede73456fa0e928e67529ae19ae4723d483acfd3 | 184a809930c4f7823526a11474b1446dd7d92afb | refs/heads/master | 2020-05-30T03:18:24.188711 | 2016-05-29T09:16:42 | 2016-05-29T09:16:42 | 189,500,579 | 6 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,025 | cpp | #include <unistd.h>
#include <iostream>
#include <sstream>
#include "../../lib/Expr/ExprRule.h"
#include "../../lib/Expr/RuleBuilder.h"
#include "static/Sugar.h"
#include "klee/ExprBuilder.h"
#include "klee/Solver.h"
#include "klee/util/ExprUtil.h"
using namespace klee;
extern int WorkerForks;
extern ExprBuilder::BuilderKind BuilderKind;
extern bool checkRule(const ExprRule* er, Solver* s, std::ostream&);
static ExprRule* rebuildBRule(
Solver *s,
const ExprRule* er,
std::ostream& of)
{
std::stringstream ss;
ExprRule *er_rebuild;
if (checkRule(er, s, std::cout) == false) {
std::cerr << "BAD RULE:\n";
er->print(std::cerr);
return NULL;
}
er->printBinaryRule(ss);
er_rebuild = ExprRule::loadBinaryRule(ss);
/* ensure we haven't corrupted the from-expr--
* otherwise, it might not match during runtime! */
if ( ExprUtil::getNumNodes(er_rebuild->getFromExpr()) !=
ExprUtil::getNumNodes(er->getFromExpr()))
{
std::cerr << "BAD REBUILD:\n";
std::cerr << "ORIGINAL:\n";
er->print(std::cerr);
std::cerr << "NEW:\n";
er_rebuild->print(std::cerr);
std::cerr << "ORIG-EXPR: "
<< er->getFromExpr() << '\n'
<< "NEW-EXPR: "
<< er_rebuild->getFromExpr() << '\n';
delete er_rebuild;
return NULL;
}
return er_rebuild;
}
#if 0
static void rebuildBRulesFork(Solver* s, const std::string& Input)
{
for (unsigned ai = 0; i < WorkerForks; i++) {
fork()
}
}
#endif
void rebuildBRules(Solver* s, const std::string& Input)
{
std::ofstream of(Input.c_str());
ExprRuleSet ers;
RuleBuilder *rb;
unsigned i;
assert (of.good() && !of.fail());
rb = RuleBuilder::create(ExprBuilder::create(BuilderKind));
i = 0;
for (const auto er : *rb) {
ExprRule* er_rebuild;
std::cerr << "[" << ++i << "]: ";
er_rebuild = rebuildBRule(s, er, of);
if (er_rebuild == NULL)
continue;
/* only emit if hasn't seen rule before */
if (!ers.count(er_rebuild)) {
er_rebuild->printBinaryRule(of);
ers.insert(er_rebuild);
} else
delete er_rebuild;
}
delete rb;
}
| [
"chz@bingularity.org"
] | chz@bingularity.org |
03872c6e47dcd81a240794bf63af490e65680d9d | fe968c73247549533ea2e8c0ffd7893d62f35d78 | /CPP04/ex00/Sorcerer.cpp | d9d19635d17c1c1eebbc79d155edca5f16445d92 | [] | no_license | danil2283376/CPP-Modules | 02b05b50f29da4e06307904ef0f272dffd9941ae | 09e2cd0e3816920392521be8f70aba7045c844ce | refs/heads/master | 2023-06-06T07:31:36.435561 | 2021-06-20T07:52:50 | 2021-06-20T07:52:50 | 370,025,927 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 681 | cpp | #include "Sorcerer.hpp"
Sorcerer::Sorcerer(std::string name, std::string title)
{
this->name = name;
this->title = title;
std::cout << name << ", " << title << ", " << "is born!\n";
}
Sorcerer::~Sorcerer()
{
std::cout << name << ", " << title << ", " << "is dead.\n";
}
std::string Sorcerer::GetName()
{
return (this->name);
}
std::string Sorcerer::GetTitle()
{
return (this->title);
}
void Sorcerer::polymorph(Victim const ©) const
{
copy.getPolymorphed();
}
std::ostream &operator<<(std::ostream &fout, Sorcerer ©)
{
fout << "I am " << copy.GetName() << ", " << copy.GetTitle() << ", " << "and i like ponies!\n";
return (fout);
} | [
"scolen@student.21-school.ru"
] | scolen@student.21-school.ru |
dffa34fc53ba8cbd5aa0d557f14687cddb434eb0 | 7b382c6ee032d1ecd4618baf317f3f91d0ab52c2 | /Misc_set/xor/kequal_subset_sum+partition.cpp | 5c90d2b8683647e800635f596b70028ee22c270b | [] | no_license | shubhampathak09/codejam | 3a632cc67a3f81945f2b452eaf7807c0c8ef90bf | 2f497cfdb9d318dd6482236f93c5e14234bea613 | refs/heads/master | 2021-06-29T03:54:44.785611 | 2020-12-29T11:51:09 | 2020-12-29T11:51:09 | 147,506,585 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 696 | cpp | // k equal subset sum partition
#include<bits/stdc++.h>
using namespace std;
bool subsetsum(int a[],int n,int sum)
{
int dp[n+1][sum+1];
for(int i=0;i<=sum;i++)
dp[0][i]=0;
for(int i=0;i<=n;i++)
dp[i][0]=1;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=sum;j++)
{
if(a[i-1]<=j)
{
dp[i][j]=dp[i-1][j-a[i-1]]||dp[i-1][j];
}
else
dp[i][j]=dp[i-1][j];
}
}
return dp[n][sum];
}
bool kequalsubset(int a[],int n,int k)
{
int sum=0;
for(int i=0;i<n;i++)
sum+=a[i];
if(sum%k!=0)
return false;
else
return subsetsum(a,n,sum/k);
}
int main()
{
int a[]={4,3,2,3,5,2,1};
int n=sizeof(a)/sizeof(a[0]);
int k=4;
cout<<kequalsubset(a,n,k);
}
| [
"shubham.pathak@rediffmail.com"
] | shubham.pathak@rediffmail.com |
a8bf80ab304c842e52760f4859d615cdc9f56648 | b10b50b69566a306b4f7ca422eed0e145f52c3b8 | /client.cc | d429abbae6e5adbc4bdb69f86778d5ba1608911c | [
"Apache-2.0"
] | permissive | avinashnarsale/Eventually-Consistent-Key-Value-Store | 7a14bf1abedfeb8b27e42a560367ff008f237ba1 | 6d887371143d50e0618cc1d8c0822756ae681e2c | refs/heads/master | 2021-04-26T23:23:55.984614 | 2018-03-05T22:30:26 | 2018-03-05T22:30:26 | 123,986,407 | 5 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 9,278 | cc | #include <iostream>
#include <fstream>
#include <string>
#include <mutex>
#include <stdio.h>
#include <sys/types.h>
#include <pthread.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/stat.h>
#include <dirent.h>
#include <netdb.h>
#include <sstream>
#include <algorithm>
#include <ifaddrs.h>
#include <time.h>
#include <ctime>
#include <list>
#include <thread>
#include <chrono>
#include <random>
#include "map.pb.h"
using namespace std;
MapMessage map_message;
map<pair<string,int>,int> server_list;
int coOrdinator_port = 0;
int receiving_port=0;
string receiving_ip;
string coOrdinator_ip;
void receiverFromServers(){
struct sockaddr_in socket_address;
memset(&socket_address, '0', sizeof(socket_address));
int server_ds, my_socket, read_count, sock1;
socklen_t address_len = sizeof(socket_address);
int option=1;
char socket_buffer[1024] = {0};
//cout << "Check Point 1.1" << endl;
if ((server_ds = socket(AF_INET, SOCK_STREAM, 0)) <= 0){
cerr << "ERROR: failed in creating socket" << endl;
exit(EXIT_FAILURE);
}
if (setsockopt(server_ds, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &option, sizeof(option))) {
cerr << "ERROR: failed setsockopt" << endl;
exit(EXIT_FAILURE);
}
socket_address.sin_family = AF_INET;
socket_address.sin_addr.s_addr = INADDR_ANY;
socket_address.sin_port = htons(receiving_port); //htons(8080);
//cout << "Check Point 1.2" << endl;
if (bind(server_ds, (struct sockaddr *)&socket_address, sizeof(socket_address))<0) {
cerr << "ERROR: binding failed" << endl;
exit(EXIT_FAILURE);
}
if (listen(server_ds, 20) < 0) {
cerr << "ERROR: failed at listen" << endl;
exit(EXIT_FAILURE);
}
while(1)
{
if ((my_socket = accept(server_ds, (struct sockaddr *)&socket_address, (socklen_t*)&address_len))<0) {
cerr << "ERROR: failed to accept" << endl;
exit(EXIT_FAILURE);
}
//cout << "Client waiting for return data...." << endl;
read_count=read(my_socket, socket_buffer, 1024);
socket_buffer[read_count] = '\0';
if(read_count<0){
cerr << "ERROR: In reading buffer." << endl;
exit(EXIT_FAILURE);
}else{
MapMessage return_message;
return_message.ParseFromString(socket_buffer);
if(return_message.has_map_metadata()){
cout << "\nKey: " << return_message.map_metadata().key();
cout << " Value: " << return_message.map_metadata().value();
cout << " Timestamp: " << return_message.map_metadata().timestamp() << endl;
}else{
cout << "\nReply::" << socket_buffer << endl;
}
}
close(my_socket);
}
}
void writeRequest(){
int input_key, input_wLevel;
string input_value;
cout << "Enter Key: ";
cin >> input_key;
if(input_key<0 || input_key > 255){
cout << "Invalid key, enter within range - (Unsigned 0-255):";
cin >> input_key;
}
if(input_key<0 || input_key > 255){
cout << "Invalid again, exiting client.." << endl;
exit(EXIT_FAILURE);
}
cin.ignore (std::numeric_limits<std::streamsize>::max(), '\n');
cout << "Enter value: ";
getline(cin, input_value);
cout << "Enter consistency level: ";
cin >> input_wLevel;
if(input_wLevel<=0){
cout << "Invalid consistency level, enter again:";
cin >> input_wLevel;
}
if(input_wLevel<=0){
cout << "Invalid again, exiting client.." << endl;
exit(EXIT_FAILURE);
}
MapStoreWrite map_data;
map_data.set_key(input_key);
map_data.set_value(input_value);
map_data.set_write_level(input_wLevel);
map_data.set_client_port(receiving_port);
map_data.set_client_ip(receiving_ip);
string output;
map_message.set_allocated_map_write(&map_data);
if (!map_message.SerializeToString(&output)) {
cerr << "ERROR: Failed to write map_data message." << endl;
exit(EXIT_FAILURE);
}
map_message.release_map_write();
struct sockaddr_in address;
int sock = 0, valread;
struct sockaddr_in serv_addr;
char buffer[1024] = {0};
memset(&serv_addr, '0', sizeof(serv_addr));
if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){
cerr << "ERROR: Socket creation error." << endl;
exit(EXIT_FAILURE);
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(coOrdinator_port);
// Convert IPv4 and IPv6 addresses from text to binary form
if(inet_pton(AF_INET, coOrdinator_ip.c_str(), &serv_addr.sin_addr)<=0) {
cerr << "ERROR: Invalid address/ Address not supported." << endl;
exit(EXIT_FAILURE);
}
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0){
cerr << "ERROR: Connection Failed." << endl;
exit(EXIT_FAILURE);
}
send(sock, output.c_str() , output.size(), 0);
cout << "Message sent to server: " << coOrdinator_port << " added successfully. " << endl;
close(sock);
}
void readRequest(){
int input_key, input_rLevel;
string output_value,output_timestamp;
cout << "Enter Key: ";
cin >> input_key;
if(input_key<0 || input_key > 255){
cout << "Invalid key, enter within range - (Unsigned 0-255):";
cin >> input_key;
}
if(input_key<0 || input_key > 255){
cout << "Invalid again, exiting client.." << endl;
exit(EXIT_FAILURE);
}
cout << "Enter consistency level: ";
cin >> input_rLevel;
if(input_rLevel<=0){
cout << "Invalid consistency level, enter again:";
cin >> input_rLevel;
}
if(input_rLevel<=0){
cout << "Invalid again, exiting client.." << endl;
exit(EXIT_FAILURE);
}
MapStoreRead map_data;
map_data.set_key(input_key);
map_data.set_read_level(input_rLevel);
map_data.set_client_port(receiving_port);
map_data.set_client_ip(receiving_ip);
string output;
map_message.set_allocated_map_read(&map_data);
if (!map_message.SerializeToString(&output)) {
cerr << "ERROR: Failed to read map_data message." << endl;
exit(EXIT_FAILURE);
}
map_message.release_map_read();
struct sockaddr_in address;
int sock = 0, valread;
struct sockaddr_in serv_addr;
char buffer[1024] = {0};
memset(&serv_addr, '0', sizeof(serv_addr));
if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){
cerr << "ERROR: Socket creation error." << endl;
exit(EXIT_FAILURE);
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(coOrdinator_port);
// Convert IPv4 and IPv6 addresses from text to binary form
if(inet_pton(AF_INET, coOrdinator_ip.c_str(), &serv_addr.sin_addr)<=0) {
cerr << "ERROR: Invalid address/ Address not supported." << endl;
exit(EXIT_FAILURE);
}
if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0){
cerr << "ERROR: Connection Failed." << endl;
exit(EXIT_FAILURE);
}
send(sock, output.c_str() , output.size(), 0);
cout << "Request sent to server: " << coOrdinator_port << " added successfully. " << endl;
close(sock);
}
int main(int argc, char* argv[]) {
GOOGLE_PROTOBUF_VERIFY_VERSION;
if (argc != 3) {
cerr << "Usage: " << argv[0] << "./client <receive_port> <server_list_file>" << endl;
return -1;
}
receiving_port=atoi(argv[1]);
struct ifaddrs *addrs, *tmp;
if (getifaddrs(&addrs) == -1) {
cerr << "ifaddrs is not set properly.. issue with environment setup!" << endl;
exit(EXIT_FAILURE);
}
tmp = addrs;
string eth0="eth0";
while (tmp){
if (tmp->ifa_addr && tmp->ifa_addr->sa_family == AF_INET){
struct sockaddr_in *pAddr = (struct sockaddr_in *)tmp->ifa_addr;
if(eth0.compare(string(tmp->ifa_name))==0){
receiving_ip=inet_ntoa(pAddr->sin_addr);
}
}
tmp = tmp->ifa_next;
}
freeifaddrs(addrs);
ifstream infile(argv[2]);
string line;
int number_of_servers=0;
while (getline(infile, line))
{
number_of_servers++;
istringstream iss(line);
string server_ip, server_port;
if (!(iss >> server_ip >> server_port)) { break; }
server_list.insert(make_pair(make_pair(server_ip,atoi(server_port.c_str())),number_of_servers));
}
infile.close();
int temp_counter=0;
for(auto itr=server_list.begin();itr!=server_list.end();++itr){
temp_counter++;
cout << temp_counter << ". => Port: "<< itr->first.second << " IP: " << itr->first.first << endl;
}
int select_server;
cout << "Enter server number to select as CoOrdinator: ";
cin >> select_server;
temp_counter=0;
for(auto itr=server_list.begin();itr!=server_list.end();++itr){
temp_counter++;
if(select_server==temp_counter){
coOrdinator_ip=itr->first.first;
coOrdinator_port=itr->first.second;
}
}
// start thread for receiving replpies from Co-Ordinator/s
thread receive_Thread(receiverFromServers);
int select;
while(1){
cout << "---------->Menu<----------" << endl;
cout << "1. Write \n2. Read \n3. Exit" << endl;
cout << "Enter operation choice: ";
cin >> select;
if(select==3){
cout << "Ending client..." << endl;
exit(EXIT_SUCCESS);
break;
}
switch(select){
case 1:
writeRequest();
break;
case 2:
readRequest();
break;
default:
cout << "Enter valid choice. " << endl;
break;
}
}
// Optional: Delete all global objects allocated by libprotobuf.
google::protobuf::ShutdownProtobufLibrary();
receive_Thread.join();
return 0;
}
| [
"noreply@github.com"
] | noreply@github.com |
4d13eaad7a8770949d80df0d84910aa0fa61d77b | abd31a789798fb251ad278f9139fc646b1f0e138 | /pc_SDK/ClientDemo-1/include/utils/HKRTSBuffer.h | 5b2ee40df11d4df7edf7667205816f3d1003e642 | [] | no_license | jameshilliard/pcSCCSDK140920 | caff45b611ae429164746c0d4cacbf15b193ab77 | 5d5372ca210303dd929277b1c27e7ddd56dbac63 | refs/heads/master | 2021-04-29T10:19:24.278679 | 2016-12-29T22:59:06 | 2016-12-29T22:59:06 | 77,644,893 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 786 | h | #pragma once
#include "RTSHead.h"
class AFX_EXT_CLASS HKRTSBuffer
{
public:
HKRTSBuffer( unsigned short nLevel,RTSHead &rtsHead,char *pData,unsigned short nLen,bool bBlock );
HKRTSBuffer( unsigned short nLevel,char *pData,unsigned short nLen,bool bBlock );
virtual ~HKRTSBuffer();
char *GetRTSBuffer()
{
return m_pDataBuf;
}
unsigned short GetRTSLevel()
{
return m_nLevel;
}
unsigned short GetRTSBufferSize()
{
return m_nLen;
}
RTSHead &GetRTSHead()
{
return m_rtsHead;
}
bool IsBlock()
{
return m_bBlock;
}
unsigned short GetType()
{
return m_nType;
}
private:
unsigned short m_nLevel;
unsigned short m_nType;
bool m_bBlock;
RTSHead m_rtsHead;
unsigned short m_nLen;
char *m_pDataBuf;
}; | [
"james.hilliard1@gmail.com"
] | james.hilliard1@gmail.com |
5ea14c081590fe53ee3150e78a21fdd81768d83c | 6c3f7244babe0a5792c9ad6608cff4843f247deb | /ejercicios/31/evolve.cpp | 8a439f84d5844a16cd6e3518b5a063ff4fa17b24 | [] | no_license | jsvillalbat/FISI2028-201920 | 0d38d31e8a046c0213af4d634018c0f4c2aa86e3 | 8b7402a12cadf89cb64afa3cd3bd63258a952de2 | refs/heads/master | 2022-03-21T20:01:22.208965 | 2019-12-14T16:18:23 | 2019-12-14T16:18:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,918 | cpp | #include <iostream>
#include <fstream>
#include <cmath>
#include "stdio.h"
void init(double *psi, int n_x);
void print(double *psi, int n_x);
void copy(double *recibe, double *entrega, int n_x);
void evolve(double *psi_new, double *psi_old, double delta_t, double delta_x, int n_x);
double difference(double *psi_new, double *psi_old, int n_x);
int main(int argc, char **argv){
double *psi = NULL;
double *psi_past = NULL;
int n_x;
int n_t=0;
double delta_x ;
double delta_t ;
double diff=1.0;
n_x=atoi(argv[1]);
delta_x = 2.0/(n_x-1);
delta_t = 0.5 * delta_x * delta_x;
psi = new double [n_x];
psi_past = new double [n_x];
init(psi, n_x);
while(diff > 1E-6){
copy(psi_past, psi, n_x);
evolve(psi, psi_past, delta_t, delta_x, n_x);
diff = difference(psi, psi_past, n_x);
n_t += 1;
}
std::cout << n_x << " " << n_t << " " << std::abs(psi[n_x/2]+0.5)/0.5 << " "<< diff << std::endl;
return 0;
}
double difference(double *psi_new, double *psi_old, int n_x){
int i;
double max_psi=0;
double delta_psi=0;
for(i=0;i<n_x;i++){
if(std::abs(psi_new[i] - psi_old[i])>delta_psi){
delta_psi = std::abs(psi_new[i] - psi_old[i]);
max_psi = std::abs(psi_old[i]);
}
}
return delta_psi/max_psi;
}
void evolve(double *psi_new, double *psi_old, double delta_t, double delta_x, int n_x){
int i;
double s=-1.0;
for(i=1;i<n_x-1;i++){
psi_new[i] = psi_old[i];
psi_new[i] += (delta_t/(delta_x * delta_x)) * (psi_old[i+1]-2*psi_old[i] + psi_old[i-1]);
psi_new[i] += delta_t * s;
}
}
void copy(double *recibe, double *entrega, int n_x){
int i;
for (i=0;i<n_x;i++){
recibe[i] = entrega[i];
}
}
void init(double *psi, int n_x){
int i;
for(i=0;i<n_x;i++){
psi[i] = 0.0;
}
}
void print(double *psi, int n_x){
int i;
for(i=0;i<n_x;i++){
std::cout << psi[i] << " ";
}
std::cout << "\n";
}
| [
"j.e.forero.romero@gmail.com"
] | j.e.forero.romero@gmail.com |
da09ec1068c98d8e43859fa960ff9d303834f94e | 1e07d601e6fd3a9f38636d4f209b9f9a1a00d5bd | /TESTs/bmp180demo/bmp180demo.ino | 917fea42c3495fb1f01dde3ae60c7c270d65d0d4 | [] | no_license | tockn/myArduinoProjects | b8d73a824c44b4e4578eaf640831d529284ce10c | a2a0ee54e8135624b207a35912a2bf56a3c0766b | refs/heads/master | 2020-03-20T05:10:31.446567 | 2018-06-19T12:53:34 | 2018-06-19T12:53:34 | 137,205,774 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 170 | ino | #include "BMP180_tockn.h"
BMP180 bmp;
void setup() {
Serial.begin(9600);
bmp.begin(26, 25);
}
void loop() {
bmp.update();
Serial.println(bmp.getAltitude());
}
| [
"takuto.sato.5g@stu.hosei.ac.jp"
] | takuto.sato.5g@stu.hosei.ac.jp |
35adb96ebb4e436da4ef160013a5df270963c3c4 | 0400ac52a20058bf13a064b838872473212765ca | /Unity_Code/DinoRun_Final/Temp/il2cppOutput/il2cppOutput/Il2CppCompilerCalculateTypeValues_5Table.cpp | a09e15c0d583a2eab3cde45de79f405e62de9b97 | [
"Apache-2.0"
] | permissive | BPenzar/SuperDinoBros. | b7e6be07bfc4278d85eeb986f4740c9a91e01689 | f46b866c5a1119c6753dbd8e963212f17a4a31d5 | refs/heads/master | 2021-01-20T04:29:24.503356 | 2017-07-25T14:58:12 | 2017-07-25T14:58:12 | 89,697,299 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 40,905 | cpp | #include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <cstring>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include "class-internals.h"
#include "codegen/il2cpp-codegen.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_MethodC1516131009.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_MethodD1742974787.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_MethodDi492828146.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_MethodRe981009581.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_MonoMeth771543475.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_Remotin3248446683.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_ObjRefS3912784830.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_Remotin2821375126.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_ReturnM3411975905.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_ServerC1054294306.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_ServerO4261369100.h"
#include "mscorlib_System_Runtime_Remoting_Messaging_StackBu1613771438.h"
#include "mscorlib_System_Runtime_Remoting_Metadata_SoapAttr1982224933.h"
#include "mscorlib_System_Runtime_Remoting_Metadata_SoapFiel3073759685.h"
#include "mscorlib_System_Runtime_Remoting_Metadata_SoapMeth2381910676.h"
#include "mscorlib_System_Runtime_Remoting_Metadata_SoapPara2780084514.h"
#include "mscorlib_System_Runtime_Remoting_Metadata_SoapType3444503085.h"
#include "mscorlib_System_Runtime_Remoting_Proxies_ProxyAttr4031752430.h"
#include "mscorlib_System_Runtime_Remoting_Proxies_Transpare3836393972.h"
#include "mscorlib_System_Runtime_Remoting_Proxies_RealProxy298428346.h"
#include "mscorlib_System_Runtime_Remoting_Proxies_RemotingP2419155897.h"
#include "mscorlib_System_Runtime_Remoting_Services_Tracking3722365321.h"
#include "mscorlib_System_Runtime_Remoting_ActivatedClientTy4060499430.h"
#include "mscorlib_System_Runtime_Remoting_ActivatedServiceT3934090848.h"
#include "mscorlib_System_Runtime_Remoting_EnvoyInfo815109115.h"
#include "mscorlib_System_Runtime_Remoting_Identity3647548000.h"
#include "mscorlib_System_Runtime_Remoting_ClientIdentity2254682501.h"
#include "mscorlib_System_Runtime_Remoting_InternalRemotingS3953136710.h"
#include "mscorlib_System_Runtime_Remoting_ObjRef318414488.h"
#include "mscorlib_System_Runtime_Remoting_RemotingConfigurat438177651.h"
#include "mscorlib_System_Runtime_Remoting_ConfigHandler2180714860.h"
#include "mscorlib_System_Runtime_Remoting_ChannelData1489610737.h"
#include "mscorlib_System_Runtime_Remoting_ProviderData2518653487.h"
#include "mscorlib_System_Runtime_Remoting_FormatterData12176916.h"
#include "mscorlib_System_Runtime_Remoting_RemotingException109604560.h"
#include "mscorlib_System_Runtime_Remoting_RemotingServices2399536837.h"
#include "mscorlib_System_Runtime_Remoting_ServerIdentity1656058977.h"
#include "mscorlib_System_Runtime_Remoting_ClientActivatedId1467784146.h"
#include "mscorlib_System_Runtime_Remoting_SingletonIdentity164722255.h"
#include "mscorlib_System_Runtime_Remoting_SingleCallIdentit3377680076.h"
#include "mscorlib_System_Runtime_Remoting_SoapServices3397513225.h"
#include "mscorlib_System_Runtime_Remoting_SoapServices_TypeIn59877052.h"
#include "mscorlib_System_Runtime_Remoting_TypeEntry3321373506.h"
#include "mscorlib_System_Runtime_Remoting_TypeInfo942537562.h"
#include "mscorlib_System_Runtime_Remoting_WellKnownClientTy3314744170.h"
#include "mscorlib_System_Runtime_Remoting_WellKnownObjectMo2630225581.h"
#include "mscorlib_System_Runtime_Remoting_WellKnownServiceT1712728956.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_B2351345412.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_B2209278355.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_Bi141209596.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_B3869872702.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_Bi419818242.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_B1866979105.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_B4119335253.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_B1476095226.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_B3000156221.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_B3123371156.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_Fo999493661.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_Fo943306207.h"
#include "mscorlib_System_Runtime_Serialization_Formatters_T1182459634.h"
#include "mscorlib_System_Runtime_Serialization_FormatterConv764140214.h"
#include "mscorlib_System_Runtime_Serialization_FormatterSer3161112612.h"
#include "mscorlib_System_Runtime_Serialization_ObjectManage2645893724.h"
#include "mscorlib_System_Runtime_Serialization_BaseFixupRec3171032996.h"
#include "mscorlib_System_Runtime_Serialization_ArrayFixupRe1994227600.h"
#include "mscorlib_System_Runtime_Serialization_MultiArrayFix691510385.h"
#include "mscorlib_System_Runtime_Serialization_FixupRecord1044204179.h"
#include "mscorlib_System_Runtime_Serialization_DelayedFixup1033808295.h"
#include "mscorlib_System_Runtime_Serialization_ObjectRecord1923758778.h"
#include "mscorlib_System_Runtime_Serialization_ObjectRecord4134110382.h"
#include "mscorlib_System_Runtime_Serialization_OnDeserializ3172265744.h"
#include "mscorlib_System_Runtime_Serialization_OnDeserializi484921187.h"
#include "mscorlib_System_Runtime_Serialization_OnSerialized3742956097.h"
#include "mscorlib_System_Runtime_Serialization_OnSerializin2011372116.h"
#include "mscorlib_System_Runtime_Serialization_Serializatio3985864818.h"
#include "mscorlib_System_Runtime_Serialization_Serializatio2797915342.h"
#include "mscorlib_System_Runtime_Serialization_Serialization362827733.h"
#include "mscorlib_System_Runtime_Serialization_Serializatio3485203212.h"
#include "mscorlib_System_Runtime_Serialization_Serialization753258759.h"
#include "mscorlib_System_Runtime_Serialization_Serialization228987430.h"
#include "mscorlib_System_Runtime_Serialization_Serialization589103770.h"
#include "mscorlib_System_Runtime_Serialization_StreamingCon1417235061.h"
#include "mscorlib_System_Runtime_Serialization_StreamingCon4264247603.h"
#include "mscorlib_System_Security_Cryptography_X509Certifica283079845.h"
#include "mscorlib_System_Security_Cryptography_X509Certific1216946873.h"
#include "mscorlib_System_Security_Cryptography_AsymmetricAlg784058677.h"
#include "mscorlib_System_Security_Cryptography_AsymmetricKe3339648384.h"
#include "mscorlib_System_Security_Cryptography_AsymmetricSi3580832979.h"
#include "mscorlib_System_Security_Cryptography_AsymmetricSi4058014248.h"
#include "mscorlib_System_Security_Cryptography_Base64Consta4112722312.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize500 = { sizeof (MethodCallDictionary_t1516131009), -1, sizeof(MethodCallDictionary_t1516131009_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable500[1] =
{
MethodCallDictionary_t1516131009_StaticFields::get_offset_of_InternalKeys_6(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize501 = { sizeof (MethodDictionary_t1742974787), -1, sizeof(MethodDictionary_t1742974787_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable501[6] =
{
MethodDictionary_t1742974787::get_offset_of__internalProperties_0(),
MethodDictionary_t1742974787::get_offset_of__message_1(),
MethodDictionary_t1742974787::get_offset_of__methodKeys_2(),
MethodDictionary_t1742974787::get_offset_of__ownProperties_3(),
MethodDictionary_t1742974787_StaticFields::get_offset_of_U3CU3Ef__switchU24map21_4(),
MethodDictionary_t1742974787_StaticFields::get_offset_of_U3CU3Ef__switchU24map22_5(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize502 = { sizeof (DictionaryEnumerator_t492828146), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable502[3] =
{
DictionaryEnumerator_t492828146::get_offset_of__methodDictionary_0(),
DictionaryEnumerator_t492828146::get_offset_of__hashtableEnum_1(),
DictionaryEnumerator_t492828146::get_offset_of__posMethod_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize503 = { sizeof (MethodReturnDictionary_t981009581), -1, sizeof(MethodReturnDictionary_t981009581_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable503[2] =
{
MethodReturnDictionary_t981009581_StaticFields::get_offset_of_InternalReturnKeys_6(),
MethodReturnDictionary_t981009581_StaticFields::get_offset_of_InternalExceptionKeys_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize504 = { sizeof (MonoMethodMessage_t771543475), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable504[8] =
{
MonoMethodMessage_t771543475::get_offset_of_method_0(),
MonoMethodMessage_t771543475::get_offset_of_args_1(),
MonoMethodMessage_t771543475::get_offset_of_arg_types_2(),
MonoMethodMessage_t771543475::get_offset_of_ctx_3(),
MonoMethodMessage_t771543475::get_offset_of_rval_4(),
MonoMethodMessage_t771543475::get_offset_of_exc_5(),
MonoMethodMessage_t771543475::get_offset_of_uri_6(),
MonoMethodMessage_t771543475::get_offset_of_methodSignature_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize505 = { sizeof (RemotingSurrogate_t3248446683), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize506 = { sizeof (ObjRefSurrogate_t3912784830), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize507 = { sizeof (RemotingSurrogateSelector_t2821375126), -1, sizeof(RemotingSurrogateSelector_t2821375126_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable507[4] =
{
RemotingSurrogateSelector_t2821375126_StaticFields::get_offset_of_s_cachedTypeObjRef_0(),
RemotingSurrogateSelector_t2821375126_StaticFields::get_offset_of__objRefSurrogate_1(),
RemotingSurrogateSelector_t2821375126_StaticFields::get_offset_of__objRemotingSurrogate_2(),
RemotingSurrogateSelector_t2821375126::get_offset_of__next_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize508 = { sizeof (ReturnMessage_t3411975905), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable508[13] =
{
ReturnMessage_t3411975905::get_offset_of__outArgs_0(),
ReturnMessage_t3411975905::get_offset_of__args_1(),
ReturnMessage_t3411975905::get_offset_of__outArgsCount_2(),
ReturnMessage_t3411975905::get_offset_of__callCtx_3(),
ReturnMessage_t3411975905::get_offset_of__returnValue_4(),
ReturnMessage_t3411975905::get_offset_of__uri_5(),
ReturnMessage_t3411975905::get_offset_of__exception_6(),
ReturnMessage_t3411975905::get_offset_of__methodBase_7(),
ReturnMessage_t3411975905::get_offset_of__methodName_8(),
ReturnMessage_t3411975905::get_offset_of__methodSignature_9(),
ReturnMessage_t3411975905::get_offset_of__typeName_10(),
ReturnMessage_t3411975905::get_offset_of__properties_11(),
ReturnMessage_t3411975905::get_offset_of__inArgInfo_12(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize509 = { sizeof (ServerContextTerminatorSink_t1054294306), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize510 = { sizeof (ServerObjectTerminatorSink_t4261369100), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable510[1] =
{
ServerObjectTerminatorSink_t4261369100::get_offset_of__nextSink_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize511 = { sizeof (StackBuilderSink_t1613771438), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable511[2] =
{
StackBuilderSink_t1613771438::get_offset_of__target_0(),
StackBuilderSink_t1613771438::get_offset_of__rp_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize512 = { sizeof (SoapAttribute_t1982224933), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable512[3] =
{
SoapAttribute_t1982224933::get_offset_of__useAttribute_0(),
SoapAttribute_t1982224933::get_offset_of_ProtXmlNamespace_1(),
SoapAttribute_t1982224933::get_offset_of_ReflectInfo_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize513 = { sizeof (SoapFieldAttribute_t3073759685), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable513[2] =
{
SoapFieldAttribute_t3073759685::get_offset_of__elementName_3(),
SoapFieldAttribute_t3073759685::get_offset_of__isElement_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize514 = { sizeof (SoapMethodAttribute_t2381910676), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable514[6] =
{
SoapMethodAttribute_t2381910676::get_offset_of__responseElement_3(),
SoapMethodAttribute_t2381910676::get_offset_of__responseNamespace_4(),
SoapMethodAttribute_t2381910676::get_offset_of__returnElement_5(),
SoapMethodAttribute_t2381910676::get_offset_of__soapAction_6(),
SoapMethodAttribute_t2381910676::get_offset_of__useAttribute_7(),
SoapMethodAttribute_t2381910676::get_offset_of__namespace_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize515 = { sizeof (SoapParameterAttribute_t2780084514), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize516 = { sizeof (SoapTypeAttribute_t3444503085), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable516[7] =
{
SoapTypeAttribute_t3444503085::get_offset_of__useAttribute_3(),
SoapTypeAttribute_t3444503085::get_offset_of__xmlElementName_4(),
SoapTypeAttribute_t3444503085::get_offset_of__xmlNamespace_5(),
SoapTypeAttribute_t3444503085::get_offset_of__xmlTypeName_6(),
SoapTypeAttribute_t3444503085::get_offset_of__xmlTypeNamespace_7(),
SoapTypeAttribute_t3444503085::get_offset_of__isType_8(),
SoapTypeAttribute_t3444503085::get_offset_of__isElement_9(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize517 = { sizeof (ProxyAttribute_t4031752430), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize518 = { sizeof (TransparentProxy_t3836393972), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable518[1] =
{
TransparentProxy_t3836393972::get_offset_of__rp_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize519 = { sizeof (RealProxy_t298428346), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable519[5] =
{
RealProxy_t298428346::get_offset_of_class_to_proxy_0(),
RealProxy_t298428346::get_offset_of__targetDomainId_1(),
RealProxy_t298428346::get_offset_of__targetUri_2(),
RealProxy_t298428346::get_offset_of__objectIdentity_3(),
RealProxy_t298428346::get_offset_of__objTP_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize520 = { sizeof (RemotingProxy_t2419155897), -1, sizeof(RemotingProxy_t2419155897_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable520[5] =
{
RemotingProxy_t2419155897_StaticFields::get_offset_of__cache_GetTypeMethod_5(),
RemotingProxy_t2419155897_StaticFields::get_offset_of__cache_GetHashCodeMethod_6(),
RemotingProxy_t2419155897::get_offset_of__sink_7(),
RemotingProxy_t2419155897::get_offset_of__hasEnvoySink_8(),
RemotingProxy_t2419155897::get_offset_of__ctorCall_9(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize521 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize522 = { sizeof (TrackingServices_t3722365321), -1, sizeof(TrackingServices_t3722365321_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable522[1] =
{
TrackingServices_t3722365321_StaticFields::get_offset_of__handlers_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize523 = { sizeof (ActivatedClientTypeEntry_t4060499430), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable523[2] =
{
ActivatedClientTypeEntry_t4060499430::get_offset_of_applicationUrl_2(),
ActivatedClientTypeEntry_t4060499430::get_offset_of_obj_type_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize524 = { sizeof (ActivatedServiceTypeEntry_t3934090848), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable524[1] =
{
ActivatedServiceTypeEntry_t3934090848::get_offset_of_obj_type_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize525 = { sizeof (EnvoyInfo_t815109115), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable525[1] =
{
EnvoyInfo_t815109115::get_offset_of_envoySinks_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize526 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize527 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize528 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize529 = { sizeof (Identity_t3647548000), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable529[7] =
{
Identity_t3647548000::get_offset_of__objectUri_0(),
Identity_t3647548000::get_offset_of__channelSink_1(),
Identity_t3647548000::get_offset_of__envoySink_2(),
Identity_t3647548000::get_offset_of__clientDynamicProperties_3(),
Identity_t3647548000::get_offset_of__serverDynamicProperties_4(),
Identity_t3647548000::get_offset_of__objRef_5(),
Identity_t3647548000::get_offset_of__disposed_6(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize530 = { sizeof (ClientIdentity_t2254682501), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable530[1] =
{
ClientIdentity_t2254682501::get_offset_of__proxyReference_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize531 = { sizeof (InternalRemotingServices_t3953136710), -1, sizeof(InternalRemotingServices_t3953136710_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable531[1] =
{
InternalRemotingServices_t3953136710_StaticFields::get_offset_of__soapAttributes_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize532 = { sizeof (ObjRef_t318414488), -1, sizeof(ObjRef_t318414488_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable532[9] =
{
ObjRef_t318414488::get_offset_of_channel_info_0(),
ObjRef_t318414488::get_offset_of_uri_1(),
ObjRef_t318414488::get_offset_of_typeInfo_2(),
ObjRef_t318414488::get_offset_of_envoyInfo_3(),
ObjRef_t318414488::get_offset_of_flags_4(),
ObjRef_t318414488::get_offset_of__serverType_5(),
ObjRef_t318414488_StaticFields::get_offset_of_MarshalledObjectRef_6(),
ObjRef_t318414488_StaticFields::get_offset_of_WellKnowObjectRef_7(),
ObjRef_t318414488_StaticFields::get_offset_of_U3CU3Ef__switchU24map26_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize533 = { sizeof (RemotingConfiguration_t438177651), -1, sizeof(RemotingConfiguration_t438177651_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable533[13] =
{
RemotingConfiguration_t438177651_StaticFields::get_offset_of_applicationID_0(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of_applicationName_1(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of_processGuid_2(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of_defaultConfigRead_3(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of_defaultDelayedConfigRead_4(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of__errorMode_5(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of_wellKnownClientEntries_6(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of_activatedClientEntries_7(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of_wellKnownServiceEntries_8(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of_activatedServiceEntries_9(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of_channelTemplates_10(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of_clientProviderTemplates_11(),
RemotingConfiguration_t438177651_StaticFields::get_offset_of_serverProviderTemplates_12(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize534 = { sizeof (ConfigHandler_t2180714860), -1, sizeof(ConfigHandler_t2180714860_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable534[10] =
{
ConfigHandler_t2180714860::get_offset_of_typeEntries_0(),
ConfigHandler_t2180714860::get_offset_of_channelInstances_1(),
ConfigHandler_t2180714860::get_offset_of_currentChannel_2(),
ConfigHandler_t2180714860::get_offset_of_currentProviderData_3(),
ConfigHandler_t2180714860::get_offset_of_currentClientUrl_4(),
ConfigHandler_t2180714860::get_offset_of_appName_5(),
ConfigHandler_t2180714860::get_offset_of_currentXmlPath_6(),
ConfigHandler_t2180714860::get_offset_of_onlyDelayedChannels_7(),
ConfigHandler_t2180714860_StaticFields::get_offset_of_U3CU3Ef__switchU24map27_8(),
ConfigHandler_t2180714860_StaticFields::get_offset_of_U3CU3Ef__switchU24map28_9(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize535 = { sizeof (ChannelData_t1489610737), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable535[7] =
{
ChannelData_t1489610737::get_offset_of_Ref_0(),
ChannelData_t1489610737::get_offset_of_Type_1(),
ChannelData_t1489610737::get_offset_of_Id_2(),
ChannelData_t1489610737::get_offset_of_DelayLoadAsClientChannel_3(),
ChannelData_t1489610737::get_offset_of__serverProviders_4(),
ChannelData_t1489610737::get_offset_of__clientProviders_5(),
ChannelData_t1489610737::get_offset_of__customProperties_6(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize536 = { sizeof (ProviderData_t2518653487), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable536[5] =
{
ProviderData_t2518653487::get_offset_of_Ref_0(),
ProviderData_t2518653487::get_offset_of_Type_1(),
ProviderData_t2518653487::get_offset_of_Id_2(),
ProviderData_t2518653487::get_offset_of_CustomProperties_3(),
ProviderData_t2518653487::get_offset_of_CustomData_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize537 = { sizeof (FormatterData_t12176916), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize538 = { sizeof (RemotingException_t109604560), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize539 = { sizeof (RemotingServices_t2399536837), -1, sizeof(RemotingServices_t2399536837_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable539[8] =
{
RemotingServices_t2399536837_StaticFields::get_offset_of_uri_hash_0(),
RemotingServices_t2399536837_StaticFields::get_offset_of__serializationFormatter_1(),
RemotingServices_t2399536837_StaticFields::get_offset_of__deserializationFormatter_2(),
RemotingServices_t2399536837_StaticFields::get_offset_of_app_id_3(),
RemotingServices_t2399536837_StaticFields::get_offset_of_next_id_4(),
RemotingServices_t2399536837_StaticFields::get_offset_of_methodBindings_5(),
RemotingServices_t2399536837_StaticFields::get_offset_of_FieldSetterMethod_6(),
RemotingServices_t2399536837_StaticFields::get_offset_of_FieldGetterMethod_7(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize540 = { sizeof (ServerIdentity_t1656058977), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable540[3] =
{
ServerIdentity_t1656058977::get_offset_of__objectType_7(),
ServerIdentity_t1656058977::get_offset_of__serverObject_8(),
ServerIdentity_t1656058977::get_offset_of__context_9(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize541 = { sizeof (ClientActivatedIdentity_t1467784146), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize542 = { sizeof (SingletonIdentity_t164722255), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize543 = { sizeof (SingleCallIdentity_t3377680076), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize544 = { sizeof (SoapServices_t3397513225), -1, sizeof(SoapServices_t3397513225_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable544[5] =
{
SoapServices_t3397513225_StaticFields::get_offset_of__xmlTypes_0(),
SoapServices_t3397513225_StaticFields::get_offset_of__xmlElements_1(),
SoapServices_t3397513225_StaticFields::get_offset_of__soapActions_2(),
SoapServices_t3397513225_StaticFields::get_offset_of__soapActionsMethods_3(),
SoapServices_t3397513225_StaticFields::get_offset_of__typeInfos_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize545 = { sizeof (TypeInfo_t59877052), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable545[2] =
{
TypeInfo_t59877052::get_offset_of_Attributes_0(),
TypeInfo_t59877052::get_offset_of_Elements_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize546 = { sizeof (TypeEntry_t3321373506), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable546[2] =
{
TypeEntry_t3321373506::get_offset_of_assembly_name_0(),
TypeEntry_t3321373506::get_offset_of_type_name_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize547 = { sizeof (TypeInfo_t942537562), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable547[3] =
{
TypeInfo_t942537562::get_offset_of_serverType_0(),
TypeInfo_t942537562::get_offset_of_serverHierarchy_1(),
TypeInfo_t942537562::get_offset_of_interfacesImplemented_2(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize548 = { sizeof (WellKnownClientTypeEntry_t3314744170), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable548[3] =
{
WellKnownClientTypeEntry_t3314744170::get_offset_of_obj_type_2(),
WellKnownClientTypeEntry_t3314744170::get_offset_of_obj_url_3(),
WellKnownClientTypeEntry_t3314744170::get_offset_of_app_url_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize549 = { sizeof (WellKnownObjectMode_t2630225581)+ sizeof (Il2CppObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable549[3] =
{
WellKnownObjectMode_t2630225581::get_offset_of_value___1() + static_cast<int32_t>(sizeof(Il2CppObject)),
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize550 = { sizeof (WellKnownServiceTypeEntry_t1712728956), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable550[3] =
{
WellKnownServiceTypeEntry_t1712728956::get_offset_of_obj_type_2(),
WellKnownServiceTypeEntry_t1712728956::get_offset_of_obj_uri_3(),
WellKnownServiceTypeEntry_t1712728956::get_offset_of_obj_mode_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize551 = { sizeof (BinaryCommon_t2351345412), -1, sizeof(BinaryCommon_t2351345412_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable551[4] =
{
BinaryCommon_t2351345412_StaticFields::get_offset_of_BinaryHeader_0(),
BinaryCommon_t2351345412_StaticFields::get_offset_of__typeCodesToType_1(),
BinaryCommon_t2351345412_StaticFields::get_offset_of__typeCodeMap_2(),
BinaryCommon_t2351345412_StaticFields::get_offset_of_UseReflectionSerialization_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize552 = { sizeof (BinaryElement_t2209278355)+ sizeof (Il2CppObject), sizeof(uint8_t), 0, 0 };
extern const int32_t g_FieldOffsetTable552[24] =
{
BinaryElement_t2209278355::get_offset_of_value___1() + static_cast<int32_t>(sizeof(Il2CppObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize553 = { sizeof (TypeTag_t141209596)+ sizeof (Il2CppObject), sizeof(uint8_t), 0, 0 };
extern const int32_t g_FieldOffsetTable553[9] =
{
TypeTag_t141209596::get_offset_of_value___1() + static_cast<int32_t>(sizeof(Il2CppObject)),
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize554 = { sizeof (MethodFlags_t3869872702)+ sizeof (Il2CppObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable554[11] =
{
MethodFlags_t3869872702::get_offset_of_value___1() + static_cast<int32_t>(sizeof(Il2CppObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize555 = { sizeof (ReturnTypeTag_t419818242)+ sizeof (Il2CppObject), sizeof(uint8_t), 0, 0 };
extern const int32_t g_FieldOffsetTable555[5] =
{
ReturnTypeTag_t419818242::get_offset_of_value___1() + static_cast<int32_t>(sizeof(Il2CppObject)),
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize556 = { sizeof (BinaryFormatter_t1866979105), -1, sizeof(BinaryFormatter_t1866979105_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable556[7] =
{
BinaryFormatter_t1866979105::get_offset_of_assembly_format_0(),
BinaryFormatter_t1866979105::get_offset_of_binder_1(),
BinaryFormatter_t1866979105::get_offset_of_context_2(),
BinaryFormatter_t1866979105::get_offset_of_surrogate_selector_3(),
BinaryFormatter_t1866979105::get_offset_of_type_format_4(),
BinaryFormatter_t1866979105::get_offset_of_filter_level_5(),
BinaryFormatter_t1866979105_StaticFields::get_offset_of_U3CDefaultSurrogateSelectorU3Ek__BackingField_6(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize557 = { sizeof (MessageFormatter_t4119335253), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize558 = { sizeof (ObjectReader_t1476095226), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable558[12] =
{
ObjectReader_t1476095226::get_offset_of__surrogateSelector_0(),
ObjectReader_t1476095226::get_offset_of__context_1(),
ObjectReader_t1476095226::get_offset_of__binder_2(),
ObjectReader_t1476095226::get_offset_of__filterLevel_3(),
ObjectReader_t1476095226::get_offset_of__manager_4(),
ObjectReader_t1476095226::get_offset_of__registeredAssemblies_5(),
ObjectReader_t1476095226::get_offset_of__typeMetadataCache_6(),
ObjectReader_t1476095226::get_offset_of__lastObject_7(),
ObjectReader_t1476095226::get_offset_of__lastObjectID_8(),
ObjectReader_t1476095226::get_offset_of__rootObjectID_9(),
ObjectReader_t1476095226::get_offset_of_arrayBuffer_10(),
ObjectReader_t1476095226::get_offset_of_ArrayBufferLength_11(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize559 = { sizeof (TypeMetadata_t3000156221), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable559[6] =
{
TypeMetadata_t3000156221::get_offset_of_Type_0(),
TypeMetadata_t3000156221::get_offset_of_MemberTypes_1(),
TypeMetadata_t3000156221::get_offset_of_MemberNames_2(),
TypeMetadata_t3000156221::get_offset_of_MemberInfos_3(),
TypeMetadata_t3000156221::get_offset_of_FieldCount_4(),
TypeMetadata_t3000156221::get_offset_of_NeedsSerializationInfo_5(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize560 = { sizeof (ArrayNullFiller_t3123371156), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable560[1] =
{
ArrayNullFiller_t3123371156::get_offset_of_NullCount_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize561 = { sizeof (FormatterAssemblyStyle_t999493661)+ sizeof (Il2CppObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable561[3] =
{
FormatterAssemblyStyle_t999493661::get_offset_of_value___1() + static_cast<int32_t>(sizeof(Il2CppObject)),
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize562 = { sizeof (FormatterTypeStyle_t943306207)+ sizeof (Il2CppObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable562[4] =
{
FormatterTypeStyle_t943306207::get_offset_of_value___1() + static_cast<int32_t>(sizeof(Il2CppObject)),
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize563 = { sizeof (TypeFilterLevel_t1182459634)+ sizeof (Il2CppObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable563[3] =
{
TypeFilterLevel_t1182459634::get_offset_of_value___1() + static_cast<int32_t>(sizeof(Il2CppObject)),
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize564 = { sizeof (FormatterConverter_t764140214), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize565 = { sizeof (FormatterServices_t3161112612), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize566 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize567 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize568 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize569 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize570 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize571 = { 0, -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize572 = { sizeof (ObjectManager_t2645893724), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable572[9] =
{
ObjectManager_t2645893724::get_offset_of__objectRecordChain_0(),
ObjectManager_t2645893724::get_offset_of__lastObjectRecord_1(),
ObjectManager_t2645893724::get_offset_of__deserializedRecords_2(),
ObjectManager_t2645893724::get_offset_of__onDeserializedCallbackRecords_3(),
ObjectManager_t2645893724::get_offset_of__objectRecords_4(),
ObjectManager_t2645893724::get_offset_of__finalFixup_5(),
ObjectManager_t2645893724::get_offset_of__selector_6(),
ObjectManager_t2645893724::get_offset_of__context_7(),
ObjectManager_t2645893724::get_offset_of__registeredObjectsCount_8(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize573 = { sizeof (BaseFixupRecord_t3171032996), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable573[4] =
{
BaseFixupRecord_t3171032996::get_offset_of_ObjectToBeFixed_0(),
BaseFixupRecord_t3171032996::get_offset_of_ObjectRequired_1(),
BaseFixupRecord_t3171032996::get_offset_of_NextSameContainer_2(),
BaseFixupRecord_t3171032996::get_offset_of_NextSameRequired_3(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize574 = { sizeof (ArrayFixupRecord_t1994227600), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable574[1] =
{
ArrayFixupRecord_t1994227600::get_offset_of__index_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize575 = { sizeof (MultiArrayFixupRecord_t691510385), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable575[1] =
{
MultiArrayFixupRecord_t691510385::get_offset_of__indices_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize576 = { sizeof (FixupRecord_t1044204179), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable576[1] =
{
FixupRecord_t1044204179::get_offset_of__member_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize577 = { sizeof (DelayedFixupRecord_t1033808295), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable577[1] =
{
DelayedFixupRecord_t1033808295::get_offset_of__memberName_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize578 = { sizeof (ObjectRecordStatus_t1923758778)+ sizeof (Il2CppObject), sizeof(uint8_t), 0, 0 };
extern const int32_t g_FieldOffsetTable578[5] =
{
ObjectRecordStatus_t1923758778::get_offset_of_value___1() + static_cast<int32_t>(sizeof(Il2CppObject)),
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize579 = { sizeof (ObjectRecord_t4134110382), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable579[13] =
{
ObjectRecord_t4134110382::get_offset_of_Status_0(),
ObjectRecord_t4134110382::get_offset_of_OriginalObject_1(),
ObjectRecord_t4134110382::get_offset_of_ObjectInstance_2(),
ObjectRecord_t4134110382::get_offset_of_ObjectID_3(),
ObjectRecord_t4134110382::get_offset_of_Info_4(),
ObjectRecord_t4134110382::get_offset_of_IdOfContainingObj_5(),
ObjectRecord_t4134110382::get_offset_of_Surrogate_6(),
ObjectRecord_t4134110382::get_offset_of_SurrogateSelector_7(),
ObjectRecord_t4134110382::get_offset_of_Member_8(),
ObjectRecord_t4134110382::get_offset_of_ArrayIndex_9(),
ObjectRecord_t4134110382::get_offset_of_FixupChainAsContainer_10(),
ObjectRecord_t4134110382::get_offset_of_FixupChainAsRequired_11(),
ObjectRecord_t4134110382::get_offset_of_Next_12(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize580 = { sizeof (OnDeserializedAttribute_t3172265744), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize581 = { sizeof (OnDeserializingAttribute_t484921187), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize582 = { sizeof (OnSerializedAttribute_t3742956097), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize583 = { sizeof (OnSerializingAttribute_t2011372116), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize584 = { sizeof (SerializationBinder_t3985864818), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize585 = { sizeof (SerializationCallbacks_t2797915342), -1, sizeof(SerializationCallbacks_t2797915342_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable585[6] =
{
SerializationCallbacks_t2797915342::get_offset_of_onSerializingList_0(),
SerializationCallbacks_t2797915342::get_offset_of_onSerializedList_1(),
SerializationCallbacks_t2797915342::get_offset_of_onDeserializingList_2(),
SerializationCallbacks_t2797915342::get_offset_of_onDeserializedList_3(),
SerializationCallbacks_t2797915342_StaticFields::get_offset_of_cache_4(),
SerializationCallbacks_t2797915342_StaticFields::get_offset_of_cache_lock_5(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize586 = { sizeof (CallbackHandler_t362827733), sizeof(Il2CppMethodPointer), 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize587 = { sizeof (SerializationEntry_t3485203212)+ sizeof (Il2CppObject), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable587[3] =
{
SerializationEntry_t3485203212::get_offset_of_name_0() + static_cast<int32_t>(sizeof(Il2CppObject)),
SerializationEntry_t3485203212::get_offset_of_objectType_1() + static_cast<int32_t>(sizeof(Il2CppObject)),
SerializationEntry_t3485203212::get_offset_of_value_2() + static_cast<int32_t>(sizeof(Il2CppObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize588 = { sizeof (SerializationException_t753258759), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize589 = { sizeof (SerializationInfo_t228987430), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable589[5] =
{
SerializationInfo_t228987430::get_offset_of_serialized_0(),
SerializationInfo_t228987430::get_offset_of_values_1(),
SerializationInfo_t228987430::get_offset_of_assemblyName_2(),
SerializationInfo_t228987430::get_offset_of_fullTypeName_3(),
SerializationInfo_t228987430::get_offset_of_converter_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize590 = { sizeof (SerializationInfoEnumerator_t589103770), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable590[1] =
{
SerializationInfoEnumerator_t589103770::get_offset_of_enumerator_0(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize591 = { sizeof (StreamingContext_t1417235061)+ sizeof (Il2CppObject), sizeof(StreamingContext_t1417235061_marshaled_pinvoke), 0, 0 };
extern const int32_t g_FieldOffsetTable591[2] =
{
StreamingContext_t1417235061::get_offset_of_state_0() + static_cast<int32_t>(sizeof(Il2CppObject)),
StreamingContext_t1417235061::get_offset_of_additional_1() + static_cast<int32_t>(sizeof(Il2CppObject)),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize592 = { sizeof (StreamingContextStates_t4264247603)+ sizeof (Il2CppObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable592[10] =
{
StreamingContextStates_t4264247603::get_offset_of_value___1() + static_cast<int32_t>(sizeof(Il2CppObject)),
0,
0,
0,
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize593 = { sizeof (X509Certificate_t283079845), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable593[5] =
{
X509Certificate_t283079845::get_offset_of_x509_0(),
X509Certificate_t283079845::get_offset_of_hideDates_1(),
X509Certificate_t283079845::get_offset_of_cachedCertificateHash_2(),
X509Certificate_t283079845::get_offset_of_issuer_name_3(),
X509Certificate_t283079845::get_offset_of_subject_name_4(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize594 = { sizeof (X509KeyStorageFlags_t1216946873)+ sizeof (Il2CppObject), sizeof(int32_t), 0, 0 };
extern const int32_t g_FieldOffsetTable594[7] =
{
X509KeyStorageFlags_t1216946873::get_offset_of_value___1() + static_cast<int32_t>(sizeof(Il2CppObject)),
0,
0,
0,
0,
0,
0,
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize595 = { sizeof (AsymmetricAlgorithm_t784058677), -1, 0, 0 };
extern const int32_t g_FieldOffsetTable595[2] =
{
AsymmetricAlgorithm_t784058677::get_offset_of_KeySizeValue_0(),
AsymmetricAlgorithm_t784058677::get_offset_of_LegalKeySizesValue_1(),
};
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize596 = { sizeof (AsymmetricKeyExchangeFormatter_t3339648384), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize597 = { sizeof (AsymmetricSignatureDeformatter_t3580832979), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize598 = { sizeof (AsymmetricSignatureFormatter_t4058014248), -1, 0, 0 };
extern const Il2CppTypeDefinitionSizes g_typeDefinitionSize599 = { sizeof (Base64Constants_t4112722312), -1, sizeof(Base64Constants_t4112722312_StaticFields), 0 };
extern const int32_t g_FieldOffsetTable599[2] =
{
Base64Constants_t4112722312_StaticFields::get_offset_of_EncodeTable_0(),
Base64Constants_t4112722312_StaticFields::get_offset_of_DecodeTable_1(),
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"bruno.penzar@posteo.de"
] | bruno.penzar@posteo.de |
52aed584eaf407cfd1e94fba37a80b022f06b8dd | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/curl/gumtree/curl_new_hunk_1223.cpp | 526d3ee3c66e057f9e351ff4f26a1941d358b701 | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 79,833 | cpp | " (HTTP) Request a compressed response using one of the algorithms\n"
" curl supports, and save the uncompressed document. If this\n"
" option is used and the server sends an unsupported encoding,\n"
" curl will report an error.\n"
"\n"
" -K, --config <file>\n"
"\n"
" Specify a text file to read curl arguments from. The command\n"
, stdout);
fputs(
" line arguments found in the text file will be used as if they\n"
" were provided on the command line.\n"
"\n"
" Options and their parameters must be specified on the same line\n"
" in the file, separated by whitespace, colon, or the equals sign.\n"
" Long option names can optionally be given in the config file\n"
" without the initial double dashes and if so, the colon or equals\n"
, stdout);
fputs(
" characters can be used as separators. If the option is specified\n"
" with one or two dashes, there can be no colon or equals charac-\n"
" ter between the option and its parameter.\n"
"\n"
" If the parameter is to contain whitespace, the parameter must be\n"
" enclosed within quotes. Within double quotes, the following\n"
" escape sequences are available: \\\\, \\\", \\t, \\n, \\r and \\v. A\n"
, stdout);
fputs(
" backslash preceding any other letter is ignored. If the first\n"
" column of a config line is a '#' character, the rest of the line\n"
" will be treated as a comment. Only write one option per physical\n"
" line in the config file.\n"
"\n"
" Specify the filename to -K, --config as '-' to make curl read\n"
" the file from stdin.\n"
"\n"
" Note that to be able to specify a URL in the config file, you\n"
, stdout);
fputs(
" need to specify it using the --url option, and not by simply\n"
" writing the URL on its own line. So, it could look similar to\n"
" this:\n"
"\n"
" url = \"https://curl.haxx.se/docs/\"\n"
"\n"
" When curl is invoked, it (unless -q, --disable is used) checks\n"
" for a default config file and uses it if found. The default con-\n"
" fig file is checked for in the following places in this order:\n"
"\n"
, stdout);
fputs(
" 1) curl tries to find the \"home dir\": It first checks for the\n"
" CURL_HOME and then the HOME environment variables. Failing that,\n"
" it uses getpwuid() on Unix-like systems (which returns the home\n"
" dir given the current user in your system). On Windows, it then\n"
" checks for the APPDATA variable, or as a last resort the '%USER-\n"
" PROFILE%\\Application Data'.\n"
"\n"
, stdout);
fputs(
" 2) On windows, if there is no _curlrc file in the home dir, it\n"
" checks for one in the same dir the curl executable is placed. On\n"
" Unix-like systems, it will simply try to load .curlrc from the\n"
" determined home dir.\n"
"\n"
" # --- Example file ---\n"
" # this is a comment\n"
" url = \"example.com\"\n"
" output = \"curlhere.html\"\n"
" user-agent = \"superagent/1.0\"\n"
"\n"
, stdout);
fputs(
" # and fetch another URL too\n"
" url = \"example.com/docs/manpage.html\"\n"
" -O\n"
" referer = \"http://nowhereatall.example.com/\"\n"
" # --- End of example file ---\n"
"\n"
" This option can be used multiple times to load multiple config\n"
" files.\n"
"\n"
" --connect-timeout <seconds>\n"
" Maximum time in seconds that you allow curl's connection to\n"
, stdout);
fputs(
" take. This only limits the connection phase, so if curl con-\n"
" nects within the given period it will continue - if not it will\n"
" exit. Since version 7.32.0, this option accepts decimal values.\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" See also -m, --max-time.\n"
"\n"
" --connect-to <HOST1:PORT1:HOST2:PORT2>\n"
"\n"
" For a request to the given HOST:PORT pair, connect to CONNECT-\n"
, stdout);
fputs(
" TO-HOST:CONNECT-TO-PORT instead. This option is suitable to\n"
" direct requests at a specific server, e.g. at a specific cluster\n"
" node in a cluster of servers. This option is only used to\n"
" establish the network connection. It does NOT affect the host-\n"
" name/port that is used for TLS/SSL (e.g. SNI, certificate veri-\n"
" fication) or for the application protocols. \"host\" and \"port\"\n"
, stdout);
fputs(
" may be the empty string, meaning \"any host/port\". \"connect-to-\n"
" host\" and \"connect-to-port\" may also be the empty string, mean-\n"
" ing \"use the request's original host/port\".\n"
"\n"
" This option can be used many times to add many connect rules.\n"
"\n"
" See also --resolve and -H, --header. Added in 7.49.0.\n"
"\n"
" -C, --continue-at <offset>\n"
" Continue/Resume a previous file transfer at the given offset.\n"
, stdout);
fputs(
" The given offset is the exact number of bytes that will be\n"
" skipped, counting from the beginning of the source file before\n"
" it is transferred to the destination. If used with uploads, the\n"
" FTP server command SIZE will not be used by curl.\n"
"\n"
" Use \"-C -\" to tell curl to automatically find out where/how to\n"
" resume the transfer. It then uses the given output/input files\n"
" to figure that out.\n"
"\n"
, stdout);
fputs(
" If this option is used several times, the last one will be used.\n"
"\n"
" See also -r, --range.\n"
"\n"
" -c, --cookie-jar <filename>\n"
" (HTTP) Specify to which file you want curl to write all cookies\n"
" after a completed operation. Curl writes all cookies from its\n"
" in-memory cookie storage to the given file at the end of opera-\n"
" tions. If no cookies are known, no data will be written. The\n"
, stdout);
fputs(
" file will be written using the Netscape cookie file format. If\n"
" you set the file name to a single dash, \"-\", the cookies will be\n"
" written to stdout.\n"
"\n"
" This command line option will activate the cookie engine that\n"
" makes curl record and use cookies. Another way to activate it is\n"
" to use the -b, --cookie option.\n"
"\n"
" If the cookie jar can't be created or written to, the whole curl\n"
, stdout);
fputs(
" operation won't fail or even report an error clearly. Using -v,\n"
" --verbose will get a warning displayed, but that is the only\n"
" visible feedback you get about this possibly lethal situation.\n"
"\n"
" If this option is used several times, the last specified file\n"
" name will be used.\n"
"\n"
" -b, --cookie <data>\n"
" (HTTP) Pass the data to the HTTP server in the Cookie header. It\n"
, stdout);
fputs(
" is supposedly the data previously received from the server in a\n"
" \"Set-Cookie:\" line. The data should be in the format\n"
" \"NAME1=VALUE1; NAME2=VALUE2\".\n"
"\n"
" If no '=' symbol is used in the argument, it is instead treated\n"
" as a filename to read previously stored cookie from. This option\n"
" also activates the cookie engine which will make curl record\n"
, stdout);
fputs(
" incoming cookies, which may be handy if you're using this in\n"
" combination with the -L, --location option or do multiple URL\n"
" transfers on the same invoke.\n"
"\n"
" The file format of the file to read cookies from should be plain\n"
" HTTP headers (Set-Cookie style) or the Netscape/Mozilla cookie\n"
" file format.\n"
"\n"
" The file specified with -b, --cookie is only used as input. No\n"
, stdout);
fputs(
" cookies will be written to the file. To store cookies, use the\n"
" -c, --cookie-jar option.\n"
"\n"
" Exercise caution if you are using this option and multiple\n"
" transfers may occur. If you use the NAME1=VALUE1; format, or in\n"
" a file use the Set-Cookie format and don't specify a domain,\n"
" then the cookie is sent for any domain (even after redirects are\n"
, stdout);
fputs(
" followed) and cannot be modified by a server-set cookie. If the\n"
" cookie engine is enabled and a server sets a cookie of the same\n"
" name then both will be sent on a future transfer to that server,\n"
" likely not what you intended. To address these issues set a\n"
" domain in Set-Cookie (doing that will include sub domains) or\n"
" use the Netscape format.\n"
"\n"
, stdout);
fputs(
" If this option is used several times, the last one will be used.\n"
" Users very often want to both read cookies from a file and write\n"
" updated cookies back to a file, so using both -b, --cookie and\n"
" -c, --cookie-jar in the same command line is common.\n"
"\n"
" --create-dirs\n"
" When used in conjunction with the -o, --output option, curl will\n"
" create the necessary local directory hierarchy as needed. This\n"
, stdout);
fputs(
" option creates the dirs mentioned with the -o, --output option,\n"
" nothing else. If the --output file name uses no dir or if the\n"
" dirs it mentions already exist, no dir will be created.\n"
"\n"
" To create remote directories when using FTP or SFTP, try --ftp-\n"
" create-dirs.\n"
"\n"
" --crlf (FTP SMTP) Convert LF to CRLF in upload. Useful for MVS\n"
" (OS/390).\n"
"\n"
" (SMTP added in 7.40.0)\n"
"\n"
, stdout);
fputs(
" --crlfile <file>\n"
" (TLS) Provide a file using PEM format with a Certificate Revoca-\n"
" tion List that may specify peer certificates that are to be con-\n"
" sidered revoked.\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" Added in 7.19.7.\n"
"\n"
" --data-ascii <data>\n"
" (HTTP) This is just an alias for -d, --data.\n"
"\n"
" --data-binary <data>\n"
, stdout);
fputs(
" (HTTP) This posts data exactly as specified with no extra pro-\n"
" cessing whatsoever.\n"
"\n"
" If you start the data with the letter @, the rest should be a\n"
" filename. Data is posted in a similar manner as -d, --data\n"
" does, except that newlines and carriage returns are preserved\n"
" and conversions are never done.\n"
"\n"
" If this option is used several times, the ones following the\n"
, stdout);
fputs(
" first will append data as described in -d, --data.\n"
"\n"
" --data-raw <data>\n"
" (HTTP) This posts data similarly to -d, --data but without the\n"
" special interpretation of the @ character.\n"
"\n"
" See also -d, --data. Added in 7.43.0.\n"
"\n"
" --data-urlencode <data>\n"
" (HTTP) This posts data, similar to the other -d, --data options\n"
" with the exception that this performs URL-encoding.\n"
"\n"
, stdout);
fputs(
" To be CGI-compliant, the <data> part should begin with a name\n"
" followed by a separator and a content specification. The <data>\n"
" part can be passed to curl using one of the following syntaxes:\n"
"\n"
" content\n"
" This will make curl URL-encode the content and pass that\n"
" on. Just be careful so that the content doesn't contain\n"
" any = or @ symbols, as that will then make the syntax\n"
, stdout);
fputs(
" match one of the other cases below!\n"
"\n"
" =content\n"
" This will make curl URL-encode the content and pass that\n"
" on. The preceding = symbol is not included in the data.\n"
"\n"
" name=content\n"
" This will make curl URL-encode the content part and pass\n"
" that on. Note that the name part is expected to be URL-\n"
" encoded already.\n"
"\n"
" @filename\n"
, stdout);
fputs(
" This will make curl load data from the given file\n"
" (including any newlines), URL-encode that data and pass\n"
" it on in the POST.\n"
"\n"
" name@filename\n"
" This will make curl load data from the given file\n"
" (including any newlines), URL-encode that data and pass\n"
" it on in the POST. The name part gets an equal sign\n"
, stdout);
fputs(
" appended, resulting in name=urlencoded-file-content. Note\n"
" that the name is expected to be URL-encoded already.\n"
" See also -d, --data and --data-raw. Added in 7.18.0.\n"
"\n"
" -d, --data <data>\n"
" (HTTP) Sends the specified data in a POST request to the HTTP\n"
" server, in the same way that a browser does when a user has\n"
" filled in an HTML form and presses the submit button. This will\n"
, stdout);
fputs(
" cause curl to pass the data to the server using the content-type\n"
" application/x-www-form-urlencoded. Compare to -F, --form.\n"
"\n"
" --data-raw is almost the same but does not have a special inter-\n"
" pretation of the @ character. To post data purely binary, you\n"
" should instead use the --data-binary option. To URL-encode the\n"
" value of a form field you may use --data-urlencode.\n"
"\n"
, stdout);
fputs(
" If any of these options is used more than once on the same com-\n"
" mand line, the data pieces specified will be merged together\n"
" with a separating &-symbol. Thus, using '-d name=daniel -d\n"
" skill=lousy' would generate a post chunk that looks like\n"
" 'name=daniel&skill=lousy'.\n"
"\n"
" If you start the data with the letter @, the rest should be a\n"
, stdout);
fputs(
" file name to read the data from, or - if you want curl to read\n"
" the data from stdin. Multiple files can also be specified. Post-\n"
" ing data from a file named from a file like that, carriage\n"
" returns and newlines will be stripped out. If you don't want the\n"
" @ character to have a special interpretation use --data-raw\n"
" instead.\n"
"\n"
" See also --data-binary and --data-urlencode and --data-raw. This\n"
, stdout);
fputs(
" option overrides -F, --form and -I, --head and --upload.\n"
"\n"
" --delegation <LEVEL>\n"
" (GSS/kerberos) Set LEVEL to tell the server what it is allowed\n"
" to delegate when it comes to user credentials.\n"
"\n"
" none Don't allow any delegation.\n"
"\n"
" policy Delegates if and only if the OK-AS-DELEGATE flag is set\n"
" in the Kerberos service ticket, which is a matter of\n"
" realm policy.\n"
"\n"
, stdout);
fputs(
" always Unconditionally allow the server to delegate.\n"
"\n"
" --digest\n"
" (HTTP) Enables HTTP Digest authentication. This is an authenti-\n"
" cation scheme that prevents the password from being sent over\n"
" the wire in clear text. Use this in combination with the normal\n"
" -u, --user option to set user name and password.\n"
"\n"
" If this option is used several times, only the first one is\n"
" used.\n"
"\n"
, stdout);
fputs(
" See also -u, --user and --proxy-digest and --anyauth. This\n"
" option overrides --basic and --ntlm and --negotiate.\n"
"\n"
" --disable-eprt\n"
" (FTP) Tell curl to disable the use of the EPRT and LPRT commands\n"
" when doing active FTP transfers. Curl will normally always first\n"
" attempt to use EPRT, then LPRT before using PORT, but with this\n"
" option, it will use PORT right away. EPRT and LPRT are exten-\n"
, stdout);
fputs(
" sions to the original FTP protocol, and may not work on all\n"
" servers, but they enable more functionality in a better way than\n"
" the traditional PORT command.\n"
"\n"
" --eprt can be used to explicitly enable EPRT again and --no-eprt\n"
" is an alias for --disable-eprt.\n"
"\n"
" If the server is accessed using IPv6, this option will have no\n"
" effect as EPRT is necessary then.\n"
"\n"
, stdout);
fputs(
" Disabling EPRT only changes the active behavior. If you want to\n"
" switch to passive mode you need to not use -P, --ftp-port or\n"
" force it with --ftp-pasv.\n"
"\n"
" --disable-epsv\n"
" (FTP) (FTP) Tell curl to disable the use of the EPSV command\n"
" when doing passive FTP transfers. Curl will normally always\n"
" first attempt to use EPSV before PASV, but with this option, it\n"
" will not try using EPSV.\n"
"\n"
, stdout);
fputs(
" --epsv can be used to explicitly enable EPSV again and --no-epsv\n"
" is an alias for --disable-epsv.\n"
"\n"
" If the server is an IPv6 host, this option will have no effect\n"
" as EPSV is necessary then.\n"
"\n"
" Disabling EPSV only changes the passive behavior. If you want to\n"
" switch to active mode you need to use -P, --ftp-port.\n"
"\n"
" -q, --disable\n"
" If used as the first parameter on the command line, the curlrc\n"
, stdout);
fputs(
" config file will not be read and used. See the -K, --config for\n"
" details on the default config file search path.\n"
"\n"
" --dns-interface <interface>\n"
" (DNS) Tell curl to send outgoing DNS requests through <inter-\n"
" face>. This option is a counterpart to --interface (which does\n"
" not affect DNS). The supplied string must be an interface name\n"
" (not an address).\n"
"\n"
, stdout);
fputs(
" See also --dns-ipv4-addr and --dns-ipv6-addr. --dns-interface\n"
" requires that the underlying libcurl was built to support c-\n"
" ares. Added in 7.33.0.\n"
"\n"
" --dns-ipv4-addr <address>\n"
" (DNS) Tell curl to bind to <ip-address> when making IPv4 DNS\n"
" requests, so that the DNS requests originate from this address.\n"
" The argument should be a single IPv4 address.\n"
"\n"
, stdout);
fputs(
" See also --dns-interface and --dns-ipv6-addr. --dns-ipv4-addr\n"
" requires that the underlying libcurl was built to support c-\n"
" ares. Added in 7.33.0.\n"
"\n"
" --dns-ipv6-addr <address>\n"
" (DNS) Tell curl to bind to <ip-address> when making IPv6 DNS\n"
" requests, so that the DNS requests originate from this address.\n"
" The argument should be a single IPv6 address.\n"
"\n"
, stdout);
fputs(
" See also --dns-interface and --dns-ipv4-addr. --dns-ipv6-addr\n"
" requires that the underlying libcurl was built to support c-\n"
" ares. Added in 7.33.0.\n"
"\n"
" --dns-servers <addresses>\n"
" Set the list of DNS servers to be used instead of the system\n"
" default. The list of IP addresses should be separated with com-\n"
" mas. Port numbers may also optionally be given as :<port-number>\n"
, stdout);
fputs(
" after each IP address.\n"
"\n"
" --dns-servers requires that the underlying libcurl was built to\n"
" support c-ares. Added in 7.33.0.\n"
"\n"
" -D, --dump-header <filename>\n"
" (HTTP FTP) Write the received protocol headers to the specified\n"
" file.\n"
"\n"
" This option is handy to use when you want to store the headers\n"
" that an HTTP site sends to you. Cookies from the headers could\n"
, stdout);
fputs(
" then be read in a second curl invocation by using the -b,\n"
" --cookie option! The -c, --cookie-jar option is a better way to\n"
" store cookies.\n"
"\n"
" When used in FTP, the FTP server response lines are considered\n"
" being \"headers\" and thus are saved there.\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" See also -o, --output.\n"
"\n"
" --egd-file <file>\n"
, stdout);
fputs(
" (TLS) Specify the path name to the Entropy Gathering Daemon\n"
" socket. The socket is used to seed the random engine for SSL\n"
" connections.\n"
"\n"
" See also --random-file.\n"
"\n"
" --engine <name>\n"
" (TLS) Select the OpenSSL crypto engine to use for cipher opera-\n"
" tions. Use --engine list to print a list of build-time supported\n"
" engines. Note that not all (or none) of the engines may be\n"
, stdout);
fputs(
" available at run-time.\n"
"\n"
" --expect100-timeout <seconds>\n"
" (HTTP) Maximum time in seconds that you allow curl to wait for a\n"
" 100-continue response when curl emits an Expects: 100-continue\n"
" header in its request. By default curl will wait one second.\n"
" This option accepts decimal values! When curl stops waiting, it\n"
" will continue as if the response has been received.\n"
"\n"
, stdout);
fputs(
" See also --connect-timeout. Added in 7.47.0.\n"
"\n"
" --fail-early\n"
" Fail and exit on the first detected transfer error.\n"
"\n"
" When curl is used to do multiple transfers on the command line,\n"
" it will attempt to operate on each given URL, one by one. By\n"
" default, it will ignore errors if there are more URLs given and\n"
" the last URL's success will determine the error code curl\n"
, stdout);
fputs(
" returns. So early failures will be \"hidden\" by subsequent suc-\n"
" cessful transfers.\n"
"\n"
" Using this option, curl will instead return an error on the\n"
" first transfer that fails, independent of the amount of URLs\n"
" that are given on the command line. This way, no transfer fail-\n"
" ures go undetected by scripts and similar.\n"
"\n"
" This option is global and does not need to be specified for each\n"
, stdout);
fputs(
" use of -:, --next.\n"
"\n"
" This option does not imply -f, --fail, which causes transfers to\n"
" fail due to the server's HTTP status code. You can combine the\n"
" two options, however note -f, --fail is not global and is there-\n"
" fore contained by -:, --next.\n"
"\n"
" Added in 7.52.0.\n"
"\n"
" -f, --fail\n"
" (HTTP) Fail silently (no output at all) on server errors. This\n"
, stdout);
fputs(
" is mostly done to better enable scripts etc to better deal with\n"
" failed attempts. In normal cases when an HTTP server fails to\n"
" deliver a document, it returns an HTML document stating so\n"
" (which often also describes why and more). This flag will pre-\n"
" vent curl from outputting that and return error 22.\n"
"\n"
" This method is not fail-safe and there are occasions where non-\n"
, stdout);
fputs(
" successful response codes will slip through, especially when\n"
" authentication is involved (response codes 401 and 407).\n"
"\n"
" --false-start\n"
" (TLS) Tells curl to use false start during the TLS handshake.\n"
" False start is a mode where a TLS client will start sending\n"
" application data before verifying the server's Finished message,\n"
" thus saving a round trip when performing a full handshake.\n"
"\n"
, stdout);
fputs(
" This is currently only implemented in the NSS and Secure Trans-\n"
" port (on iOS 7.0 or later, or OS X 10.9 or later) backends.\n"
"\n"
" Added in 7.42.0.\n"
"\n"
" --form-string <name=string>\n"
" (HTTP) Similar to -F, --form except that the value string for\n"
" the named parameter is used literally. Leading '@' and '<' char-\n"
" acters, and the ';type=' string in the value have no special\n"
, stdout);
fputs(
" meaning. Use this in preference to -F, --form if there's any\n"
" possibility that the string value may accidentally trigger the\n"
" '@' or '<' features of -F, --form.\n"
"\n"
" See also -F, --form.\n"
"\n"
" -F, --form <name=content>\n"
" (HTTP) This lets curl emulate a filled-in form in which a user\n"
" has pressed the submit button. This causes curl to POST data\n"
, stdout);
fputs(
" using the Content-Type multipart/form-data according to RFC\n"
" 2388. This enables uploading of binary files etc. To force the\n"
" 'content' part to be a file, prefix the file name with an @\n"
" sign. To just get the content part from a file, prefix the file\n"
" name with the symbol <. The difference between @ and < is then\n"
" that @ makes a file get attached in the post as a file upload,\n"
, stdout);
fputs(
" while the < makes a text field and just get the contents for\n"
" that text field from a file.\n"
"\n"
" Example: to send an image to a server, where 'profile' is the\n"
" name of the form-field to which portrait.jpg will be the input:\n"
"\n"
" curl -F profile=@portrait.jpg https://example.com/upload.cgi\n"
"\n"
" To read content from stdin instead of a file, use - as the file-\n"
, stdout);
fputs(
" name. This goes for both @ and < constructs. Unfortunately it\n"
" does not support reading the file from a named pipe or similar,\n"
" as it needs the full size before the transfer starts.\n"
"\n"
" You can also tell curl what Content-Type to use by using\n"
" 'type=', in a manner similar to:\n"
"\n"
" curl -F \"web=@index.html;type=text/html\" example.com\n"
"\n"
" or\n"
"\n"
, stdout);
fputs(
" curl -F \"name=daniel;type=text/foo\" example.com\n"
"\n"
" You can also explicitly change the name field of a file upload\n"
" part by setting filename=, like this:\n"
"\n"
" curl -F \"file=@localfile;filename=nameinpost\" example.com\n"
"\n"
" If filename/path contains ',' or ';', it must be quoted by dou-\n"
" ble-quotes like:\n"
"\n"
" curl -F \"file=@\\\"localfile\\\";filename=\\\"nameinpost\\\"\" exam-\n"
" ple.com\n"
"\n"
, stdout);
fputs(
" or\n"
"\n"
" curl -F 'file=@\"localfile\";filename=\"nameinpost\"' example.com\n"
"\n"
" Note that if a filename/path is quoted by double-quotes, any\n"
" double-quote or backslash within the filename must be escaped by\n"
" backslash.\n"
"\n"
" See further examples and details in the MANUAL.\n"
"\n"
" This option can be used multiple times.\n"
"\n"
" This option overrides -d, --data and -I, --head and --upload.\n"
"\n"
, stdout);
fputs(
" --ftp-account <data>\n"
" (FTP) When an FTP server asks for \"account data\" after user name\n"
" and password has been provided, this data is sent off using the\n"
" ACCT command.\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" Added in 7.13.0.\n"
"\n"
" --ftp-alternative-to-user <command>\n"
" (FTP) If authenticating with the USER and PASS commands fails,\n"
, stdout);
fputs(
" send this command. When connecting to Tumbleweed's Secure\n"
" Transport server over FTPS using a client certificate, using\n"
" \"SITE AUTH\" will tell the server to retrieve the username from\n"
" the certificate.\n"
" Added in 7.15.5.\n"
"\n"
" --ftp-create-dirs\n"
" (FTP SFTP) When an FTP or SFTP URL/operation uses a path that\n"
" doesn't currently exist on the server, the standard behavior of\n"
, stdout);
fputs(
" curl is to fail. Using this option, curl will instead attempt to\n"
" create missing directories.\n"
"\n"
" See also --create-dirs.\n"
"\n"
" --ftp-method <method>\n"
" (FTP) Control what method curl should use to reach a file on an\n"
" FTP(S) server. The method argument should be one of the follow-\n"
" ing alternatives:\n"
"\n"
" multicwd\n"
" curl does a single CWD operation for each path part in\n"
, stdout);
fputs(
" the given URL. For deep hierarchies this means very many\n"
" commands. This is how RFC 1738 says it should be done.\n"
" This is the default but the slowest behavior.\n"
"\n"
" nocwd curl does no CWD at all. curl will do SIZE, RETR, STOR\n"
" etc and give a full path to the server for all these com-\n"
" mands. This is the fastest behavior.\n"
"\n"
" singlecwd\n"
, stdout);
fputs(
" curl does one CWD with the full target directory and then\n"
" operates on the file \"normally\" (like in the multicwd\n"
" case). This is somewhat more standards compliant than\n"
" 'nocwd' but without the full penalty of 'multicwd'.\n"
"\n"
" Added in 7.15.1.\n"
"\n"
" --ftp-pasv\n"
" (FTP) Use passive mode for the data connection. Passive is the\n"
, stdout);
fputs(
" internal default behavior, but using this option can be used to\n"
" override a previous -P, --ftp-port option.\n"
"\n"
" If this option is used several times, only the first one is\n"
" used. Undoing an enforced passive really isn't doable but you\n"
" must then instead enforce the correct -P, --ftp-port again.\n"
"\n"
" Passive mode means that curl will try the EPSV command first and\n"
, stdout);
fputs(
" then PASV, unless --disable-epsv is used.\n"
" See also --disable-epsv. Added in 7.11.0.\n"
"\n"
" -P, --ftp-port <address>\n"
" (FTP) Reverses the default initiator/listener roles when con-\n"
" necting with FTP. This option makes curl use active mode. curl\n"
" then tells the server to connect back to the client's specified\n"
" address and port, while passive mode asks the server to setup an\n"
, stdout);
fputs(
" IP address and port for it to connect to. <address> should be\n"
" one of:\n"
"\n"
" interface\n"
" i.e \"eth0\" to specify which interface's IP address you\n"
" want to use (Unix only)\n"
"\n"
" IP address\n"
" i.e \"192.168.10.1\" to specify the exact IP address\n"
"\n"
" host name\n"
" i.e \"my.host.domain\" to specify the machine\n"
"\n"
, stdout);
fputs(
" - make curl pick the same IP address that is already used\n"
" for the control connection\n"
"\n"
" If this option is used several times, the last one will be used. Dis-\n"
" able the use of PORT with --ftp-pasv. Disable the attempt to use the\n"
" EPRT command instead of PORT by using --disable-eprt. EPRT is really\n"
" PORT++.\n"
"\n"
" Since 7.19.5, you can append \":[start]-[end]\" to the right of the\n"
, stdout);
fputs(
" address, to tell curl what TCP port range to use. That means you spec-\n"
" ify a port range, from a lower to a higher number. A single number\n"
" works as well, but do note that it increases the risk of failure since\n"
" the port may not be available.\n"
"\n"
" See also --ftp-pasv and --disable-eprt.\n"
"\n"
" --ftp-pret\n"
" (FTP) Tell curl to send a PRET command before PASV (and EPSV).\n"
" Certain FTP servers, mainly drftpd, require this non-standard\n"
, stdout);
fputs(
" command for directory listings as well as up and downloads in\n"
" PASV mode.\n"
"\n"
" Added in 7.20.0.\n"
"\n"
" --ftp-skip-pasv-ip\n"
" (FTP) Tell curl to not use the IP address the server suggests in\n"
" its response to curl's PASV command when curl connects the data\n"
" connection. Instead curl will re-use the same IP address it\n"
" already uses for the control connection.\n"
"\n"
, stdout);
fputs(
" This option has no effect if PORT, EPRT or EPSV is used instead\n"
" of PASV.\n"
"\n"
" See also --ftp-pasv. Added in 7.14.2.\n"
"\n"
" --ftp-ssl-ccc-mode <active/passive>\n"
" (FTP) Sets the CCC mode. The passive mode will not initiate the\n"
" shutdown, but instead wait for the server to do it, and will not\n"
" reply to the shutdown from the server. The active mode initiates\n"
, stdout);
fputs(
" the shutdown and waits for a reply from the server.\n"
"\n"
" See also --ftp-ssl-ccc. Added in 7.16.2.\n"
"\n"
" --ftp-ssl-ccc\n"
" (FTP) Use CCC (Clear Command Channel) Shuts down the SSL/TLS\n"
" layer after authenticating. The rest of the control channel com-\n"
" munication will be unencrypted. This allows NAT routers to fol-\n"
" low the FTP transaction. The default mode is passive.\n"
"\n"
, stdout);
fputs(
" See also --ssl and --ftp-ssl-ccc-mode. Added in 7.16.1.\n"
"\n"
" --ftp-ssl-control\n"
" (FTP) Require SSL/TLS for the FTP login, clear for transfer.\n"
" Allows secure authentication, but non-encrypted data transfers\n"
" for efficiency. Fails the transfer if the server doesn't sup-\n"
" port SSL/TLS.\n"
"\n"
" Added in 7.16.0.\n"
"\n"
" -G, --get\n"
" When used, this option will make all data specified with -d,\n"
, stdout);
fputs(
" --data, --data-binary or --data-urlencode to be used in an HTTP\n"
" GET request instead of the POST request that otherwise would be\n"
" used. The data will be appended to the URL with a '?' separator.\n"
" If used in combination with -I, --head, the POST data will\n"
" instead be appended to the URL with a HEAD request.\n"
"\n"
" If this option is used several times, only the first one is\n"
, stdout);
fputs(
" used. This is because undoing a GET doesn't make sense, but you\n"
" should then instead enforce the alternative method you prefer.\n"
"\n"
" -g, --globoff\n"
" This option switches off the \"URL globbing parser\". When you set\n"
" this option, you can specify URLs that contain the letters {}[]\n"
" without having them being interpreted by curl itself. Note that\n"
" these letters are not normal legal URL contents but they should\n"
, stdout);
fputs(
" be encoded according to the URI standard.\n"
"\n"
" -I, --head\n"
" (HTTP FTP FILE) Fetch the headers only! HTTP-servers feature the\n"
" command HEAD which this uses to get nothing but the header of a\n"
" document. When used on an FTP or FILE file, curl displays the\n"
" file size and last modification time only.\n"
"\n"
" -H, --header <header>\n"
" (HTTP) Extra header to include in the request when sending HTTP\n"
, stdout);
fputs(
" to a server. You may specify any number of extra headers. Note\n"
" that if you should add a custom header that has the same name as\n"
" one of the internal ones curl would use, your externally set\n"
" header will be used instead of the internal one. This allows you\n"
" to make even trickier stuff than curl would normally do. You\n"
" should not replace internally set headers without knowing per-\n"
, stdout);
fputs(
" fectly well what you're doing. Remove an internal header by giv-\n"
" ing a replacement without content on the right side of the\n"
" colon, as in: -H \"Host:\". If you send the custom header with no-\n"
" value then its header must be terminated with a semicolon, such\n"
" as -H \"X-Custom-Header;\" to send \"X-Custom-Header:\".\n"
"\n"
" curl will make sure that each header you add/replace is sent\n"
, stdout);
fputs(
" with the proper end-of-line marker, you should thus not add that\n"
" as a part of the header content: do not add newlines or carriage\n"
" returns, they will only mess things up for you.\n"
"\n"
" See also the -A, --user-agent and -e, --referer options.\n"
"\n"
" Starting in 7.37.0, you need --proxy-header to send custom head-\n"
" ers intended for a proxy.\n"
"\n"
" Example:\n"
"\n"
" curl -H \"X-First-Name: Joe\" http://example.com/\n"
, stdout);
fputs(
"\n"
" WARNING: headers set with this option will be set in all\n"
" requests - even after redirects are followed, like when told\n"
" with -L, --location. This can lead to the header being sent to\n"
" other hosts than the original host, so sensitive headers should\n"
" be used with caution combined with following redirects.\n"
"\n"
" This option can be used multiple times to add/replace/remove\n"
" multiple headers.\n"
"\n"
, stdout);
fputs(
" -h, --help\n"
" Usage help. This lists all current command line options with a\n"
" short description.\n"
" --hostpubmd5 <md5>\n"
" (SFTP SCP) Pass a string containing 32 hexadecimal digits. The\n"
" string should be the 128 bit MD5 checksum of the remote host's\n"
" public key, curl will refuse the connection with the host unless\n"
" the md5sums match.\n"
"\n"
" Added in 7.17.1.\n"
"\n"
" -0, --http1.0\n"
, stdout);
fputs(
" (HTTP) Tells curl to use HTTP version 1.0 instead of using its\n"
" internally preferred HTTP version.\n"
"\n"
" This option overrides --http1.1 and --http2.\n"
"\n"
" --http1.1\n"
" (HTTP) Tells curl to use HTTP version 1.1.\n"
"\n"
" This option overrides -0, --http1.0 and --http2. Added in\n"
" 7.33.0.\n"
"\n"
" --http2-prior-knowledge\n"
" (HTTP) Tells curl to issue its non-TLS HTTP requests using\n"
, stdout);
fputs(
" HTTP/2 without HTTP/1.1 Upgrade. It requires prior knowledge\n"
" that the server supports HTTP/2 straight away. HTTPS requests\n"
" will still do HTTP/2 the standard way with negotiated protocol\n"
" version in the TLS handshake.\n"
"\n"
" --http2-prior-knowledge requires that the underlying libcurl was\n"
" built to support HTTP/2. This option overrides --http1.1 and -0,\n"
" --http1.0 and --http2. Added in 7.49.0.\n"
"\n"
, stdout);
fputs(
" --http2\n"
" (HTTP) Tells curl to use HTTP version 2.\n"
"\n"
" See also --no-alpn. --http2 requires that the underlying libcurl\n"
" was built to support HTTP/2. This option overrides --http1.1 and\n"
" -0, --http1.0 and --http2-prior-knowledge. Added in 7.33.0.\n"
"\n"
" --ignore-content-length\n"
" (FTP HTTP) For HTTP, Ignore the Content-Length header. This is\n"
" particularly useful for servers running Apache 1.x, which will\n"
, stdout);
fputs(
" report incorrect Content-Length for files larger than 2 giga-\n"
" bytes.\n"
"\n"
" For FTP (since 7.46.0), skip the RETR command to figure out the\n"
" size before downloading a file.\n"
"\n"
" -i, --include\n"
" Include the HTTP-header in the output. The HTTP-header includes\n"
" things like server-name, date of the document, HTTP-version and\n"
" more...\n"
"\n"
" See also -v, --verbose.\n"
"\n"
" -k, --insecure\n"
, stdout);
fputs(
" (TLS) By default, every SSL connection curl makes is verified to\n"
" be secure. This option allows curl to proceed and operate even\n"
" for server connections otherwise considered insecure.\n"
"\n"
" The server connection is verified by making sure the server's\n"
" certificate contains the right name and verifies successfully\n"
" using the cert store.\n"
"\n"
" See this online resource for further details:\n"
, stdout);
fputs(
" https://curl.haxx.se/docs/sslcerts.html\n"
" See also --proxy-insecure and --cacert.\n"
"\n"
" --interface <name>\n"
"\n"
" Perform an operation using a specified interface. You can enter\n"
" interface name, IP address or host name. An example could look\n"
" like:\n"
"\n"
" curl --interface eth0:1 https://www.example.com/\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
, stdout);
fputs(
" See also --dns-interface.\n"
"\n"
" -4, --ipv4\n"
" This option tells curl to resolve names to IPv4 addresses only,\n"
" and not for example try IPv6.\n"
"\n"
" See also --http1.1 and --http2. This option overrides -6,\n"
" --ipv6.\n"
"\n"
" -6, --ipv6\n"
" This option tells curl to resolve names to IPv6 addresses only,\n"
" and not for example try IPv4.\n"
"\n"
, stdout);
fputs(
" See also --http1.1 and --http2. This option overrides -6,\n"
" --ipv6.\n"
"\n"
" -j, --junk-session-cookies\n"
" (HTTP) When curl is told to read cookies from a given file, this\n"
" option will make it discard all \"session cookies\". This will\n"
" basically have the same effect as if a new session is started.\n"
" Typical browsers always discard session cookies when they're\n"
" closed down.\n"
"\n"
, stdout);
fputs(
" See also -b, --cookie and -c, --cookie-jar.\n"
"\n"
" --keepalive-time <seconds>\n"
" This option sets the time a connection needs to remain idle\n"
" before sending keepalive probes and the time between individual\n"
" keepalive probes. It is currently effective on operating systems\n"
" offering the TCP_KEEPIDLE and TCP_KEEPINTVL socket options\n"
" (meaning Linux, recent AIX, HP-UX and more). This option has no\n"
, stdout);
fputs(
" effect if --no-keepalive is used.\n"
"\n"
" If this option is used several times, the last one will be used.\n"
" If unspecified, the option defaults to 60 seconds.\n"
"\n"
" Added in 7.18.0.\n"
"\n"
" --key-type <type>\n"
" (TLS) Private key file type. Specify which type your --key pro-\n"
" vided private key is. DER, PEM, and ENG are supported. If not\n"
" specified, PEM is assumed.\n"
"\n"
, stdout);
fputs(
" If this option is used several times, the last one will be used.\n"
"\n"
" --key <key>\n"
" (TLS SSH) Private key file name. Allows you to provide your pri-\n"
" vate key in this separate file. For SSH, if not specified, curl\n"
" tries the following candidates in order:\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" --krb <level>\n"
" (FTP) Enable Kerberos authentication and use. The level must be\n"
, stdout);
fputs(
" entered and should be one of 'clear', 'safe', 'confidential', or\n"
" 'private'. Should you use a level that is not one of these,\n"
" 'private' will instead be used.\n"
"\n"
" If this option is used several times, the last one will be used.\n"
" --krb requires that the underlying libcurl was built to support\n"
" Kerberos.\n"
"\n"
" --libcurl <file>\n"
" Append this option to any ordinary curl command line, and you\n"
, stdout);
fputs(
" will get a libcurl-using C source code written to the file that\n"
" does the equivalent of what your command-line operation does!\n"
"\n"
" If this option is used several times, the last given file name\n"
" will be used.\n"
"\n"
" Added in 7.16.1.\n"
"\n"
" --limit-rate <speed>\n"
" Specify the maximum transfer rate you want curl to use - for\n"
" both downloads and uploads. This feature is useful if you have a\n"
, stdout);
fputs(
" limited pipe and you'd like your transfer not to use your entire\n"
" bandwidth. To make it slower than it otherwise would be.\n"
"\n"
" The given speed is measured in bytes/second, unless a suffix is\n"
" appended. Appending 'k' or 'K' will count the number as kilo-\n"
" bytes, 'm' or M' makes it megabytes, while 'g' or 'G' makes it\n"
" gigabytes. Examples: 200K, 3m and 1G.\n"
"\n"
, stdout);
fputs(
" If you also use the -Y, --speed-limit option, that option will\n"
" take precedence and might cripple the rate-limiting slightly, to\n"
" help keeping the speed-limit logic working.\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" -l, --list-only\n"
" (FTP POP3) (FTP) When listing an FTP directory, this switch\n"
" forces a name-only view. This is especially useful if the user\n"
, stdout);
fputs(
" wants to machine-parse the contents of an FTP directory since\n"
" the normal directory view doesn't use a standard look or format.\n"
" When used like this, the option causes a NLST command to be sent\n"
" to the server instead of LIST.\n"
"\n"
" Note: Some FTP servers list only files in their response to\n"
" NLST; they do not include sub-directories and symbolic links.\n"
"\n"
, stdout);
fputs(
" (POP3) When retrieving a specific email from POP3, this switch\n"
" forces a LIST command to be performed instead of RETR. This is\n"
" particularly useful if the user wants to see if a specific mes-\n"
" sage id exists on the server and what size it is.\n"
"\n"
" Note: When combined with -X, --request, this option can be used\n"
" to send an UIDL command instead, so the user may use the email's\n"
, stdout);
fputs(
" unique identifier rather than it's message id to make the\n"
" request.\n"
"\n"
" Added in 7.21.5.\n"
"\n"
" --local-port <num/range>\n"
" Set a preferred single number or range (FROM-TO) of local port\n"
" numbers to use for the connection(s). Note that port numbers by\n"
" nature are a scarce resource that will be busy at times so set-\n"
" ting this range to something too narrow might cause unnecessary\n"
, stdout);
fputs(
" connection setup failures.\n"
"\n"
" Added in 7.15.2.\n"
"\n"
" --location-trusted\n"
" (HTTP) Like -L, --location, but will allow sending the name +\n"
" password to all hosts that the site may redirect to. This may or\n"
" may not introduce a security breach if the site redirects you to\n"
" a site to which you'll send your authentication info (which is\n"
" plaintext in the case of HTTP Basic authentication).\n"
"\n"
, stdout);
fputs(
" See also -u, --user.\n"
"\n"
" -L, --location\n"
" (HTTP) If the server reports that the requested page has moved\n"
" to a different location (indicated with a Location: header and a\n"
" 3XX response code), this option will make curl redo the request\n"
" on the new place. If used together with -i, --include or -I,\n"
" --head, headers from all requested pages will be shown. When\n"
, stdout);
fputs(
" authentication is used, curl only sends its credentials to the\n"
" initial host. If a redirect takes curl to a different host, it\n"
" won't be able to intercept the user+password. See also --loca-\n"
" tion-trusted on how to change this. You can limit the amount of\n"
" redirects to follow by using the --max-redirs option.\n"
"\n"
" When curl follows a redirect and the request is not a plain GET\n"
, stdout);
fputs(
" (for example POST or PUT), it will do the following request with\n"
" a GET if the HTTP response was 301, 302, or 303. If the response\n"
" code was any other 3xx code, curl will re-send the following\n"
" request using the same unmodified method.\n"
"\n"
" You can tell curl to not change the non-GET request method to\n"
" GET after a 30x response by using the dedicated options for\n"
, stdout);
fputs(
" that: --post301, --post302 and --post303.\n"
"\n"
" --login-options <options>\n"
" (IMAP POP3 SMTP) Specify the login options to use during server\n"
" authentication.\n"
"\n"
" You can use the login options to specify protocol specific\n"
" options that may be used during authentication. At present only\n"
" IMAP, POP3 and SMTP support login options. For more information\n"
, stdout);
fputs(
" about the login options please see RFC 2384, RFC 5092 and IETF\n"
" draft draft-earhart-url-smtp-00.txt\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" Added in 7.34.0.\n"
"\n"
" --mail-auth <address>\n"
" (SMTP) Specify a single address. This will be used to specify\n"
" the authentication address (identity) of a submitted message\n"
" that is being relayed to another server.\n"
"\n"
, stdout);
fputs(
" See also --mail-rcpt and --mail-from. Added in 7.25.0.\n"
"\n"
" --mail-from <address>\n"
" (SMTP) Specify a single address that the given mail should get\n"
" sent from.\n"
"\n"
" See also --mail-rcpt and --mail-auth. Added in 7.20.0.\n"
"\n"
" --mail-rcpt <address>\n"
" (SMTP) Specify a single address, user name or mailing list name.\n"
" Repeat this option several times to send to multiple recipients.\n"
, stdout);
fputs(
" When performing a mail transfer, the recipient should specify a\n"
" valid email address to send the mail to.\n"
"\n"
" When performing an address verification (VRFY command), the\n"
" recipient should be specified as the user name or user name and\n"
" domain (as per Section 3.5 of RFC5321). (Added in 7.34.0)\n"
"\n"
" When performing a mailing list expand (EXPN command), the recip-\n"
, stdout);
fputs(
" ient should be specified using the mailing list name, such as\n"
" \"Friends\" or \"London-Office\". (Added in 7.34.0)\n"
"\n"
" Added in 7.20.0.\n"
"\n"
" -M, --manual\n"
" Manual. Display the huge help text.\n"
"\n"
" --max-filesize <bytes>\n"
" Specify the maximum size (in bytes) of a file to download. If\n"
" the file requested is larger than this value, the transfer will\n"
" not start and curl will return with exit code 63.\n"
"\n"
, stdout);
fputs(
" NOTE: The file size is not always known prior to download, and\n"
" for such files this option has no effect even if the file trans-\n"
" fer ends up being larger than this given limit. This concerns\n"
" both FTP and HTTP transfers.\n"
"\n"
" See also --limit-rate.\n"
"\n"
" --max-redirs <num>\n"
" (HTTP) Set maximum number of redirection-followings allowed.\n"
, stdout);
fputs(
" When -L, --location is used, is used to prevent curl from fol-\n"
" lowing redirections \"in absurdum\". By default, the limit is set\n"
" to 50 redirections. Set this option to -1 to make it unlimited.\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" -m, --max-time <time>\n"
" Maximum time in seconds that you allow the whole operation to\n"
, stdout);
fputs(
" take. This is useful for preventing your batch jobs from hang-\n"
" ing for hours due to slow networks or links going down. Since\n"
" 7.32.0, this option accepts decimal values, but the actual time-\n"
" out will decrease in accuracy as the specified timeout increases\n"
" in decimal precision.\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" See also --connect-timeout.\n"
"\n"
" --metalink\n"
, stdout);
fputs(
" This option can tell curl to parse and process a given URI as\n"
" Metalink file (both version 3 and 4 (RFC 5854) are supported)\n"
" and make use of the mirrors listed within for failover if there\n"
" are errors (such as the file or server not being available). It\n"
" will also verify the hash of the file after the download com-\n"
" pletes. The Metalink file itself is downloaded and processed in\n"
, stdout);
fputs(
" memory and not stored in the local file system.\n"
"\n"
" Example to use a remote Metalink file:\n"
"\n"
" curl --metalink http://www.example.com/example.metalink\n"
"\n"
" To use a Metalink file in the local file system, use FILE proto-\n"
" col (file://):\n"
"\n"
" curl --metalink file://example.metalink\n"
"\n"
" Please note that if FILE protocol is disabled, there is no way\n"
, stdout);
fputs(
" to use a local Metalink file at the time of this writing. Also\n"
" note that if --metalink and -i, --include are used together,\n"
" --include will be ignored. This is because including headers in\n"
" the response will break Metalink parser and if the headers are\n"
" included in the file described in Metalink file, hash check will\n"
" fail.\n"
"\n"
" --metalink requires that the underlying libcurl was built to\n"
, stdout);
fputs(
" support metalink. Added in 7.27.0.\n"
"\n"
" --negotiate\n"
" (HTTP) Enables Negotiate (SPNEGO) authentication.\n"
"\n"
" This option requires a library built with GSS-API or SSPI sup-\n"
" port. Use -V, --version to see if your curl supports GSS-\n"
" API/SSPI or SPNEGO.\n"
"\n"
" When using this option, you must also provide a fake -u, --user\n"
" option to activate the authentication code properly. Sending a\n"
, stdout);
fputs(
" '-u :' is enough as the user name and password from the -u,\n"
" --user option aren't actually used.\n"
"\n"
" If this option is used several times, only the first one is\n"
" used.\n"
"\n"
" See also --basic and --ntlm and --anyauth and --proxy-negotiate.\n"
"\n"
" --netrc-file <filename>\n"
" This option is similar to -n, --netrc, except that you provide\n"
" the path (absolute or relative) to the netrc file that Curl\n"
, stdout);
fputs(
" should use. You can only specify one netrc file per invocation.\n"
" If several --netrc-file options are provided, the last one will\n"
" be used.\n"
"\n"
" It will abide by --netrc-optional if specified.\n"
"\n"
" This option overrides -n, --netrc. Added in 7.21.5.\n"
"\n"
" --netrc-optional\n"
" Very similar to -n, --netrc, but this option makes the .netrc\n"
" usage optional and not mandatory as the -n, --netrc option does.\n"
"\n"
, stdout);
fputs(
" See also --netrc-file. This option overrides -n, --netrc.\n"
"\n"
" -n, --netrc\n"
" Makes curl scan the .netrc (_netrc on Windows) file in the\n"
" user's home directory for login name and password. This is typi-\n"
" cally used for FTP on Unix. If used with HTTP, curl will enable\n"
" user authentication. See netrc(5) ftp(1) for details on the file\n"
" format. Curl will not complain if that file doesn't have the\n"
, stdout);
fputs(
" right permissions (it should not be either world- or group-read-\n"
" able). The environment variable \"HOME\" is used to find the home\n"
" directory.\n"
"\n"
" A quick and very simple example of how to setup a .netrc to\n"
" allow curl to FTP to the machine host.domain.com with user name\n"
" 'myself' and password 'secret' should look similar to:\n"
"\n"
" machine host.domain.com login myself password secret\n"
"\n"
" -:, --next\n"
, stdout);
fputs(
" Tells curl to use a separate operation for the following URL and\n"
" associated options. This allows you to send several URL\n"
" requests, each with their own specific options, for example,\n"
" such as different user names or custom requests for each.\n"
"\n"
" -:, --next will reset all local options and only global ones\n"
" will have their values survive over to the operation following\n"
, stdout);
fputs(
" the -:, --next instruction. Global options include -v, --ver-\n"
" bose, --trace, --trace-ascii and --fail-early.\n"
"\n"
" For example, you can do both a GET and a POST in a single com-\n"
" mand line:\n"
"\n"
" curl www1.example.com --next -d postthis www2.example.com\n"
"\n"
" Added in 7.36.0.\n"
"\n"
" --no-alpn\n"
" (HTTPS) Disable the ALPN TLS extension. ALPN is enabled by\n"
, stdout);
fputs(
" default if libcurl was built with an SSL library that supports\n"
" ALPN. ALPN is used by a libcurl that supports HTTP/2 to negoti-\n"
" ate HTTP/2 support with the server during https sessions.\n"
"\n"
" See also --no-npn and --http2. --no-alpn requires that the\n"
" underlying libcurl was built to support TLS. Added in 7.36.0.\n"
"\n"
" -N, --no-buffer\n"
" Disables the buffering of the output stream. In normal work sit-\n"
, stdout);
fputs(
" uations, curl will use a standard buffered output stream that\n"
" will have the effect that it will output the data in chunks, not\n"
" necessarily exactly when the data arrives. Using this option\n"
" will disable that buffering.\n"
"\n"
" Note that this is the negated option name documented. You can\n"
" thus use --buffer to enforce the buffering.\n"
"\n"
" --no-keepalive\n"
, stdout);
fputs(
" Disables the use of keepalive messages on the TCP connection.\n"
" curl otherwise enables them by default.\n"
"\n"
" Note that this is the negated option name documented. You can\n"
" thus use --keepalive to enforce keepalive.\n"
"\n"
" --no-npn\n"
" (HTTPS) Disable the NPN TLS extension. NPN is enabled by default\n"
" if libcurl was built with an SSL library that supports NPN. NPN\n"
, stdout);
fputs(
" is used by a libcurl that supports HTTP/2 to negotiate HTTP/2\n"
" support with the server during https sessions.\n"
"\n"
" See also --no-alpn and --http2. --no-npn requires that the\n"
" underlying libcurl was built to support TLS. Added in 7.36.0.\n"
"\n"
" --no-sessionid\n"
" (TLS) Disable curl's use of SSL session-ID caching. By default\n"
" all transfers are done using the cache. Note that while nothing\n"
, stdout);
fputs(
" should ever get hurt by attempting to reuse SSL session-IDs,\n"
" there seem to be broken SSL implementations in the wild that may\n"
" require you to disable this in order for you to succeed.\n"
"\n"
" Note that this is the negated option name documented. You can\n"
" thus use --sessionid to enforce session-ID caching.\n"
"\n"
" Added in 7.16.0.\n"
"\n"
" --noproxy <no-proxy-list>\n"
, stdout);
fputs(
" Comma-separated list of hosts which do not use a proxy, if one\n"
" is specified. The only wildcard is a single * character, which\n"
" matches all hosts, and effectively disables the proxy. Each name\n"
" in this list is matched as either a domain which contains the\n"
" hostname, or the hostname itself. For example, local.com would\n"
" match local.com, local.com:80, and www.local.com, but not\n"
, stdout);
fputs(
" www.notlocal.com.\n"
"\n"
" Since 7.53.0, This option overrides the environment variables\n"
" that disable the proxy. If there's an environment variable dis-\n"
" abling a proxy, you can set noproxy list to \"\" to override it.\n"
"\n"
" Added in 7.19.4.\n"
"\n"
" --ntlm-wb\n"
" (HTTP) Enables NTLM much in the style --ntlm does, but hand over\n"
" the authentication to the separate binary ntlmauth application\n"
, stdout);
fputs(
" that is executed when needed.\n"
"\n"
" See also --ntlm and --proxy-ntlm.\n"
"\n"
" --ntlm (HTTP) Enables NTLM authentication. The NTLM authentication\n"
" method was designed by Microsoft and is used by IIS web servers.\n"
" It is a proprietary protocol, reverse-engineered by clever peo-\n"
" ple and implemented in curl based on their efforts. This kind of\n"
" behavior should not be endorsed, you should encourage everyone\n"
, stdout);
fputs(
" who uses NTLM to switch to a public and documented authentica-\n"
" tion method instead, such as Digest.\n"
"\n"
" If you want to enable NTLM for your proxy authentication, then\n"
" use --proxy-ntlm.\n"
"\n"
" If this option is used several times, only the first one is\n"
" used.\n"
"\n"
" See also --proxy-ntlm. --ntlm requires that the underlying\n"
, stdout);
fputs(
" libcurl was built to support TLS. This option overrides --basic\n"
" and --negotiated and --digest and --anyauth.\n"
"\n"
" --oauth2-bearer <token>\n"
" (IMAP POP3 SMTP) Specify the Bearer Token for OAUTH 2.0 server\n"
" authentication. The Bearer Token is used in conjunction with the\n"
" user name which can be specified as part of the --url or -u,\n"
" --user options.\n"
"\n"
, stdout);
fputs(
" The Bearer Token and user name are formatted according to RFC\n"
" 6750.\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" -o, --output <file>\n"
" Write output to <file> instead of stdout. If you are using {} or\n"
" [] to fetch multiple documents, you can use '#' followed by a\n"
" number in the <file> specifier. That variable will be replaced\n"
, stdout);
fputs(
" with the current string for the URL being fetched. Like in:\n"
"\n"
" curl http://{one,two}.example.com -o \"file_#1.txt\"\n"
"\n"
" or use several variables like:\n"
"\n"
" curl http://{site,host}.host[1-5].com -o \"#1_#2\"\n"
"\n"
" You may use this option as many times as the number of URLs you\n"
" have. For example, if you specify two URLs on the same command\n"
" line, you can use it like this:\n"
"\n"
, stdout);
fputs(
" curl -o aa example.com -o bb example.net\n"
"\n"
" and the order of the -o options and the URLs doesn't matter,\n"
" just that the first -o is for the first URL and so on, so the\n"
" above command line can also be written as\n"
"\n"
" curl example.com example.net -o aa -o bb\n"
"\n"
" See also the --create-dirs option to create the local directo-\n"
" ries dynamically. Specifying the output as '-' (a single dash)\n"
, stdout);
fputs(
" will force the output to be done to stdout.\n"
"\n"
" See also -O, --remote-name and --remote-name-all and -J,\n"
" --remote-header-name.\n"
"\n"
" --pass <phrase>\n"
" (SSH TLS) Passphrase for the private key\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" --path-as-is\n"
" Tell curl to not handle sequences of /../ or /./ in the given\n"
, stdout);
fputs(
" URL path. Normally curl will squash or merge them according to\n"
" standards but with this option set you tell it not to do that.\n"
"\n"
" Added in 7.42.0.\n"
"\n"
" --pinnedpubkey <hashes>\n"
" (TLS) Tells curl to use the specified public key file (or\n"
" hashes) to verify the peer. This can be a path to a file which\n"
" contains a single public key in PEM or DER format, or any number\n"
, stdout);
fputs(
" of base64 encoded sha256 hashes preceded by 'sha256//' and sepa-\n"
" rated by ';'\n"
"\n"
" When negotiating a TLS or SSL connection, the server sends a\n"
" certificate indicating its identity. A public key is extracted\n"
" from this certificate and if it does not exactly match the pub-\n"
" lic key provided to this option, curl will abort the connection\n"
" before sending or receiving any data.\n"
"\n"
, stdout);
fputs(
" PEM/DER support:\n"
" 7.39.0: OpenSSL, GnuTLS and GSKit\n"
" 7.43.0: NSS and wolfSSL/CyaSSL\n"
" 7.47.0: mbedtls\n"
" 7.49.0: PolarSSL sha256 support:\n"
" 7.44.0: OpenSSL, GnuTLS, NSS and wolfSSL/CyaSSL.\n"
" 7.47.0: mbedtls\n"
" 7.49.0: PolarSSL Other SSL backends not supported.\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" --post301\n"
, stdout);
fputs(
" (HTTP) Tells curl to respect RFC 7231/6.4.2 and not convert POST\n"
" requests into GET requests when following a 301 redirection. The\n"
" non-RFC behaviour is ubiquitous in web browsers, so curl does\n"
" the conversion by default to maintain consistency. However, a\n"
" server may require a POST to remain a POST after such a redi-\n"
" rection. This option is meaningful only when using -L, --loca-\n"
" tion.\n"
"\n"
, stdout);
fputs(
" See also --post302 and --post303 and -L, --location. Added in\n"
" 7.17.1.\n"
"\n"
" --post302\n"
" (HTTP) Tells curl to respect RFC 7231/6.4.3 and not convert POST\n"
" requests into GET requests when following a 302 redirection. The\n"
" non-RFC behaviour is ubiquitous in web browsers, so curl does\n"
" the conversion by default to maintain consistency. However, a\n"
, stdout);
fputs(
" server may require a POST to remain a POST after such a redi-\n"
" rection. This option is meaningful only when using -L, --loca-\n"
" tion.\n"
"\n"
" See also --post301 and --post303 and -L, --location. Added in\n"
" 7.19.1.\n"
"\n"
" --post303\n"
" (HTTP) Tells curl to respect RFC 7231/6.4.4 and not convert POST\n"
" requests into GET requests when following a 303 redirection. The\n"
, stdout);
fputs(
" non-RFC behaviour is ubiquitous in web browsers, so curl does\n"
" the conversion by default to maintain consistency. However, a\n"
" server may require a POST to remain a POST after such a redi-\n"
" rection. This option is meaningful only when using -L, --loca-\n"
" tion.\n"
"\n"
" See also --post302 and --post301 and -L, --location. Added in\n"
" 7.26.0.\n"
"\n"
" --preproxy [protocol://]host[:port]\n"
, stdout);
fputs(
" Use the specified SOCKS proxy before connecting to an HTTP or\n"
" HTTPS -x, --proxy. In such a case curl first connects to the\n"
" SOCKS proxy and then connects (through SOCKS) to the HTTP or\n"
" HTTPS proxy. Hence pre proxy.\n"
"\n"
" The pre proxy string should be specified with a protocol:// pre-\n"
" fix to specify alternative proxy protocols. Use socks4://,\n"
, stdout);
fputs(
" socks4a://, socks5:// or socks5h:// to request the specific\n"
" SOCKS version to be used. No protocol specified will make curl\n"
" default to SOCKS4.\n"
"\n"
" If the port number is not specified in the proxy string, it is\n"
" assumed to be 1080.\n"
"\n"
" User and password that might be provided in the proxy string are\n"
" URL decoded by curl. This allows you to pass in special charac-\n"
, stdout);
fputs(
" ters such as @ by using %40 or pass in a colon with %3a.\n"
"\n"
" If this option is used several times, the last one will be used.\n"
"\n"
" Added in 7.52.0.\n"
"\n"
" -#, --progress-bar\n"
" Make curl display transfer progress as a simple progress bar\n"
" instead of the standard, more informational, meter.\n"
"\n"
" This progress bar draws a single line of '#' characters across\n"
, stdout);
fputs(
" the screen and shows a percentage if the transfer size is known.\n"
" For transfers without a known size, it will instead output one\n"
" '#' character for every 1024 bytes transferred.\n"
"\n"
" --proto-default <protocol>\n"
" Tells curl to use protocol for any URL missing a scheme name.\n"
"\n"
" Example:\n"
"\n"
" curl --proto-default https ftp.mozilla.org\n"
"\n"
" An unknown or unsupported protocol causes error CURLE_UNSUP-\n"
, stdout);
fputs(
" PORTED_PROTOCOL (1).\n"
"\n"
" This option does not change the default proxy protocol (http).\n"
"\n"
" Without this option curl would make a guess based on the host,\n"
" see --url for details.\n"
"\n"
" Added in 7.45.0.\n"
"\n"
" --proto-redir <protocols>\n"
" Tells curl to limit what protocols it may use on redirect. Pro-\n"
" tocols denied by --proto are not overridden by this option. See\n"
, stdout);
fputs(
" --proto for how protocols are represented.\n"
"\n"
" Example, allow only HTTP and HTTPS on redirect:\n"
"\n"
" curl --proto-redir -all,http,https http://example.com\n"
"\n"
" By default curl will allow all protocols on redirect except sev-\n"
" eral disabled for security reasons: Since 7.19.4 FILE and SCP\n"
" are disabled, and since 7.40.0 SMB and SMBS are also disabled.\n"
, stdout);
fputs(
" Specifying all or +all enables all protocols on redirect,\n"
" including those disabled for security.\n"
"\n"
" Added in 7.20.2.\n"
"\n"
" --proto <protocols>\n"
" Tells curl to limit what protocols it may use in the transfer.\n"
" Protocols are evaluated left to right, are comma separated, and\n"
" are each a protocol name or\n"
"\n"
" + Permit this protocol in addition to protocols already permit-\n"
, stdout);
fputs(
" ted (this is the default if no modifier is used).\n"
"\n"
" - Deny this protocol, removing it from the list of protocols\n"
" already permitted.\n"
"\n"
" = Permit only this protocol (ignoring the list already permit-\n"
" ted), though subject to later modification by subsequent\n"
" entries in the comma separated list.\n"
"\n"
" For example:\n"
"\n"
" --proto -ftps uses the default protocols, but disables ftps\n"
, stdout);
fputs(
"\n"
" --proto -all,https,+http\n"
" only enables http and https\n"
"\n"
" --proto =http,https\n"
" also only enables http and https\n"
"\n"
" Unknown protocols produce a warning. This allows scripts to safely rely\n"
" on being able to disable potentially dangerous protocols, without rely-\n"
" ing upon support for that protocol being built into curl to avoid an\n"
" error.\n"
"\n"
, stdout);
fputs(
" This option can be used multiple times, in which case the effect is the\n"
" same as concatenating the protocols into one instance of the option.\n"
"\n"
" See also --proto-redir and --proto-default. Added in 7.20.2.\n"
"\n"
" --proxy-anyauth\n"
" Tells curl to pick a suitable authentication method when commu-\n"
" nicating with the given HTTP proxy. This might cause an extra\n"
" request/response round-trip.\n"
"\n"
, stdout);
fputs(
" See also -x, --proxy and --proxy-basic and --proxy-digest. Added\n"
" in 7.13.2.\n"
"\n"
" --proxy-basic\n"
" Tells curl to use HTTP Basic authentication when communicating\n"
" with the given proxy. Use --basic for enabling HTTP Basic with a\n"
" remote host. Basic is the default authentication method curl\n"
" uses with proxies.\n"
"\n"
" See also -x, --proxy and --proxy-anyauth and --proxy-digest.\n"
"\n"
, stdout);
fputs(
" --proxy-cacert <file>\n"
" Same as --cacert but used in HTTPS proxy context.\n"
"\n"
" See also --proxy-capath and --cacert and --capath and -x,\n"
" --proxy. Added in 7.52.0.\n"
"\n"
" --proxy-capath <dir>\n"
" Same as --capath but used in HTTPS proxy context.\n"
"\n"
" See also --proxy-cacert and -x, --proxy and --capath. Added in\n"
" 7.52.0.\n"
"\n"
" --proxy-cert-type <type>\n"
, stdout);
fputs(
" Same as --cert-type but used in HTTPS proxy context.\n"
"\n"
" Added in 7.52.0.\n"
"\n"
" --proxy-cert <cert[:passwd]>\n"
" Same as -E, --cert but used in HTTPS proxy context.\n"
| [
"993273596@qq.com"
] | 993273596@qq.com |
6628b57792d36421aa72d56202e41ba28bd2db47 | 160fc43099ce45ed954b3315d8a1b76a145b864e | /basic_Slave.ino | 0c071249468fc1530677c7a32f517413d904394f | [] | no_license | hakim2307/ASEF_D | 60cdf1736070cdceb08f860da0fec9818ac7d372 | 1d9943f14c939a82f90234f6bedef9ab9ea72d60 | refs/heads/master | 2021-07-15T22:00:34.021195 | 2017-10-18T13:49:32 | 2017-10-18T13:49:32 | 107,412,195 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,215 | ino | #include <SoftwareSerial.h>
SoftwareSerial mySerial(10, 11);// RX AND TX
int state = 0;
const int pushbutton = 2;
const int Vibrator = 8;
int pb = 0;
int vb = 0;
void setup() {
// initialize digital pin 8 as an output.
Serial.begin(9600);
mySerial.begin(9600);
pinMode(pushbutton , INPUT );
pinMode(Vibrator , OUTPUT );
}
void loop() {
pb = digitalRead(pushbutton);
if(pb == HIGH){//masukakn digitalwrite dekat sini utk buzzer
int h = 50;
mySerial.write(h);
// Serial.println( h);
}
if(pb == LOW){
int o = 30;
mySerial.write(o);
// Serial.println(o);
}
if (mySerial.available() > 0) { // Checks whether data is comming from the serial port
state = mySerial.read(); // Reads the data from the serial port
}
// Serial.println(state);
// delay(1000);
if(state == 0){
Serial.println(" OFF" );
digitalWrite(Vibrator, LOW);
delay(20);
}
else if (state == 1){
Serial.println("ON");
digitalWrite(Vibrator, HIGH);
delay(20);
}
else if (state == 2){
Serial.println("GAS");
digitalWrite(Vibrator, HIGH);
delay(20);
}
}
| [
"noreply@github.com"
] | noreply@github.com |
bc359518e012a901d179b76f3cff6c677fb36704 | 094efc7e79b748d00929a90eb417af44ebf5eb49 | /SmartCarBluetoothKeyboard/SmartCarBluetoothKeyboard.ino | 96db47fc3ef7e5540f38f80d0aebe6e608dd6026 | [] | no_license | javiergarciaescobedo/SmartCar | 770566bbdeb12c02a808931a695549b74f2ecf67 | 765caf77cd99cb02ad44ac076cd251adfcd38aa1 | refs/heads/master | 2021-01-22T11:06:56.756595 | 2018-06-07T08:32:01 | 2018-06-07T08:32:01 | 51,717,595 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,502 | ino | int enA = 5; // Pin enA de la tarjeta controladora L298N
int in1 = 8; // Pin in1 " " " " "
int in2 = 9; // Pin in2 " " " " "
// MOTOR 2
// Pines de conexión en la tarjeta Arduino
int in3 = 12; // Pin in3 de la tarjeta controladora L298N
int in4 = 13; // Pin in4 " " " " "
int enB = 11; // Pin enB " " " " "
void setup()
{
Serial.begin(9600); //Iniciar el serial
pinMode(enA, OUTPUT);
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
pinMode(in3, OUTPUT);
pinMode(in4, OUTPUT);
pinMode(enB, OUTPUT);
analogWrite(enA, 0);
analogWrite(enB, 0);
}
void loop()
{
if(Serial.available()>=1) {
char entrada = Serial.read(); //Leer un caracter
if(entrada == 'w' or entrada == 'W') {
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
analogWrite(enA, 255);
digitalWrite(in3, HIGH);
digitalWrite(in4, LOW);
analogWrite(enB, 255);
} else if(entrada == 's' or entrada == 'S') {
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
analogWrite(enA, 255);
digitalWrite(in3, LOW);
digitalWrite(in4, HIGH);
analogWrite(enB, 255);
} else if(entrada == 'x' or entrada == 'X') {
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
analogWrite(enA, 0);
digitalWrite(in3, HIGH);
digitalWrite(in4, LOW);
analogWrite(enB, 0);
}
}
}
| [
"correo@javiergarciaescobedo.es"
] | correo@javiergarciaescobedo.es |
17d6c632263241e25dfe6a3db0a40be8a6d26adc | 227e3b12fdf0375b329a94b8e4440f5cc3b86e4b | /Classes/MusicSelect.cpp | 182338a924d7080fab37013c6c42201ff0d9447c | [] | no_license | KyoheiOkawa/SlideTheGlassSourceCode | 424b975aa7243d2023120248b65634da8a0db3e2 | c4b6f2c5a50a4c26161ad8629dd5189255546f31 | refs/heads/master | 2021-01-21T21:26:36.255162 | 2017-06-20T03:55:21 | 2017-06-20T03:55:21 | 94,846,610 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,429 | cpp | //
// MusicSelect.cpp
// SlideTheGlass
//
// Created by 大川恭平 on 2017/05/04.
//
//
#include "Common.h"
USING_NS_CC;
bool MusicSelect::init()
{
if(!LayerColor::initWithColor(Color4B(0,0,0,150)))
return false;
auto origin = Director::getInstance()->getVisibleOrigin();
auto vs = Director::getInstance()->getVisibleSize();
float offset = 10.0f;
//真ん中上に配置するラベル
auto musicSelect = Label::createWithTTF("MusicSelect", USE_FONT_PATH, 64);
musicSelect->setAnchorPoint(Vec2::ANCHOR_MIDDLE_TOP);
musicSelect->setPosition(origin + Vec2(vs.width/2.0f,vs.height - offset));
this->addChild(musicSelect);
//レイヤーを閉じる（非表示にする）ボタン
auto batsuBt = ui::Button::create("Textures/batsu.png");
batsuBt->setAnchorPoint(Vec2::ANCHOR_TOP_RIGHT);
batsuBt->setPosition(origin + Vec2(vs.width-offset,vs.height-offset));
batsuBt->addTouchEventListener(CC_CALLBACK_2(MusicSelect::onBatsuButton, this));
this->addChild(batsuBt);
//MusMus様のHPのURLを開くボタン
auto musmusBt = ui::Button::create("Textures/MusMus.png");
musmusBt->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
musmusBt->setPosition(origin + Vec2(offset,offset));
musmusBt->setScale(0.8f);
musmusBt->addTouchEventListener(CC_CALLBACK_2(MusicSelect::onMusMusButton, this));
this->addChild(musmusBt);
//------------------------------------------------------------
//スクロールビューの作成
auto scrollView = ui::ScrollView::create();
scrollView->setDirection(ui::ScrollView::Direction::VERTICAL);
scrollView->setBounceEnabled(true);
scrollView->setPosition(origin+Vec2((vs.width-700)/2.0f,0));
this->addChild(scrollView);
auto selectLayer = LayerColor::create(Color4B(0,0,0,200), 700, 63*BGM_COUNT+offset*2*(BGM_COUNT+1));
selectLayer->setPosition(Vec2::ZERO);
auto selectLayerSz = selectLayer->getContentSize();
for(int i = 0; i < BGM_COUNT; ++i)
{
auto bt = ui::Button::create("Textures/frame.png");
bt->setName(BGM_NAME[i]);
bt->setSwallowTouches(false);
bt->addClickEventListener(CC_CALLBACK_1(MusicSelect::musicChange, this));
bt->setAnchorPoint(Vec2::ANCHOR_MIDDLE_TOP);
bt->setPosition(origin+Vec2(selectLayerSz.width/2.0f,selectLayerSz.height - offset * 2 - bt->getContentSize().height * i - offset * 2 * i));
auto lb = Label::createWithTTF(BGM_NAME[i], USE_FONT_PATH, 42);
lb->setPosition(bt->getContentSize()/2.0f);
bt->addChild(lb);
selectLayer->addChild(bt);
}
scrollView->addChild(selectLayer);
scrollView->setInnerContainerSize(selectLayer->getContentSize());
scrollView->setContentSize(Size(700,vs.height-musicSelect->getContentSize().height - offset));
//------------------------------------------------------------
this->setVisible(false);
_touchListener = EventListenerTouchOneByOne::create();
_touchListener->onTouchBegan = CC_CALLBACK_2(MusicSelect::onTouchBegan, this);
_touchListener->setSwallowTouches(false);
this->getEventDispatcher()->addEventListenerWithSceneGraphPriority(_touchListener, this);
return true;
}
bool MusicSelect::onTouchBegan(Touch* touch, Event* event)
{
return true;
}
void MusicSelect::onBatsuButton(Ref* pSender, ui::Widget::TouchEventType type)
{
switch (type) {
case ui::Widget::TouchEventType::ENDED:
this->setVisible(false);
_touchListener->setSwallowTouches(false);
break;
default:
break;
}
}
void MusicSelect::onMusMusButton(Ref* pSender, ui::Widget::TouchEventType type)
{
switch (type) {
case ui::Widget::TouchEventType::ENDED:
Application::getInstance()->openURL("http://musmus.main.jp/");
break;
default:
break;
}
}
void MusicSelect::musicChange(Ref* pSender)
{
auto bt = (ui::Button*)pSender;
float distance = bt->getTouchBeganPosition().distance(bt->getTouchEndPosition());
if(10 > distance){
auto audio = SimpleAudioEngine::getInstance();
audio->stopBackgroundMusic(true);
std::string music = BGM + '/' + bt->getName() + ".mp3";
audio->playBackgroundMusic(music.c_str(),true);
}
}
| [
"kurokenken0310@gmail.com"
] | kurokenken0310@gmail.com |
18e8aece969fe8b4052af3c4e6dd4ccb4ab4b6ec | 0c014d8805267a927d161694157e065a36b5728d | /packet_entity.hpp | 1d5fd025b2bfa32e49bea7a93036609b6bd069b6 | [
"ISC"
] | permissive | devilesk/dota-replay-parser | 2de3fd6b142847696f671d1c85104369775970c1 | e83b96ee513a7193e6703615df4f676e27b1b8a0 | refs/heads/master | 2021-01-09T05:35:15.786448 | 2017-02-20T13:52:01 | 2017-02-20T13:52:01 | 80,762,984 | 2 | 2 | null | 2017-02-03T22:42:06 | 2017-02-02T19:56:19 | C++ | UTF-8 | C++ | false | false | 190 | hpp | #ifndef _PACKET_ENTITY_HPP_
#define _PACKET_ENTITY_HPP_
#include <iostream>
#include "bitstream.hpp"
#include "parser_types.hpp"
#include "property.hpp"
#endif /* _PACKET_ENTITY_HPP_ */ | [
"devilesk@gmail.com"
] | devilesk@gmail.com |
b0288b28d31244a9bbaa6792107f247eb9ead178 | f4294865b87cd8ea15f716278fb667a5bff67fb5 | /Eigen/src/Core/Dot.h | 1676dc99912c4a55a008afde2049494eba9f7c14 | [
"Apache-2.0"
] | permissive | markrenChina/savitzky_golay | 37f6f9a6daa325608cf877238c5676f450267bd0 | 007262472017ce092d281fa220a8b6e92f87109d | refs/heads/main | 2023-04-26T12:35:20.637207 | 2021-05-21T01:14:32 | 2021-05-21T01:14:32 | 369,377,623 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,751 | h | // This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2006-2008, 2010 Benoit Jacob <jacob.benoit.1@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
#ifndef EIGEN_DOT_H
#define EIGEN_DOT_H
namespace Eigen {
namespace internal {
// helper function for dot(). The problem is that if we put that in the body of dot(), then upon calling dot
// with mismatched types, the compiler emits errors about failing to instantiate cwiseProduct BEFORE
// looking at the static assertions. Thus this is a trick to get better compile errors.
template<typename T, typename U,
// the NeedToTranspose condition here is taken straight from Assign.h
bool NeedToTranspose = T::IsVectorAtCompileTime
&& U::IsVectorAtCompileTime
&& ((int(T::RowsAtCompileTime) == 1 && int(U::ColsAtCompileTime) == 1)
|
// FIXME | instead of || to please GCC 4.4.0 stupid warning "suggest parentheses around &&".
// revert to || as soon as not needed anymore.
(int(T::ColsAtCompileTime) == 1 && int(U::RowsAtCompileTime) == 1))
>
struct dot_nocheck {
typedef scalar_conj_product_op<typename traits<T>::Scalar, typename traits<U>::Scalar> conj_prod;
typedef typename conj_prod::result_type ResScalar;
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE
static ResScalar run(const MatrixBase <T> &a, const MatrixBase <U> &b) {
return a.template binaryExpr<conj_prod>(b).sum();
}
};
template<typename T, typename U>
struct dot_nocheck<T, U, true> {
typedef scalar_conj_product_op<typename traits<T>::Scalar, typename traits<U>::Scalar> conj_prod;
typedef typename conj_prod::result_type ResScalar;
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE
static ResScalar run(const MatrixBase <T> &a, const MatrixBase <U> &b) {
return a.transpose().template binaryExpr<conj_prod>(b).sum();
}
};
} // end namespace internal
/** \fn MatrixBase::dot
* \returns the dot product of *this with other.
*
* \only_for_vectors
*
* \note If the scalar type is complex numbers, then this function returns the hermitian
* (sesquilinear) dot product, conjugate-linear in the first variable and linear in the
* second variable.
*
* \sa squaredNorm(), norm()
*/
template<typename Derived>
template<typename OtherDerived>
EIGEN_DEVICE_FUNC
EIGEN_STRONG_INLINE
typename ScalarBinaryOpTraits<typename internal::traits<Derived>::Scalar, typename internal::traits<OtherDerived>::Scalar>::ReturnType
MatrixBase<Derived>::dot(const MatrixBase <OtherDerived> &other) const {
EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
EIGEN_STATIC_ASSERT_VECTOR_ONLY(OtherDerived)
EIGEN_STATIC_ASSERT_SAME_VECTOR_SIZE(Derived, OtherDerived)
#if !(defined(EIGEN_NO_STATIC_ASSERT) && defined(EIGEN_NO_DEBUG))
typedef internal::scalar_conj_product_op<Scalar, typename OtherDerived::Scalar> func;
EIGEN_CHECK_BINARY_COMPATIBILIY(func, Scalar, typename OtherDerived::Scalar);
#endif
eigen_assert(size() == other.size());
return internal::dot_nocheck<Derived, OtherDerived>::run(*this, other);
}
//---------- implementation of L2 norm and related functions ----------
/** \returns, for vectors, the squared \em l2 norm of \c *this, and for matrices the Frobenius norm.
* In both cases, it consists in the sum of the square of all the matrix entries.
* For vectors, this is also equals to the dot product of \c *this with itself.
*
* \sa dot(), norm(), lpNorm()
*/
template<typename Derived>
EIGEN_STRONG_INLINE typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
MatrixBase<Derived>::squaredNorm() const {
return numext::real((*this).cwiseAbs2().sum());
}
/** \returns, for vectors, the \em l2 norm of \c *this, and for matrices the Frobenius norm.
* In both cases, it consists in the square root of the sum of the square of all the matrix entries.
* For vectors, this is also equals to the square root of the dot product of \c *this with itself.
*
* \sa lpNorm(), dot(), squaredNorm()
*/
template<typename Derived>
EIGEN_STRONG_INLINE typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
MatrixBase<Derived>::norm() const {
return numext::sqrt(squaredNorm());
}
/** \returns an expression of the quotient of \c *this by its own norm.
*
* \warning If the input vector is too small (i.e., this->norm()==0),
* then this function returns a copy of the input.
*
* \only_for_vectors
*
* \sa norm(), normalize()
*/
template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::PlainObject
MatrixBase<Derived>::normalized() const {
typedef typename internal::nested_eval<Derived, 2>::type _Nested;
_Nested n(derived());
RealScalar z = n.squaredNorm();
// NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
if (z > RealScalar(0))
return n / numext::sqrt(z);
else
return n;
}
/** Normalizes the vector, i.e. divides it by its own norm.
*
* \only_for_vectors
*
* \warning If the input vector is too small (i.e., this->norm()==0), then \c *this is left unchanged.
*
* \sa norm(), normalized()
*/
template<typename Derived>
EIGEN_STRONG_INLINE void MatrixBase<Derived>::normalize() {
RealScalar z = squaredNorm();
// NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
if (z > RealScalar(0))
derived() /= numext::sqrt(z);
}
/** \returns an expression of the quotient of \c *this by its own norm while avoiding underflow and overflow.
*
* \only_for_vectors
*
* This method is analogue to the normalized() method, but it reduces the risk of
* underflow and overflow when computing the norm.
*
* \warning If the input vector is too small (i.e., this->norm()==0),
* then this function returns a copy of the input.
*
* \sa stableNorm(), stableNormalize(), normalized()
*/
template<typename Derived>
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::PlainObject
MatrixBase<Derived>::stableNormalized() const {
typedef typename internal::nested_eval<Derived, 3>::type _Nested;
_Nested n(derived());
RealScalar w = n.cwiseAbs().maxCoeff();
RealScalar z = (n / w).squaredNorm();
if (z > RealScalar(0))
return n / (numext::sqrt(z) * w);
else
return n;
}
/** Normalizes the vector while avoid underflow and overflow
*
* \only_for_vectors
*
* This method is analogue to the normalize() method, but it reduces the risk of
* underflow and overflow when computing the norm.
*
* \warning If the input vector is too small (i.e., this->norm()==0), then \c *this is left unchanged.
*
* \sa stableNorm(), stableNormalized(), normalize()
*/
template<typename Derived>
EIGEN_STRONG_INLINE void MatrixBase<Derived>::stableNormalize() {
RealScalar w = cwiseAbs().maxCoeff();
RealScalar z = (derived() / w).squaredNorm();
if (z > RealScalar(0))
derived() /= numext::sqrt(z) * w;
}
//---------- implementation of other norms ----------
namespace internal {
template<typename Derived, int p>
struct lpNorm_selector {
typedef typename NumTraits<typename traits<Derived>::Scalar>::Real RealScalar;
EIGEN_DEVICE_FUNC
static inline RealScalar run(const MatrixBase <Derived> &m) {
EIGEN_USING_STD_MATH(pow)
return pow(m.cwiseAbs().array().pow(p).sum(), RealScalar(1) / p);
}
};
template<typename Derived>
struct lpNorm_selector<Derived, 1> {
EIGEN_DEVICE_FUNC
static inline typename NumTraits<typename traits<Derived>::Scalar>::Real
run(const MatrixBase <Derived> &m) {
return m.cwiseAbs().sum();
}
};
template<typename Derived>
struct lpNorm_selector<Derived, 2> {
EIGEN_DEVICE_FUNC
static inline typename NumTraits<typename traits<Derived>::Scalar>::Real
run(const MatrixBase <Derived> &m) {
return m.norm();
}
};
template<typename Derived>
struct lpNorm_selector<Derived, Infinity> {
typedef typename NumTraits<typename traits<Derived>::Scalar>::Real RealScalar;
EIGEN_DEVICE_FUNC
static inline RealScalar run(const MatrixBase <Derived> &m) {
if (Derived::SizeAtCompileTime == 0 || (Derived::SizeAtCompileTime == Dynamic && m.size() == 0))
return RealScalar(0);
return m.cwiseAbs().maxCoeff();
}
};
} // end namespace internal
/** \returns the \b coefficient-wise \f$ \ell^p \f$ norm of \c *this, that is, returns the p-th root of the sum of the p-th powers of the absolute values
* of the coefficients of \c *this. If \a p is the special value \a Eigen::Infinity, this function returns the \f$ \ell^\infty \f$
* norm, that is the maximum of the absolute values of the coefficients of \c *this.
*
* In all cases, if \c *this is empty, then the value 0 is returned.
*
* \note For matrices, this function does not compute the <a href="https://en.wikipedia.org/wiki/Operator_norm">operator-norm</a>. That is, if \c *this is a matrix, then its coefficients are interpreted as a 1D vector. Nonetheless, you can easily compute the 1-norm and \f$\infty\f$-norm matrix operator norms using \link TutorialReductionsVisitorsBroadcastingReductionsNorm partial reductions \endlink.
*
* \sa norm()
*/
template<typename Derived>
template<int p>
#ifndef EIGEN_PARSED_BY_DOXYGEN
inline typename NumTraits<typename internal::traits<Derived>::Scalar>::Real
#else
MatrixBase<Derived>::RealScalar
#endif
MatrixBase<Derived>::lpNorm() const {
return internal::lpNorm_selector<Derived, p>::run(*this);
}
//---------- implementation of isOrthogonal / isUnitary ----------
/** \returns true if *this is approximately orthogonal to \a other,
* within the precision given by \a prec.
*
* Example: \include MatrixBase_isOrthogonal.cpp
* Output: \verbinclude MatrixBase_isOrthogonal.out
*/
template<typename Derived>
template<typename OtherDerived>
bool MatrixBase<Derived>::isOrthogonal
(const MatrixBase <OtherDerived> &other, const RealScalar &prec) const {
typename internal::nested_eval<Derived, 2>::type nested(derived());
typename internal::nested_eval<OtherDerived, 2>::type otherNested(other.derived());
return numext::abs2(nested.dot(otherNested)) <= prec * prec * nested.squaredNorm() * otherNested.squaredNorm();
}
/** \returns true if *this is approximately an unitary matrix,
* within the precision given by \a prec. In the case where the \a Scalar
* type is real numbers, a unitary matrix is an orthogonal matrix, whence the name.
*
* \note This can be used to check whether a family of vectors forms an orthonormal basis.
* Indeed, \c m.isUnitary() returns true if and only if the columns (equivalently, the rows) of m form an
* orthonormal basis.
*
* Example: \include MatrixBase_isUnitary.cpp
* Output: \verbinclude MatrixBase_isUnitary.out
*/
template<typename Derived>
bool MatrixBase<Derived>::isUnitary(const RealScalar &prec) const {
typename internal::nested_eval<Derived, 1>::type self(derived());
for (Index i = 0; i < cols(); ++i) {
if (!internal::isApprox(self.col(i).squaredNorm(), static_cast<RealScalar>(1), prec))
return false;
for (Index j = 0; j < i; ++j)
if (!internal::isMuchSmallerThan(self.col(i).dot(self.col(j)), static_cast<Scalar>(1), prec))
return false;
}
return true;
}
} // end namespace Eigen
#endif // EIGEN_DOT_H
| [
"390835144@qq.com"
] | 390835144@qq.com |
5e400c619f3e9ae503d7af88c142f4d085e9ec32 | f401d88a69c957015f6d0484ade477e8ae2af7a3 | /Singleton/main.cpp | 13dd5cf38cb67472f54e3544d998e351d764d8e6 | [] | no_license | DaleChen0351/DesignPattern | c0968c472e234017b5aabb3f7889d2ddf7da7dac | c48b381f0340373eb62c2ddc6c663a09fb00b3c9 | refs/heads/master | 2020-09-08T03:05:31.955643 | 2020-01-06T10:45:33 | 2020-01-06T10:45:33 | 220,996,514 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 239 | cpp | // Singleton.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include "pch.h"
#include <iostream>
int main()
{
std::cout << "Hello World!\n";
Singleton* mySing = Singleton::getInstance();
}
| [
"dalechen0351@gmail.com"
] | dalechen0351@gmail.com |
8fcf369c2b67cebd0ffaa766a86e554091194a5f | 2f55c9c9cc67712df3f9c12f6f81650fb3f7f1d0 | /processor7/0/ccz | 2689da908e96fe4870229953b84617d0dd585a6c | [] | no_license | bhqasx/Learning-openFoam-case | 86677c25948a2c0ac767be406a9356c2d2907ef9 | 159304b7e5d3579a1dfb3f20dc5ad8be79683222 | refs/heads/main | 2023-07-09T21:27:17.128564 | 2021-08-20T01:15:51 | 2021-08-20T01:15:51 | 397,872,602 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 406,499 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 2.3.1 |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "0";
object ccz;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 1 0 0 0 0 0];
internalField nonuniform List<scalar>
37692
(
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
)
;
boundaryField
{
top
{
type symmetryPlane;
}
inlet
{
type calculated;
value nonuniform 0();
}
outlet
{
type calculated;
value nonuniform 0();
}
outletConnectMaster
{
type calculated;
value nonuniform 0();
}
walls
{
type calculated;
value nonuniform List<scalar>
6687
(
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.005625
0.016875
0.028125
0.039375
0.050625
0.061875
0.073125
0.084375
0.095625
0.106875
0.118125
0.129375
0.140625
0.151875
0.163125
0.174375
0.185625
0.196875
0.208125
0.219375
0.230625
0.241875
0.253125
0.264375
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.276023
0.288068
0.300114
0.312159
0.324205
0.33625
0.348295
0.360341
0.372386
0.384432
0.396477
0.408523
0.420568
0.432614
0.444659
0.456705
0.46875
0.480795
0.492841
0.504886
0.516932
0.528977
0.541023
0.553068
0.565114
0.577159
0.589205
0.60125
0.613295
0.625341
0.637386
0.649432
0.661477
0.673523
0.685568
0.697614
0.709659
0.721705
0.73375
0.745795
0.757841
0.769886
0.781932
0.793977
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0.80625
0.81875
0.83125
0.84375
0.85625
0.86875
0.88125
0.89375
0.90625
0.91875
0.93125
0.94375
0.95625
0.96875
0.98125
0.99375
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
)
;
}
procBoundary7to5
{
type processor;
value nonuniform List<scalar>
1092
(
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
)
;
}
procBoundary7to6
{
type processor;
value nonuniform List<scalar>
1075
(
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.005625
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.016875
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.028125
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.039375
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.050625
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.061875
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.073125
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.084375
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.095625
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.106875
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.118125
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.129375
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.140625
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.151875
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.163125
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.174375
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.185625
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.196875
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.208125
0.219375
0.230625
0.219375
0.230625
0.219375
0.230625
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.219375
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.230625
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.241875
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.253125
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.264375
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.276023
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.288068
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.300114
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.312159
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.324205
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.33625
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.348295
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.360341
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.372386
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.384432
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.396477
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.408523
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.420568
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.432614
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.444659
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.456705
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.46875
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.480795
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.492841
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.504886
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.516932
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.528977
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.541023
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.553068
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.565114
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.577159
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.589205
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.60125
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.613295
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.625341
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.637386
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.649432
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.661477
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.673523
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.685568
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.697614
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.709659
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.721705
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.73375
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.745795
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.757841
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.769886
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.781932
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.793977
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.80625
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.81875
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.83125
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.84375
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.85625
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.86875
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.88125
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.89375
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.90625
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.91875
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.93125
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.94375
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.95625
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.96875
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.98125
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
0.99375
)
;
}
}
// ************************************************************************* //
| [
"815810395@qq.com"
] | 815810395@qq.com | |
fb745c8320812a787530aafcd716c0a57ec4d759 | 54c6f47140f54fe84923762485d19a597914a424 | /gui/Vdu.h | 1bb93c75c45f98d48a73d03cc35e268cb7bd0e72 | [] | no_license | nzx9/Linux-Edsac | 603170a6e31ce2c300016ee5a58f808aa2ff80e0 | 3418095153191957a9fde6551e2fa61a78df3a0e | refs/heads/master | 2023-01-27T16:36:40.580856 | 2020-12-13T22:50:04 | 2020-12-13T22:50:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 883 | h | #ifndef _VDU_H
#define _VDU_H
#include <SmrFramework.h>
#include <SmrAppFramework.h>
using namespace SmrFramework;
class Vdu : public Control {
protected:
UInt32 lines[32];
Byte mode;
Byte tank;
Boolean showGrid;
void cycleSingle(UInt32 hi, UInt32 lo,UInt32 y, Byte start);
void cycleStore();
void redrawSingle(UInt32 hi, UInt32 lo,UInt32 y, Byte start);
void redrawStore();
public:
static const Byte Memory = 0;
static const Byte Counter = 1;
static const Byte Scr = 2;
static const Byte Order = 3;
static const Byte Accumulator = 4;
static const Byte Multiplier = 5;
Vdu(Control* parent, int x, int y, int w, int h);
~Vdu();
virtual void Cycle();
virtual void Mode(Byte m);
virtual void Redraw();
virtual void ShowGrid(Boolean b);
virtual void Tank(Byte t);
};
#endif
| [
"mikehriley@hotmail.com"
] | mikehriley@hotmail.com |
caec620f4f37aec42011bf44c43156eb8aea23a8 | 07fb5486913887aa2c47e238bee7f353469320e0 | /src/caffe/util/mpi.cpp | c33bbd444bbf35d9d0c2aa9860bd521a72ead29d | [
"LicenseRef-scancode-generic-cla",
"BSD-2-Clause"
] | permissive | arnaldotav/Caffe-MPI.github.io | 597b390711389bc1f081d53f4fe27eef8f348188 | 6c2c34743583af695e8eb9fc6c946371142c3b39 | refs/heads/master | 2021-01-12T02:05:39.581899 | 2016-11-23T06:12:30 | 2016-11-23T06:12:30 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,075 | cpp | #include "caffe/common.hpp"
#include "caffe/util/mpi.hpp"
#include <execinfo.h>
namespace caffe {
template<>
int caffe_mpi_send<float>(void *buf, int count, int dest, int tag,
MPI_Comm comm) {
/*
int j, nptrs;
void *buffer[100];
char **strings;
nptrs = backtrace(buffer, 3);
strings = backtrace_symbols(buffer, nptrs);
for (j = 0; j < nptrs; j++)
printf("%s\n", strings[j]);
free(strings);
*/
// LOG(INFO)<<"MPI_SEND "<<buf<<" "<<count<<" "<<dest<<" "<<tag<<" ";
// int size=1024*1024*1024*1;
// char * bbuf= new char[size];
// MPI_Buffer_attach((void*)bbuf,size);
int ret=MPI_Send(buf, count, MPI_FLOAT, dest, tag,
comm);
// MPI_Buffer_detach((void*)bbuf,&size);
return ret;
}
template<>
int caffe_mpi_send<double>(void *buf, int count, int dest, int tag,
MPI_Comm comm) {
return MPI_Send(buf, count, MPI_DOUBLE, dest, tag,
comm);
}
int caffe_mpi_send(void *buf, int count, MPI_Datatype datatype, int dest, int tag,
MPI_Comm comm) {
return MPI_Send(buf, count, datatype, dest, tag,
comm);
}
template<>
int caffe_mpi_recv<float>(void *buf, int count, int dest, int tag,
MPI_Comm comm, MPI_Status *status) {
//LOG(INFO)<<"MPI_RECV "<<buf<<" "<<count<<" "<<dest<<" "<<tag<<" ";
int ret=MPI_Recv(buf, count, MPI_FLOAT, dest, tag,
comm, status);
return ret;
}
template<>
int caffe_mpi_recv<double>(void *buf, int count, int dest, int tag,
MPI_Comm comm, MPI_Status *status) {
return MPI_Recv(buf, count, MPI_DOUBLE, dest, tag,
comm, status);
}
int caffe_mpi_recv(void *buf, int count, MPI_Datatype datatype, int dest, int tag,
MPI_Comm comm, MPI_Status *status) {
return MPI_Recv(buf, count, datatype, dest, tag,
comm, status);
}
template <>
int caffe_mpi_isend<float>(void *buf, int count, int dest, int tag,
MPI_Comm comm, MPI_Request *req) {
return MPI_Isend(buf, count, MPI_FLOAT, dest, tag,comm, req);
}
template <>
int caffe_mpi_isend<double>(void *buf, int count, int dest, int tag,
MPI_Comm comm, MPI_Request *req) {
return MPI_Isend(buf, count, MPI_DOUBLE, dest, tag,comm, req);
}
int caffe_mpi_isend(void *buf, int count, MPI_Datatype datatype, int dest, int tag,
MPI_Comm comm, MPI_Request *req) {
return MPI_Isend(buf, count, datatype, dest, tag,comm, req);
}
template <>
int caffe_mpi_ssend<float>(void *buf, int count, int dest, int tag,
MPI_Comm comm) {
return MPI_Ssend(buf, count, MPI_FLOAT, dest, tag,comm);
}
template <>
int caffe_mpi_ssend<double>(void *buf, int count, int dest, int tag,
MPI_Comm comm) {
return MPI_Ssend(buf, count, MPI_DOUBLE, dest, tag,comm);
}
int caffe_mpi_ssend(void *buf, int count, MPI_Datatype datatype, int dest, int tag,
MPI_Comm comm) {
return MPI_Ssend(buf, count, datatype, dest, tag,comm);
}
} // namespace caffe
| [
"Caffe@inspur.com"
] | Caffe@inspur.com |
1becc2f14a95786792a00c31155f4c90e7f62de8 | 8dc84558f0058d90dfc4955e905dab1b22d12c08 | /components/mirroring/service/receiver_response_unittest.cc | 807a683f48d5e6d6da8cd55d9544e609ef75eb29 | [
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause"
] | permissive | meniossin/src | 42a95cc6c4a9c71d43d62bc4311224ca1fd61e03 | 44f73f7e76119e5ab415d4593ac66485e65d700a | refs/heads/master | 2022-12-16T20:17:03.747113 | 2020-09-03T10:43:12 | 2020-09-03T10:43:12 | 263,710,168 | 1 | 0 | BSD-3-Clause | 2020-05-13T18:20:09 | 2020-05-13T18:20:08 | null | UTF-8 | C++ | false | false | 10,338 | 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 "components/mirroring/service/receiver_response.h"
#include "base/base64.h"
#include "base/bind.h"
#include "base/callback.h"
#include "base/json/json_reader.h"
#include "base/macros.h"
#include "base/test/mock_callback.h"
#include "components/mirroring/service/value_util.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using ::testing::InvokeWithoutArgs;
using ::testing::_;
namespace mirroring {
class ReceiverResponseTest : public ::testing::Test {
public:
ReceiverResponseTest() {}
~ReceiverResponseTest() override {}
private:
DISALLOW_COPY_AND_ASSIGN(ReceiverResponseTest);
};
TEST_F(ReceiverResponseTest, ParseValidJson) {
const std::string response_string = "{\"type\":\"ANSWER\",\"result\":\"ok\"}";
ReceiverResponse response;
ASSERT_TRUE(response.Parse(response_string));
EXPECT_EQ(-1, response.session_id);
EXPECT_EQ(-1, response.sequence_number);
EXPECT_EQ(ResponseType::ANSWER, response.type);
EXPECT_EQ("ok", response.result);
EXPECT_FALSE(response.answer);
EXPECT_FALSE(response.status);
EXPECT_FALSE(response.capabilities);
EXPECT_FALSE(response.error);
EXPECT_TRUE(response.rpc.empty());
}
TEST_F(ReceiverResponseTest, ParseInvalidValueType) {
const std::string response_string =
"{\"sessionId\":123, \"seqNum\":\"one-two-three\"}";
ReceiverResponse response;
EXPECT_FALSE(response.Parse(response_string));
}
TEST_F(ReceiverResponseTest, ParseNonJsonString) {
const std::string response_string = "This is not JSON.";
ReceiverResponse response;
EXPECT_FALSE(response.Parse(response_string));
}
TEST_F(ReceiverResponseTest, ParseRealWorldAnswerMessage) {
const std::string response_string =
"{\"answer\":{\"receiverRtcpEventLog\":[0,1],\"rtpExtensions\":"
"[[\"adaptive_playout_delay\"],[\"adaptive_playout_delay\"]],"
"\"sendIndexes\":[0,1],\"ssrcs\":[40863,759293],\"udpPort\":50691,"
"\"castMode\":\"mirroring\"},\"result\":\"ok\",\"seqNum\":989031000,"
"\"type\":\"ANSWER\"}";
ReceiverResponse response;
ASSERT_TRUE(response.Parse(response_string));
EXPECT_EQ(-1, response.session_id);
EXPECT_EQ(989031000, response.sequence_number);
EXPECT_EQ(ResponseType::ANSWER, response.type);
EXPECT_EQ("ok", response.result);
ASSERT_TRUE(response.answer);
EXPECT_EQ(50691, response.answer->udp_port);
EXPECT_EQ(std::vector<int32_t>({0, 1}), response.answer->send_indexes);
EXPECT_EQ(std::vector<int32_t>({40863, 759293}), response.answer->ssrcs);
EXPECT_TRUE(response.answer->iv.empty());
EXPECT_EQ(false, response.answer->supports_get_status);
EXPECT_EQ("mirroring", response.answer->cast_mode);
EXPECT_FALSE(response.status);
EXPECT_FALSE(response.capabilities);
EXPECT_FALSE(response.error);
}
TEST_F(ReceiverResponseTest, ParseErrorMessage) {
const std::string response_string =
"{\"sessionId\": 123,"
"\"seqNum\": 999,"
"\"type\": \"ANSWER\","
"\"result\": \"error\","
"\"error\": {"
"\"code\": 42,"
"\"description\": \"it is broke\","
"\"details\": {\"foo\": -1, \"bar\": 88}"
"}"
"}";
ReceiverResponse response;
ASSERT_TRUE(response.Parse(response_string));
EXPECT_EQ(123, response.session_id);
EXPECT_EQ(999, response.sequence_number);
EXPECT_EQ(ResponseType::ANSWER, response.type);
EXPECT_EQ("error", response.result);
EXPECT_FALSE(response.answer);
EXPECT_FALSE(response.status);
EXPECT_FALSE(response.capabilities);
ASSERT_TRUE(response.error);
EXPECT_EQ(42, response.error->code);
EXPECT_EQ("it is broke", response.error->description);
std::unique_ptr<base::Value> parsed_details =
base::JSONReader::Read(response.error->details);
ASSERT_TRUE(parsed_details && parsed_details->is_dict());
EXPECT_EQ(2u, parsed_details->DictSize());
int fool_value = 0;
EXPECT_TRUE(GetInt(*parsed_details, "foo", &fool_value));
EXPECT_EQ(-1, fool_value);
int bar_value = 0;
EXPECT_TRUE(GetInt(*parsed_details, "bar", &bar_value));
EXPECT_EQ(88, bar_value);
}
TEST_F(ReceiverResponseTest, ParseStatusMessage) {
const std::string response_string =
"{\"seqNum\": 777,"
"\"type\": \"STATUS_RESPONSE\","
"\"result\": \"ok\","
"\"status\": {"
"\"wifiSnr\": 36.7,"
"\"wifiSpeed\": [1234, 5678, 3000, 3001],"
"\"wifiFcsError\": [12, 13, 12, 12]}" // This will be ignored.
"}";
ReceiverResponse response;
ASSERT_TRUE(response.Parse(response_string));
EXPECT_EQ(777, response.sequence_number);
EXPECT_EQ(ResponseType::STATUS_RESPONSE, response.type);
EXPECT_EQ("ok", response.result);
EXPECT_FALSE(response.error);
EXPECT_FALSE(response.answer);
ASSERT_TRUE(response.status);
EXPECT_EQ(36.7, response.status->wifi_snr);
const std::vector<int32_t> expect_speed({1234, 5678, 3000, 3001});
EXPECT_EQ(expect_speed, response.status->wifi_speed);
EXPECT_FALSE(response.capabilities);
}
TEST_F(ReceiverResponseTest, ParseCapabilityMessage) {
const std::string response_string =
"{\"sessionId\": 999888777,"
"\"seqNum\": 5551212,"
"\"type\": \"CAPABILITIES_RESPONSE\","
"\"result\": \"ok\","
"\"capabilities\": {"
"\"mediaCaps\": [\"audio\", \"video\", \"vp9\"],"
"\"keySystems\": ["
"{"
"\"keySystemName\": \"com.w3c.clearkey\""
"},"
"{"
"\"keySystemName\": \"com.widevine.alpha\","
"\"initDataTypes\": [\"a\", \"b\", \"c\", \"1\", \"2\", \"3\"],"
"\"codecs\": [\"vp8\", \"h264\"],"
"\"secureCodecs\": [\"h264\", \"vp8\"],"
"\"audioRobustness\": [\"nope\"],"
"\"videoRobustness\": [\"yep\"],"
"\"persistentLicenseSessionSupport\": \"SUPPORTED\","
"\"persistentReleaseMessageSessionSupport\": \"SUPPORTED_WITH_ID\","
"\"persistentStateSupport\": \"REQUESTABLE\","
"\"distinctiveIdentifierSupport\": \"ALWAYS_ENABLED\""
"}"
"]}}";
ReceiverResponse response;
ASSERT_TRUE(response.Parse(response_string));
EXPECT_EQ(999888777, response.session_id);
EXPECT_EQ(5551212, response.sequence_number);
EXPECT_EQ(ResponseType::CAPABILITIES_RESPONSE, response.type);
EXPECT_EQ("ok", response.result);
EXPECT_FALSE(response.error);
EXPECT_FALSE(response.answer);
EXPECT_FALSE(response.status);
ASSERT_TRUE(response.capabilities);
EXPECT_EQ(std::vector<std::string>({"audio", "video", "vp9"}),
response.capabilities->media_caps);
const ReceiverKeySystem& first_key_system =
response.capabilities->key_systems[0];
EXPECT_EQ("com.w3c.clearkey", first_key_system.name);
EXPECT_TRUE(first_key_system.init_data_types.empty());
EXPECT_TRUE(first_key_system.codecs.empty());
EXPECT_TRUE(first_key_system.secure_codecs.empty());
EXPECT_TRUE(first_key_system.audio_robustness.empty());
EXPECT_TRUE(first_key_system.video_robustness.empty());
EXPECT_TRUE(first_key_system.persistent_license_session_support.empty());
EXPECT_TRUE(
first_key_system.persistent_release_message_session_support.empty());
EXPECT_TRUE(first_key_system.persistent_state_support.empty());
EXPECT_TRUE(first_key_system.distinctive_identifier_support.empty());
const ReceiverKeySystem& second_key_system =
response.capabilities->key_systems[1];
EXPECT_EQ("com.widevine.alpha", second_key_system.name);
EXPECT_EQ(std::vector<std::string>({"a", "b", "c", "1", "2", "3"}),
second_key_system.init_data_types);
EXPECT_EQ(std::vector<std::string>({"vp8", "h264"}),
second_key_system.codecs);
EXPECT_EQ(std::vector<std::string>({"h264", "vp8"}),
second_key_system.secure_codecs);
EXPECT_EQ(std::vector<std::string>({"nope"}),
second_key_system.audio_robustness);
EXPECT_EQ(std::vector<std::string>({"yep"}),
second_key_system.video_robustness);
EXPECT_EQ("SUPPORTED", second_key_system.persistent_license_session_support);
EXPECT_EQ("SUPPORTED_WITH_ID",
second_key_system.persistent_release_message_session_support);
EXPECT_EQ("REQUESTABLE", second_key_system.persistent_state_support);
EXPECT_EQ("ALWAYS_ENABLED", second_key_system.distinctive_identifier_support);
}
TEST_F(ReceiverResponseTest, ParseRpcMessage) {
const std::string message = "Hello from the Cast Receiver!";
std::string rpc_base64;
base::Base64Encode(message, &rpc_base64);
std::string response_string =
"{\"sessionId\": 735189,"
"\"seqNum\": 6789,"
"\"type\": \"RPC\","
"\"result\": \"ok\","
"\"rpc\": \"" +
rpc_base64 + "\"}";
ReceiverResponse response;
ASSERT_TRUE(response.Parse(response_string));
EXPECT_EQ(735189, response.session_id);
EXPECT_EQ(6789, response.sequence_number);
EXPECT_EQ("ok", response.result);
EXPECT_EQ(ResponseType::RPC, response.type);
EXPECT_EQ(message, response.rpc);
EXPECT_FALSE(response.error);
EXPECT_FALSE(response.answer);
EXPECT_FALSE(response.status);
EXPECT_FALSE(response.capabilities);
}
TEST_F(ReceiverResponseTest, ParseResponseWithNullField) {
const std::string response_string =
"{\"sessionId\":null,\"seqNum\":808907000,\"type\":\"ANSWER\","
"\"result\":\"ok\",\"rpc\":null,\"error\":null,"
"\"answer\":{\"udpPort\":51706,\"sendIndexes\":[0,1],"
"\"ssrcs\":[152818,556029],\"IV\":null,\"receiverGetStatus\":true,"
"\"castMode\":\"mirroring\"},\"status\":null,\"capabilities\":null}";
ReceiverResponse response;
ASSERT_TRUE(response.Parse(response_string));
EXPECT_EQ(808907000, response.sequence_number);
EXPECT_EQ("ok", response.result);
EXPECT_FALSE(response.error);
EXPECT_FALSE(response.status);
EXPECT_FALSE(response.capabilities);
EXPECT_TRUE(response.rpc.empty());
EXPECT_EQ(ResponseType::ANSWER, response.type);
ASSERT_TRUE(response.answer);
EXPECT_EQ(51706, response.answer->udp_port);
EXPECT_EQ(std::vector<int32_t>({0, 1}), response.answer->send_indexes);
EXPECT_EQ(std::vector<int32_t>({152818, 556029}), response.answer->ssrcs);
EXPECT_TRUE(response.answer->iv.empty());
EXPECT_EQ(true, response.answer->supports_get_status);
EXPECT_EQ("mirroring", response.answer->cast_mode);
}
} // namespace mirroring
| [
"arnaud@geometry.ee"
] | arnaud@geometry.ee |
73d6fa49703a54589980360297130c55a1b401c6 | 3e1ac5a6f5473c93fb9d4174ced2e721a7c1ff4c | /build/iOS/Preview/include/Fuse.Elements.Element.DefaultDisposable.h | a7b1e69cf5b4eed6e9017b7391d9523ace2e8502 | [] | no_license | dream-plus/DreamPlus_popup | 49d42d313e9cf1c9bd5ffa01a42d4b7c2cf0c929 | 76bb86b1f2e36a513effbc4bc055efae78331746 | refs/heads/master | 2020-04-28T20:47:24.361319 | 2019-05-13T12:04:14 | 2019-05-13T12:04:14 | 175,556,703 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,225 | h | // This file was generated based on /usr/local/share/uno/Packages/Fuse.Elements/1.9.0/Element.UnoHostInterface.uno.
// WARNING: Changes might be lost if you edit this file directly.
#pragma once
#include <Uno.IDisposable.h>
#include <Uno.Object.h>
namespace g{namespace Fuse{namespace Elements{struct Element__DefaultDisposable;}}}
namespace g{
namespace Fuse{
namespace Elements{
// private sealed extern class Element.DefaultDisposable :11
// {
struct Element__DefaultDisposable_type : uType
{
::g::Uno::IDisposable interface0;
};
Element__DefaultDisposable_type* Element__DefaultDisposable_typeof();
void Element__DefaultDisposable__ctor__fn(Element__DefaultDisposable* __this);
void Element__DefaultDisposable__get_Instance_fn(uObject** __retval);
void Element__DefaultDisposable__New1_fn(Element__DefaultDisposable** __retval);
void Element__DefaultDisposable__UnoIDisposableDispose_fn(Element__DefaultDisposable* __this);
struct Element__DefaultDisposable : uObject
{
static uSStrong<uObject*> _instance_;
static uSStrong<uObject*>& _instance() { return _instance_; }
void ctor_();
static Element__DefaultDisposable* New1();
static uObject* Instance();
};
// }
}}} // ::g::Fuse::Elements
| [
"cowodbs156@gmail.com"
] | cowodbs156@gmail.com |
85f0873927a7b01283b7e01d8b148ce619f264d7 | 24201d4d7e1ed9a023d4c549f07a0c8725caa570 | /Engine/H/Graphics/Image.h | 8ba8bb424077d8707046373e58bc32b919b3db17 | [
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-other-permissive"
] | permissive | rastargame/EsenthelEngine | 97402529e152aa38eaaa89d2786ebe9bb980da00 | deccf86929c86b7fcf762039c3ba6afdeb5d8681 | refs/heads/master | 2023-07-16T16:40:52.136995 | 2021-08-22T08:33:28 | 2021-08-22T08:33:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 101,063 | h | /******************************************************************************
Use 'Image' for handling images (textures).
/******************************************************************************/
enum FILTER_TYPE : Byte // Filtering Type
{
FILTER_NONE , // 1.0000 speed, worst quality, uses 1x1 samples no 2D filtering
FILTER_LINEAR , // ~0.7500 speed, low quality, uses 2x2 samples in 2D filtering
FILTER_CUBIC_FAST , // ~0.1700 speed, high quality, uses 4x4 samples in 2D filtering, low sharpening is applied
FILTER_CUBIC_FAST_SMOOTH, // ~0.1700 speed, blurry quality, uses 4x4 samples in 2D filtering, no sharpening is applied, result will appear blurry however without aliasing
FILTER_CUBIC_FAST_SHARP , // ~0.1700 speed, high quality, uses 4x4 samples in 2D filtering, high sharpening is applied (best for down-scaling)
FILTER_CUBIC_PLUS , // ~0.1000 speed, high quality, uses 6x6 samples in 2D filtering, medium sharpening is applied (best for up-scaling)
FILTER_CUBIC_PLUS_SHARP , // ~0.1000 speed, high quality, uses 6x6 samples in 2D filtering, high sharpening is applied
FILTER_WAIFU , // ~0.0005 speed, super quality however super slow, this filter is available only if 'SupportFilterWaifu' was called inside 'InitPre', it's used only for up-scaling
FILTER_EASU , // high quality, AMD Edge Adaptive Spatial Upsampling, this filter is available only for up-scaling
FILTER_BEST , // automatically choose the best filter (currently FILTER_CUBIC_FAST_SHARP for down-scaling and FILTER_WAIFU for up-scaling)
FILTER_NO_STRETCH , // does not perform any stretching, pixels out of range are either wrapped or clamped
FILTER_NUM , // number of filters
#if EE_PRIVATE
FILTER_DOWN=FILTER_CUBIC_FAST_SHARP, // best filter used for down-scaling
#endif
};
/******************************************************************************/
enum LOCK_MODE : Byte
{
LOCK_NONE =0, // no lock
LOCK_READ =1, // lock for reading only
LOCK_WRITE =2, // lock for writing only (if the image is stored in the GPU then any previous image data may get lost when using this mode, use if you wish to replace the whole image data)
LOCK_READ_WRITE=3, // lock for reading and writing
#if EE_PRIVATE
LOCK_APPEND =4, // lock for writing only without overwriting existing data
#endif
};
/******************************************************************************/
enum IMAGE_TYPE : Byte // Image Type, comments specify in which mode the type is available (Soft: Software, DX10: DirectX 10, DX11: DirectX 11, GL: Desktop OpenGL, partial: may be supported on some devices but not all of them)
{
IMAGE_NONE, // none
IMAGE_R8G8B8A8 , // 32-bit (R,G,B,A), linear gamma, 0..1 unsigned, Soft, DX10+, GL, GL ES
IMAGE_R8G8B8A8_SRGB, // 32-bit (R,G,B,A), sRGB gamma, 0..1 unsigned, Soft, DX10+, GL, GL ES
IMAGE_R8G8B8A8_SIGN, // 32-bit (R,G,B,A), linear gamma, -1..1 signed, Soft, DX10+, GL, GL ES
IMAGE_R8G8B8 , // 24-bit (R,G,B,1), linear gamma, 0..1 unsigned, Soft
IMAGE_R8G8B8_SRGB , // 24-bit (R,G,B,1), sRGB gamma, 0..1 unsigned, Soft
IMAGE_R8G8 , // 16-bit (R,G,0,1), linear gamma, 0..1 unsigned, Soft, DX10+, GL, GL ES
IMAGE_R8G8_SIGN , // 16-bit (R,G,0,1), linear gamma, -1..1 signed, Soft, DX10+, GL, GL ES
IMAGE_R8 , // 8-bit (R,0,0,1), linear gamma, 0..1 unsigned, Soft, DX10+, GL, GL ES
IMAGE_R8_SIGN , // 8-bit (R,0,0,1), linear gamma, -1..1 signed, Soft, DX10+, GL, GL ES
IMAGE_R10G10B10A2, // 32-bit (R,G,B,A), linear gamma, 0..1 unsigned, Soft, DX10+, GL, GL ES
IMAGE_A8 , // 8-bit alpha (0,0,0,A), Soft, DX10+, GL, GL ES
IMAGE_L8 , // 8-bit luminance (L,L,L,1), linear gamma, Soft, GL, GL ES
IMAGE_L8_SRGB , // 8-bit luminance (L,L,L,1), sRGB gamma, Soft
IMAGE_L8A8 , // 16-bit luminance alpha (L,L,L,A), linear gamma, Soft, GL, GL ES
IMAGE_L8A8_SRGB, // 16-bit luminance alpha (L,L,L,A), sRGB gamma, Soft
IMAGE_I8 , // 8-bit integer , linear gamma, Soft
IMAGE_I16 , // 16-bit integer , linear gamma, Soft
IMAGE_I24 , // 24-bit integer , linear gamma, Soft
IMAGE_I32 , // 32-bit integer , linear gamma, Soft
IMAGE_F16 , // 16-bit float , linear gamma, Soft, DX10+, GL, GL ES
IMAGE_F32 , // 32-bit float , linear gamma, Soft, DX10+, GL, GL ES
IMAGE_F16_2 , // 2 x 16-bit float ( 32-bit total), linear gamma, Soft, DX10+, GL, GL ES
IMAGE_F32_2 , // 2 x 32-bit float ( 64-bit total), linear gamma, Soft, DX10+, GL, GL ES
IMAGE_F16_3 , // 3 x 16-bit float ( 48-bit total), linear gamma, Soft GL, GL ES
IMAGE_F32_3 , // 3 x 32-bit float ( 96-bit total), linear gamma, Soft, DX10+, GL, GL ES
IMAGE_F16_4 , // 4 x 16-bit float ( 64-bit total), linear gamma, Soft, DX10+, GL, GL ES
IMAGE_F32_4 , // 4 x 32-bit float (128-bit total), linear gamma, Soft, DX10+, GL, GL ES
IMAGE_F32_3_SRGB, // 3 x 32-bit float ( 96-bit total), sRGB gamma, Soft
IMAGE_F32_4_SRGB, // 4 x 32-bit float (128-bit total), sRGB gamma, Soft
// compressed format for Desktop
IMAGE_BC1 , // BC1/DXT1 4-bit lossy RGBA compression with 1-bit alpha , linear gamma, 0..1 unsigned, Soft, DX10+, GL, partial Android
IMAGE_BC1_SRGB, // BC1/DXT1 4-bit lossy RGBA compression with 1-bit alpha , sRGB gamma, 0..1 unsigned, Soft, DX10+, GL, partial Android
IMAGE_BC2 , // BC2/DXT3 8-bit lossy RGBA compression with sharp alpha transitions, linear gamma, 0..1 unsigned, Soft, DX10+, GL, partial Android
IMAGE_BC2_SRGB, // BC2/DXT3 8-bit lossy RGBA compression with sharp alpha transitions, sRGB gamma, 0..1 unsigned, Soft, DX10+, GL, partial Android
IMAGE_BC3 , // BC3/DXT5 8-bit lossy RGBA compression with smooth alpha transitions, linear gamma, 0..1 unsigned, Soft, DX10+, GL, partial Android
IMAGE_BC3_SRGB, // BC3/DXT5 8-bit lossy RGBA compression with smooth alpha transitions, sRGB gamma, 0..1 unsigned, Soft, DX10+, GL, partial Android
IMAGE_BC4 , // BC4 4-bit lossy R compression , linear gamma, 0..1 unsigned, Soft, DX10+, GL, partial Android
IMAGE_BC4_SIGN, // BC4 4-bit lossy R compression , linear gamma, -1..1 signed, Soft, DX10+, GL, partial Android
IMAGE_BC5 , // BC5 8-bit lossy RG compression , linear gamma, 0..1 unsigned, Soft, DX10+, GL, partial Android
IMAGE_BC5_SIGN, // BC5 8-bit lossy RG compression , linear gamma, -1..1 signed, Soft, DX10+, GL, partial Android
IMAGE_BC6 , // BC6 8-bit lossy RGB 16-bit floating point compression , linear gamma, 0..HALF_MAX unsigned, Soft, DX11+, partial GL (compressing images to this format is available only when 'SupportCompressBC' was called in 'InitPre')
IMAGE_BC7 , // BC7 8-bit lossy RGBA high quality compression , linear gamma, 0..1 unsigned, Soft, DX11+, partial GL (compressing images to this format is available only when 'SupportCompressBC' was called in 'InitPre')
IMAGE_BC7_SRGB, // BC7 8-bit lossy RGBA high quality compression , sRGB gamma, 0..1 unsigned, Soft, DX11+, partial GL (compressing images to this format is available only when 'SupportCompressBC' was called in 'InitPre')
// compressed format for Android/iOS (compressing images to these formats is available only when 'SupportCompressETC' was called in 'InitPre')
IMAGE_ETC2_R , // Ericsson 4-bit lossy R compression with no alpha (R,0,0,1 ), linear gamma, 0..1 unsigned, Soft, partial GL, GL ES
IMAGE_ETC2_R_SIGN , // Ericsson 4-bit lossy R compression with no alpha (R,0,0,1 ), linear gamma, -1..1 signed, Soft, partial GL, GL ES
IMAGE_ETC2_RG , // Ericsson 8-bit lossy RG compression with no alpha (R,G,0,1 ), linear gamma, 0..1 unsigned, Soft, partial GL, GL ES
IMAGE_ETC2_RG_SIGN , // Ericsson 8-bit lossy RG compression with no alpha (R,G,0,1 ), linear gamma, -1..1 signed, Soft, partial GL, GL ES
IMAGE_ETC2_RGB , // Ericsson 4-bit lossy RGB compression with no alpha (R,G,B,1 ), linear gamma, 0..1 unsigned, Soft, partial GL, GL ES
IMAGE_ETC2_RGB_SRGB , // Ericsson 4-bit lossy RGB compression with no alpha (R,G,B,1 ), sRGB gamma, 0..1 unsigned, Soft, partial GL, GL ES
IMAGE_ETC2_RGBA1 , // Ericsson 4-bit lossy RGBA compression with 1-bit alpha (R,G,B,0 or 1), linear gamma, 0..1 unsigned, Soft, partial GL, GL ES
IMAGE_ETC2_RGBA1_SRGB, // Ericsson 4-bit lossy RGBA compression with 1-bit alpha (R,G,B,0 or 1), sRGB gamma, 0..1 unsigned, Soft, partial GL, GL ES
IMAGE_ETC2_RGBA , // Ericsson 8-bit lossy RGBA compression with 8-bit alpha (R,G,B,A ), linear gamma, 0..1 unsigned, Soft, partial GL, GL ES
IMAGE_ETC2_RGBA_SRGB , // Ericsson 8-bit lossy RGBA compression with 8-bit alpha (R,G,B,A ), sRGB gamma, 0..1 unsigned, Soft, partial GL, GL ES
// compressed formats for iOS (compressing images to these formats is available only on Desktop platforms when 'SupportCompressPVRTC' was called in 'InitPre', decompression and especially compression may be slow, formats are recommended to be used only on iOS)
IMAGE_PVRTC1_2 , // PVRTC1 2-bit lossy RGBA compression, linear gamma, 0..1 unsigned, Soft, iOS, partial Android
IMAGE_PVRTC1_2_SRGB, // PVRTC1 2-bit lossy RGBA compression, sRGB gamma, 0..1 unsigned, Soft, iOS, partial Android
IMAGE_PVRTC1_4 , // PVRTC1 4-bit lossy RGBA compression, linear gamma, 0..1 unsigned, Soft, iOS, partial Android
IMAGE_PVRTC1_4_SRGB, // PVRTC1 4-bit lossy RGBA compression, sRGB gamma, 0..1 unsigned, Soft, iOS, partial Android
IMAGE_TYPES, // number of types
#if EE_PRIVATE
IMAGE_B8G8R8A8 , // 32-bit (R,G,B,A), Soft, DX10+
IMAGE_B8G8R8A8_SRGB,
IMAGE_B8G8R8 ,
IMAGE_B8G8R8_SRGB ,
IMAGE_B5G6R5 ,
IMAGE_B5G5R5A1,
IMAGE_B4G4R4A4,
IMAGE_D16 ,
IMAGE_D24X8,
IMAGE_D24S8,
IMAGE_D32 ,
IMAGE_ETC1, // Ericsson 4-bit lossy RGB compression with no alpha (R,G,B,1), linear gamma, Soft, Android
IMAGE_R11G11B10F,
IMAGE_R9G9B9E5F ,
IMAGE_ALL_TYPES, // number of all types
#endif
};
Bool IsSRGB (IMAGE_TYPE type); // if this is a sRGB image
Bool IsSByte(IMAGE_TYPE type); // if image 'type' channels have signed byte/8-bit precision
enum IMAGE_MODE : Byte // Image Mode
{
IMAGE_2D , // Hardware 2D Texture
IMAGE_3D , // Hardware 3D Texture
IMAGE_CUBE , // Hardware Cube Texture
IMAGE_SOFT , // Software Image (this type is used for software processing only - it can't be drawn on the screen)
IMAGE_SOFT_CUBE, // Software Cube Image (this type is used for software processing only - it can't be drawn on the screen)
IMAGE_RT , // Hardware RenderTarget (only this mode can be used as custom rendering destination for 'Renderer.target', after you have rendered to this image you can treat it as typical IMAGE_2D texture)
#if EE_PRIVATE
IMAGE_RT_CUBE , // Hardware RenderTarget Cube
IMAGE_DS , // Hardware Depth Stencil
IMAGE_SHADOW_MAP, // Hardware Shadow Map (Depth Texture)
#if DX11
IMAGE_STAGING , // DirectX Image used for copying data between CPU<->GPU
#elif GL
IMAGE_GL_RB , // OpenGL Render Buffer (can be color or depth stencil)
#endif
#endif
};
Bool IsSoft(IMAGE_MODE mode); // if this is a software image (IMAGE_SOFT, IMAGE_SOFT_CUBE)
Bool IsHW (IMAGE_MODE mode); // if this is a hardware image NOT (IMAGE_SOFT, IMAGE_SOFT_CUBE)
Bool IsCube(IMAGE_MODE mode); // if this is a cube image (IMAGE_CUBE, IMAGE_SOFT_CUBE or IMAGE_RT_CUBE)
enum IMAGE_PRECISION : Byte // Image Precision
{
IMAGE_PRECISION_8 , // up to 8-bits
IMAGE_PRECISION_10 , // 10-bits
IMAGE_PRECISION_16 , // 16-bits
IMAGE_PRECISION_24 , // 24-bits
IMAGE_PRECISION_32 , // 32-bits
IMAGE_PRECISION_64 , // 64-bits
IMAGE_PRECISION_NUM, // number of precisions
};
#if EE_PRIVATE
inline IMAGE_PRECISION Min(IMAGE_PRECISION a, IMAGE_PRECISION b) {return (a<b) ? a : b;}
inline IMAGE_PRECISION Max(IMAGE_PRECISION a, IMAGE_PRECISION b) {return (a>b) ? a : b;}
#endif
enum CUBE_LAYOUT : Byte
{
CUBE_LAYOUT_ONE ,
CUBE_LAYOUT_CROSS, // 4x3 cross
CUBE_LAYOUT_6x1 , // Left, Front, Right, Back, Down, Up
};
/******************************************************************************/
struct ImageTypeInfo // Image Type Information
{
enum USAGE_FLAG
{
USAGE_VTX =1<<0, // type can be used in a Vertex Buffer
USAGE_IMAGE_2D =1<<1, // type can be used in a 2D Image
USAGE_IMAGE_3D =1<<2, // type can be used in a 3D Image
USAGE_IMAGE_CUBE=1<<3, // type can be used in a Cube Image
USAGE_IMAGE_RT =1<<4, // type can be used in a Render Target
USAGE_IMAGE_DS =1<<5, // type can be used in a Depth Stencil Buffer
USAGE_IMAGE_MS =1<<6, // type can be used in a Multi-Sampled Render Target or Depth Stencil (depending on USAGE_IMAGE_RT, USAGE_IMAGE_DS)
USAGE_IMAGE_UAV =1<<7, // type can be used in a Unordered Access View
};
const CChar8 *name ; // type name
const Bool compressed , // if type is compressed
high_precision; // if type requires high precision storage (for example Flt/Vec4 instead of Byte/Color)
const Byte byte_pp , // bytes per pixel
bit_pp , // bits per pixel
r , // number of red bits
g , // number of green bits
b , // number of blue bits
a , // number of alpha bits
d , // number of depth bits
s , // number of stencil bits
channels ; // number of channels
const IMAGE_PRECISION precision ;
Byte usage ()C {return _usage ;} // get a combination of USAGE_FLAG, valid only if 'usageKnown' (on DX11/12, OpenGL 4.2+)
static Bool usageKnown() {return _usage_known;}
#if EE_PRIVATE
constexpr Bool filterable()C {return (!GL_ES) || (precision<IMAGE_PRECISION_32 && !d);} // GLES3 doesn't support filtering F32/Depth textures - https://www.khronos.org/registry/OpenGL-Refpages/es3.0/html/glTexImage2D.xhtml , "depth textures are not filterable" - https://arm-software.github.io/opengl-es-sdk-for-android/occlusion_culling.html
#endif
#if !EE_PRIVATE
private:
#endif
Byte _usage;
#if EE_PRIVATE
const GPU_API(DXGI_FORMAT, UInt) format;
#else
const UInt format;
#endif
#if EE_PRIVATE
private:
friend struct DisplayClass;
#endif
static Bool _usage_known;
};extern ImageTypeInfo
ImageTI[]; // Image Type Info Array, allows obtaining information about specified IMAGE_TYPE, sample usage: ImageTI[IMAGE_R8G8B8A8].name -> "R8G8B8A8"
/******************************************************************************/
enum IMAGE_COPY_FLAG
{
IC_CLAMP = 0, // perform UVW coordinate clamping when filtering pixels
IC_WRAP =1<<0, // perform UVW coordinate wrapping when filtering pixels
IC_ALPHA_WEIGHT =1<<1, // if use pixel's alpha for weight of pixel's color
IC_KEEP_EDGES =1<<2, // if preserve the edges of the image when resizing
IC_NO_ALT_TYPE =1<<3, // don't try using alternative IMAGE_TYPE if a specified is not supported
IC_CONVERT_GAMMA=1<<4, // make sure gamma conversion is performed (if no IC_CONVERT_GAMMA/IC_IGNORE_GAMMA are specified then choice is made automatically)
IC_IGNORE_GAMMA =1<<5, // make sure gamma conversion is ignored (if no IC_CONVERT_GAMMA/IC_IGNORE_GAMMA are specified then choice is made automatically)
IC_ENV_CUBE =1<<6, // cube image is meant to be used as Environment Map and will have its mip maps blurred in a special way
#if EE_PRIVATE
IC_NO_ALPHA_LIMIT=1<<7, // don't apply alpha limit when processing pixel colors
#endif
};
#if EE_PRIVATE
inline Bool IcWrap (UInt flag) {return FlagTest(flag, IC_WRAP);}
inline Bool IcClamp(UInt flag) {return !FlagTest(flag, IC_WRAP);}
#endif
/******************************************************************************/
struct Image // Image (Texture)
{
// get
Int w()C {return _size.x;} // get width (in pixels)
Int h()C {return _size.y;} // get height (in pixels)
Int d()C {return _size.z;} // get depth (in pixels)
Int lw()C {return _lock_size.x;} // get width of currently locked mip map (in pixels)
Int lh()C {return _lock_size.y;} // get height of currently locked mip map (in pixels)
Int ld()C {return _lock_size.z;} // get depth of currently locked mip map (in pixels)
Int hwW()C {return _hw_size.x;} // get width as it is stored on the GPU (in pixels), this can be different than 'w' if the size is a non-power of 2, but the GPU does not support non-power of 2 textures, in which case the hardware size will be rounded up to the nearest power of 2
Int hwH()C {return _hw_size.y;} // get height as it is stored on the GPU (in pixels), this can be different than 'h' if the size is a non-power of 2, but the GPU does not support non-power of 2 textures, in which case the hardware size will be rounded up to the nearest power of 2
Int hwD()C {return _hw_size.z;} // get depth as it is stored on the GPU (in pixels), this can be different than 'd' if the size is a non-power of 2, but the GPU does not support non-power of 2 textures, in which case the hardware size will be rounded up to the nearest power of 2
C VecI2& size ()C {return _size.xy;} // get image size (in pixels)
C VecI & size3()C {return _size ;} // get image size (in pixels)
C VecI2& hwSize ()C {return _hw_size.xy;} // get image size as it is stored on the GPU (in pixels)
C VecI & hwSize3()C {return _hw_size ;} // get image size as it is stored on the GPU (in pixels)
C VecI2& lockSize ()C {return _lock_size.xy;} // get lock size (in pixels)
Bool is ()C {return _type!=IMAGE_NONE;} // if valid
IMAGE_TYPE type ()C {return _type ;} // get image type
IMAGE_TYPE hwType ()C {return _hw_type ;} // get image type in which it is stored on the GPU (this can be different than 'type' if it is not supported directly on the hardware, for example image was created as compressed format which the GPU does not support, 'type' will be set to the compressed format but 'hwType' may be set to R8G8B8A8 format as stored on the GPU)
IMAGE_MODE mode ()C {return _mode ;} // get image mode
Int mipMaps()C {return _mms ;} // get number of mipmaps
Byte samples()C {return _samples ;} // get number of samples per pixel
Bool multiSample ()C {return _samples>1 ;} // if this is a multi sampled image
Bool partial()C {return _partial ;} // if 'hwSize' is different than 'size'
Int faces()C; // get how many faces this image has (0=empty, 1=default, 6=cube)
Bool soft()C {return IsSoft(mode()) ;} // if this is a software image (IMAGE_SOFT, IMAGE_SOFT_CUBE)
Bool hw()C {return IsHW (mode()) ;} // if this is a hardware image NOT (IMAGE_SOFT, IMAGE_SOFT_CUBE)
Bool cube()C {return IsCube(mode()) ;} // if this is a cube image (IMAGE_CUBE, IMAGE_SOFT_CUBE or IMAGE_RT_CUBE)
Int lMipMap ()C {return _lmm ;} // get index of locked mip map
DIR_ENUM lCubeFace()C {return _lcf ;} // get locked cube face
UInt pitch ()C {return _pitch ;} // get width pitch of locked mip map
UInt pitch2 ()C {return _pitch2 ;} // get width*height pitch of locked mip map
Byte* data () {return _data ;} // get address of locked data, memory accessed using this method should be interpreted according to 'hwType' (and not 'type')
C Byte* data ()C {return _data ;} // get address of locked data, memory accessed using this method should be interpreted according to 'hwType' (and not 'type')
LOCK_MODE lockMode ()C {return _lock_mode ;} // get current lock mode
Int lockCount()C {return _lock_count;} // get current lock count
Flt aspect()C {return Flt(w())/h() ;} // get aspect ratio of image "width/height"
Flt invAspect()C {return Flt(h())/w() ;} // get inversed aspect ratio of image "height/width"
UInt memUsage()C; // get actual memory usage of the image, this method operates on 'hwType' (what the image is using right now)
UInt typeMemUsage()C; // get desired memory usage of the image, this method operates on 'type' (what the image would use if it was stored in its desired type)
C ImageTypeInfo& typeInfo()C {return ImageTI[ _type] ;} // get image type info
C ImageTypeInfo& hwTypeInfo()C {return ImageTI[_hw_type] ;} // get image hardware type info
Byte bytePP()C {return _byte_pp ;} // get number of bytes per pixel
Bool compressed()C {return hwTypeInfo(). compressed;} // if hardware type is compressed
IMAGE_PRECISION precision()C {return hwTypeInfo(). precision;} // get image precision
Bool highPrecision()C {return hwTypeInfo().high_precision;} // if image requires high precision storage (for example Flt/Vec4 instead of Byte/Color)
Byte typeChannels()C {return typeInfo(). channels;} // get number of chanels for image type
Bool sRGB()C {return IsSRGB (_hw_type) ;} // if this is a sRGB image
Bool isSByte()C {return IsSByte(_hw_type) ;} // if this is a signed byte/8-bit precision
#if EE_PRIVATE
constexpr Bool filterable()C {return hwTypeInfo(). filterable();}
#endif
CUBE_LAYOUT cubeLayout()C; // auto-detect cube layout based on image size
// manage
#if EE_PRIVATE
Bool createEx(Int w, Int h, Int d, IMAGE_TYPE type, IMAGE_MODE mode, Int mip_maps, Byte samples=1, CPtr src_data=null, C Image *src=null
#if GL_ES
, Bool can_del_src=false // 'can_del_src'=if allow deleting 'src' (always enable if possible, to allow faster creation of images on GL_ES)
#endif
);
#endif
Image& del(); // delete
Bool createTry (Int w, Int h, Int d, IMAGE_TYPE type, IMAGE_MODE mode, Int mip_maps=0, Bool alt_type_on_fail=true); // create image, 'mip_maps'=number of mip-maps (0=autodetect), 'alt_type_on_fail'=if try using an alternative type if 'type' is not supported, false on fail
Bool create2DTry (Int w, Int h, IMAGE_TYPE type, Int mip_maps=0, Bool alt_type_on_fail=true) {return createTry(w, h, 1, type, IMAGE_2D , mip_maps, alt_type_on_fail);} // create hardware 2D texture, 'mip_maps'=number of mip-maps (0=autodetect), 'alt_type_on_fail'=if try using an alternative type if 'type' is not supported, false on fail
Bool create3DTry (Int w, Int h, Int d, IMAGE_TYPE type, Int mip_maps=1, Bool alt_type_on_fail=true) {return createTry(w, h, d, type, IMAGE_3D , mip_maps, alt_type_on_fail);} // create hardware 3D texture, 'mip_maps'=number of mip-maps (0=autodetect), 'alt_type_on_fail'=if try using an alternative type if 'type' is not supported, false on fail
Bool createCubeTry(Int w, IMAGE_TYPE type, Int mip_maps=1, Bool alt_type_on_fail=true) {return createTry(w, w, 1, type, IMAGE_CUBE, mip_maps, alt_type_on_fail);} // create hardware cube texture, 'mip_maps'=number of mip-maps (0=autodetect), 'alt_type_on_fail'=if try using an alternative type if 'type' is not supported, false on fail
Bool createSoftTry(Int w, Int h, Int d, IMAGE_TYPE type, Int mip_maps=1 ) {return createTry(w, h, d, type, IMAGE_SOFT, mip_maps, false);} // create software image, 'mip_maps'=number of mip-maps (0=autodetect), false on fail
Image& mustCreate (Int w, Int h, Int d, IMAGE_TYPE type, IMAGE_MODE mode, Int mip_maps=0, Bool alt_type_on_fail=true); // create image, 'mip_maps'=number of mip-maps (0=autodetect), 'alt_type_on_fail'=if try using an alternative type if 'type' is not supported, Exit on fail
Image& mustCreate2D (Int w, Int h, IMAGE_TYPE type, Int mip_maps=0, Bool alt_type_on_fail=true) {return mustCreate(w, h, 1, type, IMAGE_2D , mip_maps, alt_type_on_fail);} // create hardware 2D texture, 'mip_maps'=number of mip-maps (0=autodetect), 'alt_type_on_fail'=if try using an alternative type if 'type' is not supported, Exit on fail
Image& mustCreate3D (Int w, Int h, Int d, IMAGE_TYPE type, Int mip_maps=1, Bool alt_type_on_fail=true) {return mustCreate(w, h, d, type, IMAGE_3D , mip_maps, alt_type_on_fail);} // create hardware 3D texture, 'mip_maps'=number of mip-maps (0=autodetect), 'alt_type_on_fail'=if try using an alternative type if 'type' is not supported, Exit on fail
Image& mustCreateCube(Int w, IMAGE_TYPE type, Int mip_maps=1, Bool alt_type_on_fail=true) {return mustCreate(w, w, 1, type, IMAGE_CUBE, mip_maps, alt_type_on_fail);} // create hardware cube texture, 'mip_maps'=number of mip-maps (0=autodetect), 'alt_type_on_fail'=if try using an alternative type if 'type' is not supported, Exit on fail
Image& mustCreateSoft(Int w, Int h, Int d, IMAGE_TYPE type, Int mip_maps=1 ) {return mustCreate(w, h, d, type, IMAGE_SOFT, mip_maps, false);} // create software image, 'mip_maps'=number of mip-maps (0=autodetect), Exit on fail
Bool copyTry(Image &dest, Int w=-1, Int h=-1, Int d=-1, Int type=-1, Int mode=-1, Int mip_maps=-1, FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP)C; // copy to 'dest', -1=keep original value, 'type'=IMAGE_TYPE, 'mode'=IMAGE_MODE (this method does not support IMAGE_3D), 'mip_maps'=number of mip-maps (0=autodetect), 'flags'=IMAGE_COPY_FLAG, false on fail
void mustCopy (Image &dest, Int w=-1, Int h=-1, Int d=-1, Int type=-1, Int mode=-1, Int mip_maps=-1, FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP)C; // copy to 'dest', -1=keep original value, 'type'=IMAGE_TYPE, 'mode'=IMAGE_MODE (this method does not support IMAGE_3D), 'mip_maps'=number of mip-maps (0=autodetect), 'flags'=IMAGE_COPY_FLAG, Exit on fail
// lock
#if EE_PRIVATE
Byte* softData() {return _data_all;} // get software image data without locking the image
C Byte* softData()C {return _data_all;} // get software image data without locking the image
Byte* softData(Int mip_map, DIR_ENUM cube_face=DIR_RIGHT); // get software image data for 'mip_map' and 'cube_face' without locking the image
C Byte* softData(Int mip_map, DIR_ENUM cube_face=DIR_RIGHT)C {return ConstCast(T).softData(mip_map, cube_face);} // get software image data for 'mip_map' and 'cube_face' without locking the image
Int softFaceSize(Int mip_map)C; // get size in bytes for a single cube face for specified 'mip_map'
UInt softPitch (Int mip_map)C; // get pitch of specified 'mip_map'
void lockSoft();
Bool setFrom(CPtr data, Int data_pitch, Int mip_map=0, DIR_ENUM cube_face=DIR_RIGHT);
#endif
Bool lock (LOCK_MODE lock=LOCK_READ_WRITE, Int mip_map=0, DIR_ENUM cube_face=DIR_RIGHT) ; // lock image for editing specified 'mip_map', this needs to be called before manual setting/getting pixels/colors on hardware images (IMAGE_SOFT doesn't need locking), 'cube_face'=desired cube face (this is used only for IMAGE_CUBE modes)
Bool lockRead( Int mip_map=0, DIR_ENUM cube_face=DIR_RIGHT)C; // lock image for reading specified 'mip_map', this needs to be called before manual setting/getting pixels/colors on hardware images (IMAGE_SOFT doesn't need locking), 'cube_face'=desired cube face (this is used only for IMAGE_CUBE modes), this method has the same effect as calling "lock(LOCK_READ, mip_map, cube_face)", however unlike 'lock' method it has 'const' modifier and can be called on "const Image" objects
Image& unlock ( ) ; // unlock image , this needs to be called after manual setting/getting pixels/colors on hardware images (IMAGE_SOFT doesn't need locking), if you want the mip maps to be updated according to any change applied during the lock then you must call 'updateMipMaps' after 'unlock'
C Image& unlock ( )C; // unlock image , this needs to be called after manual setting/getting pixels/colors on hardware images (IMAGE_SOFT doesn't need locking), if you want the mip maps to be updated according to any change applied during the lock then you must call 'updateMipMaps' after 'unlock'
#if EE_PRIVATE
Bool updateMipMaps(C Image &src, Int src_mip, FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP, Int mip_start=0);
#endif
Image& updateMipMaps(FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP, Int mip_start=0); // update mip maps of the image, 'flags'=IMAGE_COPY_FLAG, 'mip_start'=index of the mip map to start with (this mip map will be taken, and downsampled to following mip maps)
Bool blurCubeMipMaps(); // blur mip maps based on increasing angles per mip-map, this method is only for Cube Images, false on fail
Image& freeOpenGLESData(); // this method is used only under OpenGL ES (on other platforms it is ignored), the method frees the software copy of the GPU data which increases available memory, however after calling this method the data can no longer be accessed on the CPU (can no longer be locked or saved to file)
// pixel
UInt pixel (Int x, Int y)C; void pixel (Int x, Int y, UInt pixel); // get/set pixel UInt value, image gamma (no gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixelF(Int x, Int y)C; void pixelF(Int x, Int y, Flt pixel); // get/set pixel Flt value, image gamma (no gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
Color color (Int x, Int y)C; void color (Int x, Int y, C Color &color); // get/set color Byte color, image gamma (no gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorF(Int x, Int y)C; void colorF(Int x, Int y, C Vec4 &color); // get/set color Flt color, image gamma (no gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorL(Int x, Int y)C; void colorL(Int x, Int y, C Vec4 &color); // get/set color Flt color, linear gamma ( gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorS(Int x, Int y)C; void colorS(Int x, Int y, C Vec4 &color); // get/set color Flt color, sRGB gamma ( gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
void blendF(Int x, Int y, C Vec4 &color); // apply 'color' pixel using ALPHA_BLEND formula
void mergeF(Int x, Int y, C Vec4 &color); // apply 'color' pixel using ALPHA_MERGE formula
Flt pixelFNearest (Flt x, Flt y, Bool clamp=true)C; // get pixel Flt with no interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixelFLinear (Flt x, Flt y, Bool clamp=true)C; // get pixel Flt with Linear interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixelFCubicFast (Flt x, Flt y, Bool clamp=true)C; // get pixel Flt with Cubic Fast interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixelFCubicFastSmooth(Flt x, Flt y, Bool clamp=true)C; // get pixel Flt with Cubic Fast Smooth interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixelFCubicFastSharp (Flt x, Flt y, Bool clamp=true)C; // get pixel Flt with Cubic Fast Sharp interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixelFCubicPlus (Flt x, Flt y, Bool clamp=true)C; // get pixel Flt with Cubic Plus interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixelFCubicPlusSharp (Flt x, Flt y, Bool clamp=true)C; // get pixel Flt with Cubic Plus Sharp interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorFNearest (Flt x, Flt y, Bool clamp=true, Bool alpha_weight=false)C; // get color Vec4 with no interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorFLinear (Flt x, Flt y, Bool clamp=true, Bool alpha_weight=false)C; // get color Vec4 with Linear interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorFCubicFast (Flt x, Flt y, Bool clamp=true, Bool alpha_weight=false)C; // get color Vec4 with Cubic Fast interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorLCubicFast (Flt x, Flt y, Bool clamp=true, Bool alpha_weight=false)C; // get color Vec4 with Cubic Fast interpolation, linear gamma ( gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorSCubicFast (Flt x, Flt y, Bool clamp=true, Bool alpha_weight=false)C; // get color Vec4 with Cubic Fast interpolation, sRGB gamma ( gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorFCubicFastSmooth(Flt x, Flt y, Bool clamp=true, Bool alpha_weight=false)C; // get color Vec4 with Cubic Fast Smooth interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorFCubicFastSharp (Flt x, Flt y, Bool clamp=true, Bool alpha_weight=false)C; // get color Vec4 with Cubic Fast Sharp interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorFCubicPlus (Flt x, Flt y, Bool clamp=true, Bool alpha_weight=false)C; // get color Vec4 with Cubic Plus interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 colorFCubicPlusSharp (Flt x, Flt y, Bool clamp=true, Bool alpha_weight=false)C; // get color Vec4 with Cubic Plus Sharp interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
#if EE_PRIVATE
Vec4 colorFLinearTTNF32_4(Flt x, Flt y, Bool clamp)C; // optimized version specifically for 'transparentToNeighbor', image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels
#endif
// pixel 3D
UInt pixel3D (Int x, Int y, Int z)C; void pixel3D (Int x, Int y, Int z, UInt pixel); // get/set pixel 3D UInt value, image gamma (no gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixel3DF(Int x, Int y, Int z)C; void pixel3DF(Int x, Int y, Int z, Flt pixel); // get/set pixel 3D Flt value, image gamma (no gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
Color color3D (Int x, Int y, Int z)C; void color3D (Int x, Int y, Int z, C Color &color); // get/set color 3D Byte color, image gamma (no gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 color3DF(Int x, Int y, Int z)C; void color3DF(Int x, Int y, Int z, C Vec4 &color); // get/set color 3D Flt color, image gamma (no gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 color3DL(Int x, Int y, Int z)C; void color3DL(Int x, Int y, Int z, C Vec4 &color); // get/set color 3D Flt color, linear gamma ( gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 color3DS(Int x, Int y, Int z)C; void color3DS(Int x, Int y, Int z, C Vec4 &color); // get/set color 3D Flt color, sRGB gamma ( gamma conversion), (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixel3DFNearest (Flt x, Flt y, Flt z, Bool clamp=true)C; // get 3D pixel Flt with no interpolation, 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixel3DFLinear (Flt x, Flt y, Flt z, Bool clamp=true)C; // get 3D pixel Flt with Linear interpolation, 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixel3DFCubicFast (Flt x, Flt y, Flt z, Bool clamp=true)C; // get 3D pixel Flt with Cubic Fast interpolation, 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixel3DFCubicFastSmooth(Flt x, Flt y, Flt z, Bool clamp=true)C; // get 3D pixel Flt with Cubic Fast Smooth interpolation, 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixel3DFCubicFastSharp (Flt x, Flt y, Flt z, Bool clamp=true)C; // get 3D pixel Flt with Cubic Fast Sharp interpolation, 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixel3DFCubicPlus (Flt x, Flt y, Flt z, Bool clamp=true)C; // get 3D pixel Flt with Cubic Plus interpolation, 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Flt pixel3DFCubicPlusSharp (Flt x, Flt y, Flt z, Bool clamp=true)C; // get 3D pixel Flt with Cubic Plus Sharp interpolation, 'clamp'=if use clamping when filtering pixels, (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 color3DFNearest (Flt x, Flt y, Flt z, Bool clamp=true, Bool alpha_weight=false)C; // get 3D color Vec4 with no interpolation, 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 color3DFLinear (Flt x, Flt y, Flt z, Bool clamp=true, Bool alpha_weight=false)C; // get 3D color Vec4 with Linear interpolation, 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 color3DFCubicFast (Flt x, Flt y, Flt z, Bool clamp=true, Bool alpha_weight=false)C; // get 3D color Vec4 with Cubic Fast interpolation, 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 color3DFCubicFastSmooth(Flt x, Flt y, Flt z, Bool clamp=true, Bool alpha_weight=false)C; // get 3D color Vec4 with Cubic Fast Smooth interpolation, 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 color3DFCubicFastSharp (Flt x, Flt y, Flt z, Bool clamp=true, Bool alpha_weight=false)C; // get 3D color Vec4 with Cubic Fast Sharp interpolation, 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 color3DFCubicPlus (Flt x, Flt y, Flt z, Bool clamp=true, Bool alpha_weight=false)C; // get 3D color Vec4 with Cubic Plus interpolation, 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 color3DFCubicPlusSharp (Flt x, Flt y, Flt z, Bool clamp=true, Bool alpha_weight=false)C; // get 3D color Vec4 with Cubic Plus Sharp interpolation, 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
// pixel area
Vec4 areaColorFAverage (C Vec2 &pos, C Vec2 &size, Bool clamp=true, Bool alpha_weight=false)C; // get average color Vec4 of specified 'pos' position and 'size' coverage with Average interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 areaColorFLinear (C Vec2 &pos, C Vec2 &size, Bool clamp=true, Bool alpha_weight=false)C; // get average color Vec4 of specified 'pos' position and 'size' coverage with Linear interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 areaColorLLinear (C Vec2 &pos, C Vec2 &size, Bool clamp=true, Bool alpha_weight=false)C; // get average color Vec4 of specified 'pos' position and 'size' coverage with Linear interpolation, linear gamma ( gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 areaColorFCubicFast (C Vec2 &pos, C Vec2 &size, Bool clamp=true, Bool alpha_weight=false)C; // get average color Vec4 of specified 'pos' position and 'size' coverage with Cubic Fast interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 areaColorLCubicFast (C Vec2 &pos, C Vec2 &size, Bool clamp=true, Bool alpha_weight=false)C; // get average color Vec4 of specified 'pos' position and 'size' coverage with Cubic Fast interpolation, linear gamma ( gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 areaColorFCubicFastSmooth(C Vec2 &pos, C Vec2 &size, Bool clamp=true, Bool alpha_weight=false)C; // get average color Vec4 of specified 'pos' position and 'size' coverage with Cubic Fast Smooth interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 areaColorLCubicFastSmooth(C Vec2 &pos, C Vec2 &size, Bool clamp=true, Bool alpha_weight=false)C; // get average color Vec4 of specified 'pos' position and 'size' coverage with Cubic Fast Smooth interpolation, linear gamma ( gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 areaColorFCubicFastSharp (C Vec2 &pos, C Vec2 &size, Bool clamp=true, Bool alpha_weight=false)C; // get average color Vec4 of specified 'pos' position and 'size' coverage with Cubic Fast Sharp interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 areaColorFCubicPlus (C Vec2 &pos, C Vec2 &size, Bool clamp=true, Bool alpha_weight=false)C; // get average color Vec4 of specified 'pos' position and 'size' coverage with Cubic Plus interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
Vec4 areaColorFCubicPlusSharp (C Vec2 &pos, C Vec2 &size, Bool clamp=true, Bool alpha_weight=false)C; // get average color Vec4 of specified 'pos' position and 'size' coverage with Cubic Plus Sharp interpolation, image gamma (no gamma conversion), 'clamp'=if use clamping when filtering pixels, 'alpha_weight'=if use pixel's alpha for weight of pixel's color (these methods may not support all compressed types, instead try using 'copy' method first)
// operations
Image& clear ( ) ; // clear to 0 (transparent black)
Image& normalize ( Bool red=true, Bool green=true, Bool blue=true, Bool alpha=true, C BoxI *box=null ) ; // normalize selected components to 0..1 range, 'box'=optional box in which perform the operation (use null for entire image)
Image& mulAdd ( C Vec4 &mul, C Vec4 &add , C BoxI *box=null ) ; // transform color to "color*mul+add" , 'box'=optional box in which perform the operation (use null for entire image)
void bumpToNormal ( Image &dest, Flt scale, Bool high_precision=false )C; // convert bump map to normal map, 'scale'=bump scaling factor 0..Inf, 'high_precision'=if create signed float image type, or unsigned byte image type
void crop ( Image &dest, Int x, Int y, Int w, Int h , C Vec4 *clear_color=&Vec4Zero )C; // crop image, 'clear_color'=color to be used for pixels that didn't exist in the source (if null then they will remain uninitialized)
void crop3D ( Image &dest, Int x, Int y, Int z, Int w, Int h, Int d, C Vec4 *clear_color=&Vec4Zero )C; // crop 3D image, 'clear_color'=color to be used for pixels that didn't exist in the source (if null then they will remain uninitialized)
Image& resize ( Int w, Int h, FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP ) ; // resize image, 'flags'=IMAGE_COPY_FLAG
Image& resize3D ( Int w, Int h, Int d, FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP ) ; // resize 3D image, 'flags'=IMAGE_COPY_FLAG
Image& mirrorX ( ) ; // mirror image horizontally
Image& mirrorY ( ) ; // mirror image vertically
Image& mirrorXY ( ) ; // mirror image horizontally and vertically
void rotate ( Image &dest, Flt angle, FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP )C; // rotate image by 'angle' and store in 'dest'
void rotateScale ( Image &dest, Flt angle, Flt scale, FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP )C; // rotate image by 'angle', scale by 'scale', and store in 'dest'
Image& alphaFromKey ( C Color &key=PURPLE ) ; // transform to ((pixel color==key) ? (0, 0, 0, 0) : (r, g, b, 255))
Image& alphaFromBrightness ( ) ; // transform to (r , g , b , brightness)
Image& divRgbByAlpha ( ) ; // transform to (r/a, g/a, b/a, a)
Bool stats ( Vec4 *min=null, Vec4 *max=null, Vec4 *avg=null, Vec4 *median=null, Vec4 *mode=null, Vec *avg_alpha_weight=null, Vec *med_alpha_weight=null, C BoxI *box=null)C; // get image statistics , such as: minimum, maximum, average, median and mode color values, 'box'=optional box in which perform the operation (use null for entire image), false on fail
Bool statsSat ( Flt *min=null, Flt *max=null, Flt *avg=null, Flt *median=null, Flt *mode=null, Flt *avg_alpha_weight=null, Flt *med_alpha_weight=null, C BoxI *box=null)C; // get image statistics for saturation, such as: minimum, maximum, average, median and mode values, 'box'=optional box in which perform the operation (use null for entire image), false on fail
Bool monochromatic ( )C; // check if image is monochromatic (all RGB values are the same)
Bool monochromaticRG ( )C; // check if image is monochromatic (all RG values are the same, Blue values are ignored)
#if EE_PRIVATE
void transform ( Image &dest, C Matrix2 &matrix, FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP )C; // transform image by 'matrix' and store in 'dest'
Bool extractNonCompressedMipMapNoStretch(Image &dest, Int w, Int h, Int d, Int mip_map, DIR_ENUM cube_face=DIR_RIGHT, Bool clamp=true)C;
#endif
Bool extractMipMap ( Image &dest, Int type, Int mip_map, DIR_ENUM cube_face=DIR_RIGHT )C; // extract specified mipmap to 'dest' 0-th mipmap, false on fail, 'type'=IMAGE_TYPE (-1=keep), 'dest' will always be IMAGE_SOFT
Bool injectMipMap (C Image &src , Int mip_map, DIR_ENUM cube_face=DIR_RIGHT, FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP ) ; // inject specified mipmap from 'src' 0-th mipmap, false on fail, 'filter'=what kind of filtering to use when source is of different size than the target, 'flags'=IMAGE_COPY_FLAG
Image& downSample ( FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP ) ; // downsample to half resolution size, 'flags'=IMAGE_COPY_FLAG
Bool averageX ( Image &dest, Int range, Bool clamp )C; // horizontal average, 'range'=range of blurring (in pixels), false on fail
Bool averageY ( Image &dest, Int range, Bool clamp )C; // vertical average, 'range'=range of blurring (in pixels), false on fail
Bool averageZ ( Image &dest, Int range, Bool clamp )C; // depth average, 'range'=range of blurring (in pixels), false on fail
Bool average ( Image &dest, C VecI &range, Bool clamp )C; // average, 'range'=range of blurring (in pixels), false on fail
Image& average ( C VecI &range, Bool clamp ) ; // average, 'range'=range of blurring (in pixels)
Bool blurX ( Image &dest, Flt range, Bool clamp )C; // horizontal blur , 'range'=range of blurring (in pixels), false on fail
Bool blurY ( Image &dest, Flt range, Bool clamp )C; // vertical blur , 'range'=range of blurring (in pixels), false on fail
Bool blurZ ( Image &dest, Flt range, Bool clamp )C; // depth blur , 'range'=range of blurring (in pixels), false on fail
Bool blur ( Image &dest, C Vec &range, Bool clamp )C; // blur , 'range'=range of blurring (in pixels), false on fail
Image& blur ( C Vec &range, Bool clamp ) ; // blur , 'range'=range of blurring (in pixels)
Image& sharpen ( Flt power, C Vec &range, Bool clamp, Bool blur=true ) ; // sharpen image, 'power'=0..Inf (default=1.0), 'range'=blurring range, 'clamp'=blurring clamp, 'blur'=if use blur or averaging
Image& noise ( Byte red , Byte green, Byte blue , Byte alpha ) ; // add noise of selected scale per component to image
Image& RGBToHSB ( ) ; // convert Red Green Blue image to Hue Saturation Brightness (Alpha will be kept)
Image& HSBToRGB ( ) ; // convert Hue Saturation Brightness image to Red Green Blue (Alpha will be kept)
Image& tile ( C VecI2 &range ) ; // make tileable, 'range'=number of pixels to blend
Image& minimum ( Flt distance ) ; // apply minimum filter, 'distance'=pixel range (0..1)
Image& maximum ( Flt distance ) ; // apply maximum filter, 'distance'=pixel range (0..1)
Bool getSameColorNeighbors( Int x, Int y, MemPtr<VecI2> pixels, Bool diagonal=true )C; // get a list of all neighbor pixels with the same color, 'diagonal'=if allow diagonal movements, false on fail
Image& fill ( Int x, Int y, C Color &color , Bool diagonal=true ) ; // fill image at specified coordinates with given color, 'diagonal'=if allow diagonal movements
Image& transparentToNeighbor (Bool clamp=true, Flt step =1); // replace transparent pixels with neighbors
Image& transparentForFiltering(Bool clamp=true, Flt intensity=1); // adjust transparent pixels to optimize for filtering
Image& createShadow(C Image &src , Int blur, Flt shadow_opacity=1.0f, Flt shadow_spread=0.0f, Bool border_padd=true ); // create shadow image IMAGE_A8 from 'src' alpha channel, 'blur'=blur range (in pixels), 'shadow_opacity'=shadow opacity (0..1), 'shadow_spread'=shadow spread (0..1)
Image& applyShadow(C Image &shadow, C Color &shadow_color =BLACK, C VecI2 &offset=0, Int image_type=0, Bool combine=true); // apply shadow image to self, 'offset'=offset in pixels where to apply the shadow, 'image_type'=IMAGE_TYPE (-1=keep, 0=autodetect), 'combine'=if combine on to the color map (if false then alpha will be set to shadow intensity)
Image& setShadow( Int blur, Flt shadow_opacity=1.0f, Flt shadow_spread=0.0f, Bool border_padd=true, C VecI2 &offset=0, Int image_type=0, Bool combine=true); // create shadow and apply to self
#if EE_PRIVATE
Bool accessible()C;
Bool compatible(C Image &image)C;
Bool toCube(C Image &src, Int layout=-1, Int size=-1, Int type=-1, Int mode=-1, Int mip_maps=-1, FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP); // convert from 'src' image to cube image, 'size'=desired resolution of the image (-1=keep), 'type'=IMAGE_TYPE (-1=keep), 'mode'=IMAGE_MODE (-1=auto), 'mip_maps'=number of mip-maps (0=autodetect), 'filter'=what kind of filtering to use when source is of different size than the target, 'flags'=IMAGE_COPY_FLAG
Bool fromCube(C Image &src, Int uncompressed_type=-1 ); // convert from 'src' cube image to 6x1 image, 'uncompressed_type'=IMAGE_TYPE to use if source is compressed
#endif
Bool raycast(C Vec &start, C Vec &move, C Matrix *image_matrix=null, Flt *hit_frac=null, Vec *hit_pos=null, Flt precision=1.0f)C; // perform ray casting from 'start' position along 'move' vector, return true if collision encountered with the image, by default the Image is on XY plane with its pixel values extending it towards the Z axis, 'image_matrix'=image transformation matrix, 'hit_frac'=fraction of the movement where collision occurs, 'hit_pos'=position where collision occurs, 'precision'=affects number of pixels to advance in a single step (lower value makes calculations faster but less precise)
// !! warning: following methods do not check for coordinates being out of range, image type matching, and image being locked, use only if you know what you're doing !!
Byte & pixB (Int x, Int y) {return *(Byte *)(_data + x*SIZE(Byte ) + y*_pitch);} Byte & pixB (C VecI2 &v) {return pixB (v.x, v.y);}
UInt & pix (Int x, Int y) {return *(UInt *)(_data + x*SIZE(UInt ) + y*_pitch);} UInt & pix (C VecI2 &v) {return pix (v.x, v.y);}
Color& pixC (Int x, Int y) {return *(Color*)(_data + x*SIZE(Color) + y*_pitch);} Color& pixC (C VecI2 &v) {return pixC (v.x, v.y);}
VecB & pixB3(Int x, Int y) {return *(VecB *)(_data + x*SIZE(VecB ) + y*_pitch);} VecB & pixB3(C VecI2 &v) {return pixB3(v.x, v.y);}
VecB4& pixB4(Int x, Int y) {return *(VecB4*)(_data + x*SIZE(VecB4) + y*_pitch);} VecB4& pixB4(C VecI2 &v) {return pixB4(v.x, v.y);}
Flt & pixF (Int x, Int y) {return *(Flt *)(_data + x*SIZE(Flt ) + y*_pitch);} Flt & pixF (C VecI2 &v) {return pixF (v.x, v.y);}
Vec2 & pixF2(Int x, Int y) {return *(Vec2 *)(_data + x*SIZE(Vec2 ) + y*_pitch);} Vec2 & pixF2(C VecI2 &v) {return pixF2(v.x, v.y);}
Vec & pixF3(Int x, Int y) {return *(Vec *)(_data + x*SIZE(Vec ) + y*_pitch);} Vec & pixF3(C VecI2 &v) {return pixF3(v.x, v.y);}
Vec4 & pixF4(Int x, Int y) {return *(Vec4 *)(_data + x*SIZE(Vec4 ) + y*_pitch);} Vec4 & pixF4(C VecI2 &v) {return pixF4(v.x, v.y);}
Byte & pixB (Int x, Int y, Int z) {return *(Byte *)(_data + x*SIZE(Byte ) + y*_pitch + z*_pitch2);} Byte & pixB (C VecI &v) {return pixB (v.x, v.y, v.z);}
UInt & pix (Int x, Int y, Int z) {return *(UInt *)(_data + x*SIZE(UInt ) + y*_pitch + z*_pitch2);} UInt & pix (C VecI &v) {return pix (v.x, v.y, v.z);}
Color& pixC (Int x, Int y, Int z) {return *(Color*)(_data + x*SIZE(Color) + y*_pitch + z*_pitch2);} Color& pixC (C VecI &v) {return pixC (v.x, v.y, v.z);}
VecB & pixB3(Int x, Int y, Int z) {return *(VecB *)(_data + x*SIZE(VecB ) + y*_pitch + z*_pitch2);} VecB & pixB3(C VecI &v) {return pixB3(v.x, v.y, v.z);}
VecB4& pixB4(Int x, Int y, Int z) {return *(VecB4*)(_data + x*SIZE(VecB4) + y*_pitch + z*_pitch2);} VecB4& pixB4(C VecI &v) {return pixB4(v.x, v.y, v.z);}
Flt & pixF (Int x, Int y, Int z) {return *(Flt *)(_data + x*SIZE(Flt ) + y*_pitch + z*_pitch2);} Flt & pixF (C VecI &v) {return pixF (v.x, v.y, v.z);}
Vec2 & pixF2(Int x, Int y, Int z) {return *(Vec2 *)(_data + x*SIZE(Vec2 ) + y*_pitch + z*_pitch2);} Vec2 & pixF2(C VecI &v) {return pixF2(v.x, v.y, v.z);}
Vec & pixF3(Int x, Int y, Int z) {return *(Vec *)(_data + x*SIZE(Vec ) + y*_pitch + z*_pitch2);} Vec & pixF3(C VecI &v) {return pixF3(v.x, v.y, v.z);}
Vec4 & pixF4(Int x, Int y, Int z) {return *(Vec4 *)(_data + x*SIZE(Vec4 ) + y*_pitch + z*_pitch2);} Vec4 & pixF4(C VecI &v) {return pixF4(v.x, v.y, v.z);}
C Byte & pixB (Int x, Int y)C {return *(Byte *)(_data + x*SIZE(Byte ) + y*_pitch);} C Byte & pixB (C VecI2 &v)C {return pixB (v.x, v.y);}
C UInt & pix (Int x, Int y)C {return *(UInt *)(_data + x*SIZE(UInt ) + y*_pitch);} C UInt & pix (C VecI2 &v)C {return pix (v.x, v.y);}
C Color& pixC (Int x, Int y)C {return *(Color*)(_data + x*SIZE(Color) + y*_pitch);} C Color& pixC (C VecI2 &v)C {return pixC (v.x, v.y);}
C VecB & pixB3(Int x, Int y)C {return *(VecB *)(_data + x*SIZE(VecB ) + y*_pitch);} C VecB & pixB3(C VecI2 &v)C {return pixB3(v.x, v.y);}
C VecB4& pixB4(Int x, Int y)C {return *(VecB4*)(_data + x*SIZE(VecB4) + y*_pitch);} C VecB4& pixB4(C VecI2 &v)C {return pixB4(v.x, v.y);}
C Flt & pixF (Int x, Int y)C {return *(Flt *)(_data + x*SIZE(Flt ) + y*_pitch);} C Flt & pixF (C VecI2 &v)C {return pixF (v.x, v.y);}
C Vec2 & pixF2(Int x, Int y)C {return *(Vec2 *)(_data + x*SIZE(Vec2 ) + y*_pitch);} C Vec2 & pixF2(C VecI2 &v)C {return pixF2(v.x, v.y);}
C Vec & pixF3(Int x, Int y)C {return *(Vec *)(_data + x*SIZE(Vec ) + y*_pitch);} C Vec & pixF3(C VecI2 &v)C {return pixF3(v.x, v.y);}
C Vec4 & pixF4(Int x, Int y)C {return *(Vec4 *)(_data + x*SIZE(Vec4 ) + y*_pitch);} C Vec4 & pixF4(C VecI2 &v)C {return pixF4(v.x, v.y);}
C Byte & pixB (Int x, Int y, Int z)C {return *(Byte *)(_data + x*SIZE(Byte ) + y*_pitch + z*_pitch2);} C Byte & pixB (C VecI &v)C {return pixB (v.x, v.y, v.z);}
C UInt & pix (Int x, Int y, Int z)C {return *(UInt *)(_data + x*SIZE(UInt ) + y*_pitch + z*_pitch2);} C UInt & pix (C VecI &v)C {return pix (v.x, v.y, v.z);}
C Color& pixC (Int x, Int y, Int z)C {return *(Color*)(_data + x*SIZE(Color) + y*_pitch + z*_pitch2);} C Color& pixC (C VecI &v)C {return pixC (v.x, v.y, v.z);}
C VecB & pixB3(Int x, Int y, Int z)C {return *(VecB *)(_data + x*SIZE(VecB ) + y*_pitch + z*_pitch2);} C VecB & pixB3(C VecI &v)C {return pixB3(v.x, v.y, v.z);}
C VecB4& pixB4(Int x, Int y, Int z)C {return *(VecB4*)(_data + x*SIZE(VecB4) + y*_pitch + z*_pitch2);} C VecB4& pixB4(C VecI &v)C {return pixB4(v.x, v.y, v.z);}
C Flt & pixF (Int x, Int y, Int z)C {return *(Flt *)(_data + x*SIZE(Flt ) + y*_pitch + z*_pitch2);} C Flt & pixF (C VecI &v)C {return pixF (v.x, v.y, v.z);}
C Vec2 & pixF2(Int x, Int y, Int z)C {return *(Vec2 *)(_data + x*SIZE(Vec2 ) + y*_pitch + z*_pitch2);} C Vec2 & pixF2(C VecI &v)C {return pixF2(v.x, v.y, v.z);}
C Vec & pixF3(Int x, Int y, Int z)C {return *(Vec *)(_data + x*SIZE(Vec ) + y*_pitch + z*_pitch2);} C Vec & pixF3(C VecI &v)C {return pixF3(v.x, v.y, v.z);}
C Vec4 & pixF4(Int x, Int y, Int z)C {return *(Vec4 *)(_data + x*SIZE(Vec4 ) + y*_pitch + z*_pitch2);} C Vec4 & pixF4(C VecI &v)C {return pixF4(v.x, v.y, v.z);}
// !! warning: 'gather' methods are written for speed and not safety, they assume that image is locked and that offsets are in range, these methods set 'pixels/colors' array from image values, coordinates are specified in the 'offset' parameters !!
void gather (Flt *pixels, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets)C;
void gather (VecB *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets)C;
void gather (Color *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets)C;
void gather (Vec2 *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets)C;
void gather (Vec4 *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets)C;
void gatherL(Vec4 *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets)C;
void gatherS(Vec4 *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets)C;
void gather (Flt *pixels, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets, Int *z_offset, Int z_offsets)C;
void gather (VecB *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets, Int *z_offset, Int z_offsets)C;
void gather (Color *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets, Int *z_offset, Int z_offsets)C;
void gather (Vec2 *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets, Int *z_offset, Int z_offsets)C;
void gather (Vec4 *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets, Int *z_offset, Int z_offsets)C;
void gatherL(Vec4 *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets, Int *z_offset, Int z_offsets)C;
void gatherS(Vec4 *colors, Int *x_offset, Int x_offsets, Int *y_offset, Int y_offsets, Int *z_offset, Int z_offsets)C;
// fit
Rect fit (C Rect &rect, FIT_MODE fit=FIT_FULL)C {return Fit( aspect(), rect, fit);} // get rectangle that can be used for drawing of the image to the 'rect' destination while preserving image proportions according to specified 'fit' mode
Rect fitVertical(C Rect &rect, FIT_MODE fit=FIT_FULL)C {return Fit(invAspect(), rect, fit);} // get rectangle that can be used for drawing of the image to the 'rect' destination while preserving image proportions according to specified 'fit' mode
// draw
void draw ( C Rect &rect)C;
void draw (C Color &color, C Color &color_add, C Rect &rect)C;
void drawVertical( C Rect &rect)C; // draw with texture coordinates in vertical mode
void drawVertical(C Color &color, C Color &color_add, C Rect &rect)C; // draw with texture coordinates in vertical mode
// draw to fit best in given space, while preserving image proportions
void drawFit ( C Rect &rect)C {return draw ( fit (rect));}
void drawFit (C Color &color, C Color &color_add, C Rect &rect)C {return draw (color, color_add, fit (rect));}
void drawFitVertical(C Color &color, C Color &color_add, C Rect &rect)C {return drawVertical(color, color_add, fitVertical(rect));}
// draw to fullscreen
void drawFs( FIT_MODE fit=FIT_FULL, Int filter=-1)C; // draw to fullscreen, 'filter'=custom filtering (FILTER_TYPE) for this parameter you can set any of the FILTER_TYPE enums or use -1 to let the engine decide on filtering (for example linear filtering will be used on Mobile platforms and better filtering on other platforms)
void drawFs(C Color &color, C Color &color_add=TRANSPARENT, FIT_MODE fit=FIT_FULL, Int filter=-1)C; // draw to fullscreen, 'filter'=custom filtering (FILTER_TYPE) for this parameter you can set any of the FILTER_TYPE enums or use -1 to let the engine decide on filtering (for example linear filtering will be used on Mobile platforms and better filtering on other platforms)
// draw only part of the image
void drawPart ( C Rect &screen_rect, C Rect &tex_rect)C;
void drawPart (C Color &color, C Color &color_add, C Rect &screen_rect, C Rect &tex_rect)C;
void drawPartVertical( C Rect &screen_rect, C Rect &tex_rect)C; // draw with texture coordinates in vertical mode
void drawPartVertical(C Color &color, C Color &color_add, C Rect &screen_rect, C Rect &tex_rect)C; // draw with texture coordinates in vertical mode
// draw rotated
void drawRotate( C Vec2 ¢er, C Vec2 &size, Flt angle, C Vec2 *rotation_center=null)C;
void drawRotate(C Color &color, C Color &color_add, C Vec2 ¢er, C Vec2 &size, Flt angle, C Vec2 *rotation_center=null)C;
// draw masked
void drawMask (C Color &color, C Color &color_add, C Rect &rect, C Image &mask, C Rect &mask_rect)C; // draw image using 'mask', final result is calculated as: this* mask *color+color_add
void drawMaskNoFilter (C Color &color, C Color &color_add, C Rect &rect, C Image &mask, C Rect &mask_rect)C; // draw image using 'mask', final result is calculated as: this* mask *color+color_add, uses FILTER_NONE for this, but FILTER_LINEAR for 'mask'
void drawMaskA (C Color &color, C Color &color_add, C Rect &rect, C Image &mask, C Rect &mask_rect)C; // draw image using 'mask', final result is calculated as: this*Vec4(1,1,1,mask.a)*color+color_add
void drawMaskANoFilter(C Color &color, C Color &color_add, C Rect &rect, C Image &mask, C Rect &mask_rect)C; // draw image using 'mask', final result is calculated as: this*Vec4(1,1,1,mask.a)*color+color_add, uses FILTER_NONE for this, but FILTER_LINEAR for 'mask'
// draw faded
void drawFadeLR(C Color &color, C Rect &rect, Flt trans_l, Flt opaque_l, Flt opaque_r, Flt trans_r)C; // draw and fade out left/right sides, 'trans_l'=X screen coordinate where left part is fully transparent, 'opaque_l'=X screen coordinate where left part is fully opaque, 'opaque_r'=X screen coordinate where right part is fully opaque, 'trans_r'=X screen coordinate where right part is fully transparent
// draw image as tiled background, 'tex_scale'=texture coordinates scaling
void drawTile( C Rect &rect, Flt tex_scale=1)C;
void drawTile(C Color &color, C Color &color_add, C Rect &rect, Flt tex_scale=1)C;
// draw image as rectangle's border
void drawBorder( C Rect &rect, Flt border=0.02f, Flt tex_scale=1, Flt tex_offset=0, Bool wrap_mode=false)C;
void drawBorder(C Color &color, C Color &color_add, C Rect &rect, Flt border=0.02f, Flt tex_scale=1, Flt tex_offset=0, Bool wrap_mode=false)C;
// draw stretched image from 3x3 parts
void draw3x3 (C Color &color, C Color &color_add, C Rect &rect, Flt border_size, Flt tex_frac=0.25f)C; // 'color'=color that will be multiplied by the texture, 'color_add'=color that will be added to the texture using following formula "final_color = texture_color * color + color_add", 'rect'=screen rectangle at which the image will be drawn, 'border_size'=size of the border inside the screen 'rect' rectangle that will be drawn as image borders (this value should be less than rectangle dimensions), 'tex_frac'=fraction of the image texture that will be used for drawing the borders (this value should be in range of 0 .. 0.5)
void draw3x3Vertical(C Color &color, C Color &color_add, C Rect &rect, Flt border_size, Flt tex_frac=0.25f)C; // 'color'=color that will be multiplied by the texture, 'color_add'=color that will be added to the texture using following formula "final_color = texture_color * color + color_add", 'rect'=screen rectangle at which the image will be drawn, 'border_size'=size of the border inside the screen 'rect' rectangle that will be drawn as image borders (this value should be less than rectangle dimensions), 'tex_frac'=fraction of the image texture that will be used for drawing the borders (this value should be in range of 0 .. 0.5), this function will draw with texture coordinates in vertical mode
// draw with custom filtering
void drawFilter( C Rect &rect, FILTER_TYPE filter=FILTER_BEST)C; // this method will draw the image with custom filtering which allows to achieve better quality than linear filtering, the pixel shader for better filters is very expensive, therefore use it only if performance is not critical and just for few images (for example displaying one image on the screen), this method supports only FILTER_NONE, FILTER_LINEAR, FILTER_CUBIC_FAST and FILTER_CUBIC_PLUS
void drawFilter(C Color &color, C Color &color_add, C Rect &rect, FILTER_TYPE filter=FILTER_BEST)C; // this method will draw the image with custom filtering which allows to achieve better quality than linear filtering, the pixel shader for better filters is very expensive, therefore use it only if performance is not critical and just for few images (for example displaying one image on the screen), this method supports only FILTER_NONE, FILTER_LINEAR, FILTER_CUBIC_FAST and FILTER_CUBIC_PLUS
// draw cube face
void drawCubeFace(C Color &color, C Color &color_add, C Rect &rect, DIR_ENUM face)C;
// draw in 3D space
void draw3D(C Color &color, Flt size, Flt angle, C Vec &pos)C; // draw as 3D billboard, this can be called in RM_BLEND mode or outside rendering function (in drawing function), this method supports only IMAGE_2D images, this relies on active object matrix which can be set using 'SetMatrix' function
void drawVolume(C Color &color, C Color &color_add, C OBox &obox, Flt voxel_density_factor=0.01f, Flt precision=1.0f, Int min_steps=2, Int max_steps=64)C; // draw as 3D volumetric image, 'voxel_density_factor'=density factor of a single voxel (0..1), 'precision'=number of steps per voxel (0..Inf), 'min_steps max_steps'=minimum and maximum number of steps (2..1024), this method can be called in RM_BLEND rendering mode, this method supports only IMAGE_3D images
// io
void operator=(C Str &name) ; // load, Exit on fail
void operator=(C UID &id ) ; // load, Exit on fail
#if EE_PRIVATE
Bool saveData ( File &f )C; // save, false on fail
Bool loadData ( File &f, ImageHeader *header=null, C Str &name=S) ; // load, false on fail
Bool _loadData( File &f, ImageHeader *header=null, C Str &name=S) ; // load, false on fail - Deprecated do not use !!
#endif
Bool save (C Str &name)C; // save, false on fail
Bool load (C Str &name) ; // load, false on fail
Bool save ( File &f )C; // save, false on fail
Bool load ( File &f ) ; // load, false on fail
#if EE_PRIVATE
Bool ImportTGA (C Str &name, Int type , Int mode=-1, Int mip_maps=-1); Bool ImportTGA (File &f, Int type, Int mode=-1, Int mip_maps=-1);
Bool ImportDDS (C Str &name, Int type , Int mode=-1, Int mip_maps=-1); Bool ImportDDS (File &f, Int type, Int mode=-1, Int mip_maps=-1);
Bool ImportBMPRaw( File &f , Bool ico=false ); Bool ExportBMPRaw(File &f, Byte byte_pp, Bool ico=false)C;
#endif
Bool ImportTry(C Str &name, Int type=-1, Int mode=-1, Int mip_maps=-1); // import BMP PNG JPG WEBP HEIF TGA TIF DDS PSD ICO HDR, 'type'=IMAGE_TYPE, 'mode'=IMAGE_MODE, 'mip_maps'=number of mip-maps (0=autodetect), -1=keep original value, false on fail
Image& mustImport (C Str &name, Int type=-1, Int mode=-1, Int mip_maps=-1); // import BMP PNG JPG WEBP HEIF TGA TIF DDS PSD ICO HDR, 'type'=IMAGE_TYPE, 'mode'=IMAGE_MODE, 'mip_maps'=number of mip-maps (0=autodetect), -1=keep original value, Exit on fail
Bool ImportTry( File &f , Int type=-1, Int mode=-1, Int mip_maps=-1); // import BMP PNG JPG WEBP HEIF TGA TIF DDS PSD ICO HDR, 'type'=IMAGE_TYPE, 'mode'=IMAGE_MODE, 'mip_maps'=number of mip-maps (0=autodetect), -1=keep original value, false on fail
Image& mustImport ( File &f , Int type=-1, Int mode=-1, Int mip_maps=-1); // import BMP PNG JPG WEBP HEIF TGA TIF DDS PSD ICO HDR, 'type'=IMAGE_TYPE, 'mode'=IMAGE_MODE, 'mip_maps'=number of mip-maps (0=autodetect), -1=keep original value, Exit on fail
Bool Export(C Str &name, Flt rgb_quality=-1, Flt alpha_quality=-1, Flt compression_level=-1, Int sub_sample=-1)C; // export according to extension, false on fail, 'rgb_quality'=color quality 0..1 (-1=default, 0=smallest size, 1=best quality), 'alpha_quality'=alpha quality 0..1 (-1=use 'rgb_quality', 0=smallest size, 1=best quality), 'compression_level'=0..1 (-1=default, 0=fast/biggest size, 1=slow/smallest size), 'sub_sample'=0..2 (chroma sub-sampling for RGB images, 0=none, 1=half, 2=quarter, -1=default)
Bool ImportCubeTry(C Image &right, C Image &left, C Image &up, C Image &down, C Image &forward, C Image &back, Int type=-1, Bool soft=false, Int mip_maps=1, Bool resize_to_pow2=true, FILTER_TYPE filter=FILTER_BEST); // import as cube texture, 'type'=IMAGE_TYPE (-1=keep original value), 'soft'=if use IMAGE_SOFT_CUBE or IMAGE_CUBE, false on fail
Bool ImportCubeTry(C Str &right, C Str &left, C Str &up, C Str &down, C Str &forward, C Str &back, Int type=-1, Bool soft=false, Int mip_maps=1, Bool resize_to_pow2=true, FILTER_TYPE filter=FILTER_BEST); // import BMP PNG JPG WEBP HEIF TGA TIF DDS PSD ICO HDR as cube texture, 'type'=IMAGE_TYPE (-1=keep original value), 'soft'=if use IMAGE_SOFT_CUBE or IMAGE_CUBE, false on fail
Image& mustImportCube (C Str &right, C Str &left, C Str &up, C Str &down, C Str &forward, C Str &back, Int type=-1, Bool soft=false, Int mip_maps=1, Bool resize_to_pow2=true, FILTER_TYPE filter=FILTER_BEST); // import BMP PNG JPG WEBP HEIF TGA TIF DDS PSD ICO HDR as cube texture, 'type'=IMAGE_TYPE (-1=keep original value), 'soft'=if use IMAGE_SOFT_CUBE or IMAGE_CUBE, Exit on fail
Bool ImportBMP (C Str &name ) ; // import BMP from file, false on fail
Bool ImportBMP ( File &f ) ; // import BMP from file, false on fail
Bool ExportBMP (C Str &name )C; // export as BMP to file, false on fail
Bool ExportBMP ( File &f )C; // export as BMP to file, false on fail
Bool ImportPNG (C Str &name ) ; // import PNG from file, false on fail
Bool ImportPNG ( File &f ) ; // import PNG from file, false on fail
Bool ExportPNG (C Str &name, Flt compression_level=-1 )C; // export as PNG to file, false on fail, 'compression_level'=0..1 (-1=default, 0=fast/biggest size, 1=slow/smallest size)
Bool ExportPNG ( File &f , Flt compression_level=-1 )C; // export as PNG to file, false on fail, 'compression_level'=0..1 (-1=default, 0=fast/biggest size, 1=slow/smallest size)
Bool ImportJPG (C Str &name ) ; // import JPG from file, false on fail
Bool ImportJPG ( File &f ) ; // import JPG from file, false on fail
Bool ExportJPG (C Str &name, Flt quality=-1, Int sub_sample=-1 )C; // export as JPG to file, false on fail, 'quality'=0..1 (-1=default, 0=smallest size, 1=best quality), 'sub_sample'=0..2 (chroma sub-sampling for RGB images, 0=none, 1=half, 2=quarter, -1=default)
Bool ExportJPG ( File &f , Flt quality=-1, Int sub_sample=-1 )C; // export as JPG to file, false on fail, 'quality'=0..1 (-1=default, 0=smallest size, 1=best quality), 'sub_sample'=0..2 (chroma sub-sampling for RGB images, 0=none, 1=half, 2=quarter, -1=default)
Bool ImportWEBP(C Str &name ) ; // import WEBP from file, false on fail
Bool ImportWEBP( File &f ) ; // import WEBP from file, false on fail
Bool ExportWEBP(C Str &name, Flt rgb_quality=-1, Flt alpha_quality=-1)C; // export as WEBP to file, false on fail, 'rgb_quality'=color quality 0..1 (-1=default, 0=smallest size, 1=lossless), 'alpha_quality'=alpha quality 0..1 (-1=use 'rgb_quality', 0=smallest size, 1=lossless)
Bool ExportWEBP( File &f , Flt rgb_quality=-1, Flt alpha_quality=-1)C; // export as WEBP to file, false on fail, 'rgb_quality'=color quality 0..1 (-1=default, 0=smallest size, 1=lossless), 'alpha_quality'=alpha quality 0..1 (-1=use 'rgb_quality', 0=smallest size, 1=lossless)
Bool ImportHEIF(C Str &name ) ; // import HEIF from file, false on fail
Bool ImportHEIF( File &f ) ; // import HEIF from file, false on fail
Bool ExportHEIF(C Str &name, Flt quality=-1 )C; // export as HEIF to file, false on fail, 'quality'=0..1 (-1=default, 0=smallest size, 1=lossless)
Bool ExportHEIF( File &f , Flt quality=-1 )C; // export as HEIF to file, false on fail, 'quality'=0..1 (-1=default, 0=smallest size, 1=lossless)
Bool ImportTGA (C Str &name ) ; // import TGA from file, false on fail
Bool ImportTGA ( File &f ) ; // import TGA from file, false on fail
Bool ExportTGA (C Str &name )C; // export as TGA to file, false on fail
Bool ExportTGA ( File &f )C; // export as TGA to file, false on fail
Bool ImportTIF (C Str &name ) ; // import TIF from file, false on fail
Bool ImportTIF ( File &f ) ; // import TIF from file, false on fail
Bool ExportTIF (C Str &name, Flt compression_level=-1 )C; // export as TIF to file, false on fail, 'compression_level'=0..1 (-1=default, 0=fast/biggest size, 1=slow/smallest size)
Bool ExportTIF ( File &f , Flt compression_level=-1 )C; // export as TIF to file, false on fail, 'compression_level'=0..1 (-1=default, 0=fast/biggest size, 1=slow/smallest size)
Bool ImportDDS (C Str &name ) ; // import DDS from file, false on fail
Bool ImportDDS ( File &f ) ; // import DDS from file, false on fail
Bool ExportDDS (C Str &name )C; // export as DDS to file, false on fail
Bool ImportPSD (C Str &name ) ; // import PSD from file, false on fail
Bool ImportPSD ( File &f ) ; // import PSD from file, false on fail
Bool ImportICO (C Str &name ) ; // import ICO from file, false on fail
Bool ImportICO ( File &f ) ; // import ICO from file, false on fail
Bool ExportICO (C Str &name )C; // export as ICO to file, false on fail
Bool ExportICO ( File &f )C; // export as ICO to file, false on fail
Bool ExportICNS(C Str &name )C; // export as ICNS to file, false on fail
Bool ExportICNS( File &f )C; // export as ICNS to file, false on fail
Bool ImportHDR (C Str &name ) ; // import HDR from file, false on fail
Bool ImportHDR ( File &f ) ; // import HDR from file, false on fail
Image& operator=(C Image &src); // create from 'src' image using 'copy' method, Exit on fail
~Image();
Image();
Image(C Image &src ); // create from 'src' image using 'copy' method, Exit on fail
explicit Image(Int w, Int h, Int d, IMAGE_TYPE type, IMAGE_MODE mode, Int mip_maps=0); // create with specified parameters using 'create' method, Exit on fail, 'mip_maps'=number of mip-maps (0=autodetect)
#if EE_PRIVATE
void zero () {Zero(T);}
Bool setInfo ();
void forceInfo (Int w, Int h, Int d, IMAGE_TYPE type, IMAGE_MODE mode, Int samples);
void adjustInfo (Int w, Int h, Int d, IMAGE_TYPE type);
void setPartial ();
void setGLParams();
Bool copySoft(Image &dest, FILTER_TYPE filter=FILTER_BEST, UInt flags=IC_CLAMP, Int max_mip_maps=INT_MAX, Flt sharp_smooth=1.0f)C; // software copy, 'flags'=IMAGE_COPY_FLAG, 'sharp_smooth'=factor affecting sharpness/smoothness (0..Inf, the closer to 0.0 then the sharper result, the bigger than 1.0 then the more blurry result, default=1.0)
void copyMs (ImageRT &dest, Bool restore_rt, Bool multi_sample, C RectI *rect =null )C; // multi sample texture copy, 'multi_sample'=average samples when writing to single sample, or copy texture on a per sample basis, this is needed because multi-sampled textures can't be sampled smoothly in the shader, this assumes that both source and dest are of the same size
void copyMs (ImageRT &dest, Bool restore_rt, Bool multi_sample, C Rect &rect )C; // multi sample texture copy, 'multi_sample'=average samples when writing to single sample, or copy texture on a per sample basis, this is needed because multi-sampled textures can't be sampled smoothly in the shader, this assumes that both source and dest are of the same size
void copyHw (ImageRT &dest, Bool restore_rt, C RectI *rect_src=null, C RectI *rect_dest=null )C; // hardware texture copy
void copyHw (ImageRT &dest, Bool restore_rt, C Rect &rect )C; // hardware texture copy
Bool capture(C ImageRT &src);
#endif
#if !EE_PRIVATE
private:
#endif
IMAGE_TYPE _type, _hw_type;
IMAGE_MODE _mode;
LOCK_MODE _lock_mode;
DIR_ENUM _lcf;
Byte _mms, _samples, _lmm, _byte_pp;
Bool _partial, _discard;
Int _lock_count;
UInt _pitch, _pitch2;
VecI _size, _hw_size, _lock_size;
Vec _part;
Byte *_data, *_data_all;
union
{
struct
{
#if EE_PRIVATE && DX11
ID3D11Resource *_txtr;
ID3D11ShaderResourceView *_srv ;
#else
Ptr _ptr[2];
#endif
};
struct
{
#if EE_PRIVATE && GL
UInt _txtr, _rb;
#else
UInt _uint[2];
#endif
};
};
};
/******************************************************************************/
DECLARE_CACHE(Image, Images, ImagePtr); // 'Images' cache storing 'Image' objects which can be accessed by 'ImagePtr' pointer
/******************************************************************************/
struct ImageHeader
{
VecI size;
Int mip_maps;
IMAGE_TYPE type;
IMAGE_MODE mode;
void zero() {size.zero(); mip_maps=0; type=IMAGE_NONE; mode=IMAGE_2D;}
ImageHeader() {zero();}
};
Bool ImageLoadHeader( File &f , ImageHeader &header); // load image header from file, this method is faster than 'Image.load' if you're not interested in the Image data, but only in information about it. After reading the header, 'f' file position is reset to the same place before making this call, false on fail
Bool ImageLoadHeader(C Str &name, ImageHeader &header); // load image header from file, this method is faster than 'Image.load' if you're not interested in the Image data, but only in information about it. false on fail
/******************************************************************************/
struct ImageCompare
{
Bool skipped ; // if comparison was interrupted due to 'skip_dif'
Flt max_dif , // max difference between colors, 0..1
avg_dif , // average difference between colors, 0..1
avg_dif2, // average difference between colors, 0..1 (using square method)
similar , // fraction of the image that is similar (difference is below 'similar_dif'), 0..1
psnr ; // peak signal to noise ratio, 0..Inf
Bool compare(C Image &a, C Image &b, Flt similar_dif=0.01f, Bool alpha_weight=false, Int a_mip=0, Flt skip_dif=1.0f); // compare 2 images, 'similar_dif'=limit used to determine that colors are similar, 'alpha_weight'=if use alpha channel as the weight, 'a_mip'=mip map of 'a' image used for comparison (based on this value, mip map of 'b' image will be selected to match the size of selected 'a' mip map), 'skip_dif'=if a single color difference exceeds this limit then skip remaining processing and return as soon as possible (value >=1 disables skipping), this function returns true on success and false on fail (if couldn't find matching mip map size between images, or if failed to lock the images)
};
/******************************************************************************/
IMAGE_TYPE BytesToImageType(Int byte_pp); // get IMAGE_TYPE needed to store 'byte_pp' amount of bytes per pixel, which is 1->IMAGE_I8, 2->IMAGE_I16, 3->IMAGE_I24, 4->IMAGE_I32, other->IMAGE_NONE
IMAGE_TYPE ImageTypeIncludeRGB(IMAGE_TYPE type); // convert 'type' to the most similar IMAGE_TYPE that has RGB channels
IMAGE_TYPE ImageTypeIncludeAlpha(IMAGE_TYPE type); // convert 'type' to the most similar IMAGE_TYPE that has alpha channel
IMAGE_TYPE ImageTypeExcludeAlpha(IMAGE_TYPE type); // convert 'type' to the most similar IMAGE_TYPE that has no alpha channel
IMAGE_TYPE ImageTypeToggleSRGB (IMAGE_TYPE type); // convert 'type' to the most similar IMAGE_TYPE that has different sRGB
IMAGE_TYPE ImageTypeIncludeSRGB(IMAGE_TYPE type); // convert 'type' to the most similar IMAGE_TYPE that has sRGB
IMAGE_TYPE ImageTypeExcludeSRGB(IMAGE_TYPE type); // convert 'type' to the most similar IMAGE_TYPE that has no sRGB
IMAGE_TYPE ImageTypeHighPrec(IMAGE_TYPE type); // convert 'type' to the most similar IMAGE_TYPE that has F32 precision per channel
IMAGE_TYPE ImageTypeUncompressed(IMAGE_TYPE type); // convert 'type' to the most similar IMAGE_TYPE that is not compressed
DIR_ENUM DirToCubeFace(C Vec &dir ); // convert vector direction (doesn't need to be normalized) to cube face
DIR_ENUM DirToCubeFace(C Vec &dir, Int res, Vec2 &tex); // convert vector direction (doesn't need to be normalized) to cube face and texture coordinates, 'res'=cube image resolution, 'tex'=image coordinates
Vec CubeFaceToDir(Flt x, Flt y, Int res, DIR_ENUM cube_face); // convert image coordinates, 'x,y'=image coordinates (0..res-1), 'res'=cube image resolution, 'cube_face'=image cube face, returned vector is not normalized, however its on a cube with radius=1 ("Abs(dir).max()=1")
#if EE_PRIVATE
struct ImageThreadsClass : Threads
{
ImageThreadsClass& init()
{
if(!created())createIfEmpty(false, Cpu.threads()-1, 0, "EE.Image #"); // -1 because we will do processing on the caller thread too
return T;
}
void process(Int elms, void func(IntPtr elm_index, Ptr user, Int thread_index), Ptr user) {process1(elms, func, user, INT_MAX);} // use all available threads, including this one
T1(USER_DATA) void process(Int elms, void func(IntPtr elm_index, USER_DATA &user, Int thread_index), USER_DATA &user) {process1(elms, func, user, INT_MAX);} // use all available threads, including this one
}extern ImageThreads;
extern const ImagePtr ImageNull;
// pointers to class method
typedef Flt (Image::*PtrImagePixel )(Flt x, Flt y, Bool clamp)C;
typedef Flt (Image::*PtrImagePixel3D )(Flt x, Flt y, Flt z, Bool clamp)C;
typedef Vec4 (Image::*PtrImageColor )(Flt x, Flt y, Bool clamp, Bool alpha_weight)C;
typedef Vec4 (Image::*PtrImageColor3D )(Flt x, Flt y, Flt z, Bool clamp, Bool alpha_weight)C;
typedef Vec4 (Image::*PtrImageAreaColor)(C Vec2 &pos, C Vec2 &size, Bool clamp, Bool alpha_weight)C;
PtrImagePixel GetImagePixelF (FILTER_TYPE filter);
PtrImagePixel3D GetImagePixel3DF (FILTER_TYPE filter);
PtrImageColor GetImageColorF (FILTER_TYPE filter);
PtrImageColor3D GetImageColor3DF (FILTER_TYPE filter);
PtrImageAreaColor GetImageAreaColor(FILTER_TYPE filter, Bool &linear_gamma);
Int ImageFaces (IMAGE_MODE mode);
Int PaddedWidth (Int w, Int h, Int mip, IMAGE_TYPE type);
Int PaddedHeight (Int w, Int h, Int mip, IMAGE_TYPE type);
Int ImagePitch (Int w, Int h, Int mip, IMAGE_TYPE type);
Int ImageBlocksY (Int w, Int h, Int mip, IMAGE_TYPE type);
Int ImageMipSize (Int w, Int h, Int mip, IMAGE_TYPE type);
Int ImageMipSize (Int w, Int h, Int d, Int mip, IMAGE_TYPE type);
UInt ImageSize (Int w, Int h, Int d, IMAGE_TYPE type, IMAGE_MODE mode, Int mip_maps);
GPU_API(DXGI_FORMAT, UInt) ImageTypeToFormat(Int type); // convert from IMAGE_TYPE to API_FORMAT
IMAGE_TYPE ImageFormatToType(GPU_API(DXGI_FORMAT, UInt) format); // convert from API_FORMAT to IMAGE_TYPE
Int TotalMipMaps (Int w, Int h, Int d, IMAGE_TYPE type);
IMAGE_TYPE ImageTypeOnFail(IMAGE_TYPE type);
Bool ImageSupported(IMAGE_TYPE type, IMAGE_MODE mode, Byte samples=1);
Bool IgnoreGamma(UInt flags, IMAGE_TYPE src, IMAGE_TYPE dest);
Bool CanDoRawCopy(IMAGE_TYPE src, IMAGE_TYPE dest, Bool ignore_gamma=false);
Bool CanDoRawCopy(C Image &src, C Image &dest, Bool ignore_gamma=false);
Bool CanCompress (IMAGE_TYPE dest);
Bool CompatibleLock(LOCK_MODE cur, LOCK_MODE lock); // if 'lock' is okay to be applied when 'cur' is already applied
Vec4 ImageColorF(CPtr data, IMAGE_TYPE hw_type);
Vec4 ImageColorL(CPtr data, IMAGE_TYPE hw_type);
void CopyNoStretch(C Image &src, Image &dest, Bool clamp, Bool ignore_gamma=false); // assumes 'src,dest' are locked and non-compressed
#if WINDOWS
HICON CreateIcon(C Image &image, C VecI2 *cursor_hot_spot=null); // 'cursor_hot_spot'=if this is specified then the icon is treated as a mouse cursor with given hot spot, otherwise it's a normal icon
#endif
#if GL
UInt SourceGLFormat(IMAGE_TYPE type);
UInt SourceGLType (IMAGE_TYPE type);
#endif
#endif
/******************************************************************************/
| [
"esenthel@hotmail.com"
] | esenthel@hotmail.com |
56a9f8254b470e2120ccd1a2fdaba21ac32fe7e2 | f760d086814b96dfc0a09da8ffc3c056ae6cc9af | /archive/challenge-0007/recursive-image-cxx/src/frac_builder.cxx | 41c18e34d02ef5b2f08da6ec322296978a6396fb | [] | no_license | psyomn/programming-exercise-solutions | cb548f48a91016dc26deecca0f0e43abfed51146 | 55944c333b851c7f1688fbc9b50fff6d366a2225 | refs/heads/master | 2021-01-17T09:14:55.242179 | 2016-12-15T23:39:35 | 2016-12-15T23:39:35 | 10,873,980 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 827 | cxx | #include "frac_builder.hxx"
using namespace std::literals;
FracBuilder::FracBuilder(std::function<double(double)> iFn) :
m_fn(iFn),
m_data(std::vector<std::complex<double> >()),
m_x(0),
m_y(0),
m_value(0.0)
{}
FracBuilder FracBuilder::x(double iX) {
m_x = iX;
return *this;
}
FracBuilder FracBuilder::y(double iY) {
m_y = iY;
return *this;
}
FracBuilder FracBuilder::value(double iValue) {
m_value = iValue;
return *this;
}
double FracBuilder::default_engine(std::complex<double> value) {
return 0.0;
}
FracBuilder FracBuilder::build() {
std::complex<double> dflt = 0. + 0i;
m_data.clear();
for (size_t i = 0; i < m_x; ++i)
for (size_t j = 0; j < m_y; ++j)
m_data.push_back(std::complex<double>(dflt));
return *this;
}
FracBuilder FracBuilder::process() {
return *this;
}
| [
"lethaljellybean@gmail.com"
] | lethaljellybean@gmail.com |
bbae13ef35b7aa28dd7c55be221c26c4f35d24a1 | ae9792e5ba21183c5a8270e50f48177ed31a774d | /bin/tlrplay-glfw/Util.cpp | f3b83fe3adf8c28f0f32a02df0fc626668106525 | [
"BSD-3-Clause",
"LicenseRef-scancode-free-unknown"
] | permissive | jhodges10/tlRender | 057c7095747ca1ec9a003921d5ecd1c19056c58e | b84b6197d8d1f5db9a9850399cd2da76be034b83 | refs/heads/main | 2023-06-19T02:49:48.885834 | 2021-07-13T23:56:54 | 2021-07-13T23:56:54 | 386,013,232 | 1 | 0 | BSD-3-Clause | 2021-07-14T16:56:40 | 2021-07-14T16:56:40 | null | UTF-8 | C++ | false | false | 3,383 | cpp | // SPDX-License-Identifier: BSD-3-Clause
// Copyright (c) 2021 Darby Johnston
// All rights reserved.
#include "Util.h"
#include <tlrCore/Color.h>
#include <tlrCore/Math.h>
#include <cmath>
namespace tlr
{
void drawHUDLabel(
const std::shared_ptr<gl::Render>& render,
const std::shared_ptr<gl::FontSystem>& fontSystem,
const imaging::Size& window,
const std::string& text,
gl::FontFamily fontFamily,
uint16_t fontSize,
HUDElement hudElement)
{
const imaging::Color4f labelColor(1.F, 1.F, 1.F);
const imaging::Color4f overlayColor(0.F, 0.F, 0.F, .7F);
const gl::FontInfo fontInfo(fontFamily, fontSize);
const gl::FontMetrics fontMetrics = fontSystem->getMetrics(fontInfo);
const float margin = fontSize;
const math::BBox2f marginBBox = math::BBox2f(0.F, 0.F, window.w, window.h).margin(-margin);
const math::Vector2f labelSize = fontSystem->measure(text, fontInfo);
const float labelMargin = fontSize / 5.F;
math::BBox2f bbox;
math::Vector2f pos;
switch (hudElement)
{
case HUDElement::UpperLeft:
bbox = math::BBox2f(
floorf(marginBBox.min.x),
floorf(marginBBox.min.y),
ceilf(labelSize.x + labelMargin * 2.F),
ceilf(fontMetrics.lineHeight + labelMargin * 2.F));
pos = math::Vector2f(
floorf(marginBBox.min.x + labelMargin),
floorf(marginBBox.min.y + labelMargin + fontMetrics.ascender));
break;
case HUDElement::UpperRight:
bbox = math::BBox2f(
floorf(marginBBox.max.x - labelMargin * 2.F - labelSize.x),
floorf(marginBBox.min.y),
ceilf(labelSize.x + labelMargin * 2.F),
ceilf(fontMetrics.lineHeight + labelMargin * 2.F));
pos = math::Vector2f(
floorf(marginBBox.max.x - labelMargin - labelSize.x),
floorf(marginBBox.min.y + labelMargin + fontMetrics.ascender));
break;
case HUDElement::LowerLeft:
bbox = math::BBox2f(
floorf(marginBBox.min.x),
floorf(marginBBox.max.y - labelMargin * 2.F - fontMetrics.lineHeight),
ceilf(labelSize.x + labelMargin * 2.F),
ceilf(fontMetrics.lineHeight + labelMargin * 2.F));
pos = math::Vector2f(
floorf(marginBBox.min.x + labelMargin),
floorf(marginBBox.max.y - labelMargin - fontMetrics.lineHeight + fontMetrics.ascender));
break;
case HUDElement::LowerRight:
bbox = math::BBox2f(
floorf(marginBBox.max.x - labelMargin * 2.F - labelSize.x),
floorf(marginBBox.max.y - labelMargin * 2.F - fontMetrics.lineHeight),
ceilf(labelSize.x + labelMargin * 2.F),
ceilf(fontMetrics.lineHeight + labelMargin * 2.F));
pos = math::Vector2f(
floorf(marginBBox.max.x - labelMargin - labelSize.x),
floorf(marginBBox.max.y - labelMargin - fontMetrics.lineHeight + fontMetrics.ascender));
break;
}
render->drawRect(bbox, overlayColor);
render->drawText(fontSystem->getGlyphs(text, fontInfo), pos, labelColor);
}
}
| [
"darbyjohnston@yahoo.com"
] | darbyjohnston@yahoo.com |
8fa516f70a7aab8381faec39c12f73bf72b8bf82 | ac67de87a6c7c4391c8398f409745e284fd70d76 | /e_Team.h | 39f274d4d354c524485c30ab49d1bb1e3f0f2a2d | [] | no_license | Wasgo097/mygame | 6a2af89edf83749cd793568203de0b0b4d7112fd | dce2ebd0afc0c08019b5d1da321653c39930d7ac | refs/heads/master | 2020-06-26T16:37:20.432575 | 2019-07-30T16:45:28 | 2019-07-30T16:45:28 | 199,687,279 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,029 | h | #pragma once
#include "base_e_Team.h"
class e_Team:public base_e_Team{
sf::Texture texture[5];
public:
e_Team(const sf::Vector2f& ratio, Quality q) {
int texture_index = 0;
int fig = 0;
int wiz = 0;
int m_war = 0;
int tan = 0;
int arc = 0;
this->ratio = ratio;
while (e_team_full.size()<5) {
int j = std::rand() % 5;
if (j == 0 && fig<2) {
fig++;
//e_team.push_back(rand_eFighter(q));
string path_texture = "Enemy/fight" + std::to_string(std::rand() % 3 + 1) + ".png";
if (!texture[texture_index].loadFromFile(path_texture)) {
std::cout << "Error with enemies team generation";
exit(-1);
}
sf::Sprite sprite;
sprite.setTexture(texture[texture_index]);
//sprite_e_team.push_back(sprite);
e_team_full.push_back(std::make_pair(sprite, rand_eFighter(q)));
texture_index++;
}
else if (j == 1 && wiz < 2) {
wiz++;
//e_team.push_back(rand_eWizzard(q));
string path_texture = "Enemy/wizz" + std::to_string(std::rand() % 3 + 1) + ".png";
if (!texture[texture_index].loadFromFile(path_texture)) {
std::cout << "Error with enemies team generation";
exit(-1);
}
sf::Sprite sprite;
sprite.setTexture(texture[texture_index]);
e_team_full.push_back(std::make_pair(sprite, rand_eWizzard(q)));
//sprite_e_team.push_back(sprite);
texture_index++;
}
else if (j == 2 && m_war<2) {
m_war++;
//e_team.push_back(rand_eMage_warrior(q));
string path_texture = "Enemy/m_warr" + std::to_string(std::rand() % 3 + 1) + ".png";
if (!texture[texture_index].loadFromFile(path_texture)) {
std::cout << "Error with enemies team generation";
exit(-1);
}
sf::Sprite sprite;
sprite.setTexture(texture[texture_index]);
//sprite_e_team.push_back(sprite);
e_team_full.push_back(std::make_pair(sprite, rand_eMage_warrior(q)));
texture_index++;
}
else if (j == 3 && tan<2) {
tan++;
//e_team.push_back(rand_eTank(q));
string path_texture = "Enemy/tank" + std::to_string(std::rand() % 3 + 1) + ".png";
if (!texture[texture_index].loadFromFile(path_texture)) {
std::cout << "Error with enemies team generation";
exit(-1);
}
sf::Sprite sprite;
sprite.setTexture(texture[texture_index]);
//sprite_e_team.push_back(sprite);
e_team_full.push_back(std::make_pair(sprite, rand_eTank(q)));
texture_index++;
}
else if (j == 4 && arc<2) {
arc++;
//e_team.push_back(rand_eArcher(q));
string path_texture = "Enemy/arch" + std::to_string(std::rand() % 3 + 1) + ".png";
if (!texture[texture_index].loadFromFile(path_texture)) {
std::cout << "Error with enemies team generation";
exit(-1);
}
sf::Sprite sprite;
sprite.setTexture(texture[texture_index]);
//sprite_e_team.push_back(sprite);
e_team_full.push_back(std::make_pair(sprite, rand_eArcher(q)));
texture_index++;
}
else continue;
}
for (auto c : e_team_full) {
c.first.setScale(ratio.x, ratio.y);
}
}
~e_Team(){}
};
| [
"patrykpakula321@gmail.com"
] | patrykpakula321@gmail.com |
572ed0ec391adf658efd3994edefb8ce666d8013 | 4b394b378f5d35d055f730592552daaefdadcc71 | /2 course/OOP/lab2-4/main.cpp | 902c2d51e062349e9aaca61d809462f62dfd09d6 | [
"Unlicense"
] | permissive | semyon-dev/bonch-labs | 092c73bfd81a75a9f1cff714d5cfa2cbf19598a0 | 632a692e27eee5ab34dd6684a6d2d095ff4f89d6 | refs/heads/master | 2023-01-13T01:04:54.437134 | 2022-12-22T09:27:33 | 2022-12-22T09:27:33 | 246,418,646 | 8 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 507 | cpp | #include <iostream>
#include "CTwo.hpp"
#include "COne.hpp"
#include "CThree.hpp"
#include "CFour.hpp"
using std::cout;
using std::endl;
void printAll(CTwo **ctwo, size_t n) {
for (int i = 0; i < n; i++) {
ctwo[i]->print();
}
}
int main() {
COne cone(1.1, "f");
CTwo ctwo(2.2, &cone);
CThree cThree(3, ctwo);
CFour cFour(4, cThree);
cThree.setInt(10);
CTwo *ctwos[3] = {&ctwo, &cThree, &cFour};
printAll(ctwos, 3);
return 0;
} | [
"semyon-dev@protonmail.com"
] | semyon-dev@protonmail.com |
d9b0bcc4e35b116a6fbd7de62a195833708e64fc | a1242faa44b9a723b9b6a99c016371dfa37ccba9 | /include/mobj/domains/MOGWManhattanHeuristic.h | 1f2cc21e693723995fc902d6f09b6306012f72ce | [
"MIT"
] | permissive | mejrpete/mdp-lib | 6a73db290f5a17ab410460f48e3a92e6627e35ab | 8e8e0f1fbbacf9a0ff9e42a2934270676633de29 | refs/heads/master | 2022-11-27T00:14:14.318671 | 2019-07-16T12:48:08 | 2019-07-16T12:48:08 | 266,203,595 | 0 | 0 | MIT | 2020-05-22T20:42:22 | 2020-05-22T20:42:22 | null | UTF-8 | C++ | false | false | 1,496 | h | #ifndef MDPLIB_MOGWSECONDHEUR_H
#define MDPLIB_MOGWSECONDHEUR_H
#include "../../util/general.h"
#include "../../heuristic.h"
#include "../../state.h"
#include "MOGridWorldProblem.h"
#include "MOGridWorldState.h"
namespace mlmobj
{
class MOGWManhattanHeuristic : public mlcore::Heuristic
{
private:
MOGridWorldProblem* problem_;
double costDown_;
public:
MOGWManhattanHeuristic(MOGridWorldProblem* problem, double costDown)
{
problem_ = problem;
costDown_ = costDown;
}
virtual double cost(const mlcore::State* s)
{
MOGridWorldState* gws = (MOGridWorldState*) s;
double cost_ = mdplib::dead_end_cost;
if (gws->x() == -1) // absorbing dummy state
return 0;
for (PairDoubleMap::iterator it = problem_->goals()[0].begin();
it != problem_->goals()[0].end(); it++) {
std::pair<int,int> goal = it->first;
double value = it->second;
if (gws->x() == goal.first && gws->y() == goal.second)
return value;
double distX = abs(gws->x() - goal.first);
double distY = abs(gws->y() - goal.second);
double mult = (gws->y() > goal.second) ? costDown_ : 1.0;
double goalCost = problem_->actionCost() * (distX + mult * distY) + value;
if (goalCost < cost_)
cost_ = goalCost;
}
return cost_;
}
};
}
#endif // MDPLIB_MOGWSECONDHEUR_H
| [
"luisen.p@gmail.com"
] | luisen.p@gmail.com |
9efe6918f61f1e6f18ae6806f104a5f4b5f9a7bf | 1a91bdd47ab7829a278da1fb6ddcfc5c386293b3 | /third_party/dapcstp/src/main.cpp | ca56e2f59aa7ae3253c6c2570618acaf55bf1a36 | [] | no_license | danzeng8/TopoSimplifier | 43738b843577fc34cc469bed24bdf23c4fcf088b | 10753151afac5bd35f574f834a029788ecd1e25e | refs/heads/master | 2023-07-09T22:06:18.850305 | 2021-08-04T21:09:00 | 2021-08-04T21:09:00 | 266,427,563 | 22 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 5,627 | cpp | /**
* \file main.cpp
* \brief solver for apcstp instances
*
* \author Martin Luipersbeck
* \date 2015-05-03
*/
#include <stdio.h>
#include <vector>
#include <boost/filesystem.hpp>
#include "stats.h"
#include "options.h"
#include "procstatus.h"
#include "timer.h"
#include "ds.h"
#include "bbtree.h"
#include "prep.h"
Inst load();
void solve(Inst& inst);
double bestKnown = -1;
int main(int argc, char *argv[])
{
enlargeStack();
ProgramOptions po(argc, argv);
ProcStatus::setMemLimit(params.memlimit);
srand(params.seed);
Inst inst = load();
solve(inst);
return 0;
}
Inst load()
{
// load instance file
if(params.file.empty()) {
EXIT("Input file missing.\n");
}
Timer tLoad(true);
Inst inst = load(params.file.c_str());
if(params.bigM) {
if(inst.r == -1) {
inst = inst.createRootedBigMCopy();
} else {
params.bigM = false;
}
}
stats.name = boost::filesystem::path(params.file).stem().string();
if(!params.boundsfile.empty()) {
bestKnown = getBestKnownBound(params.file.c_str(), params.boundsfile.c_str());
}
printf("[ %sload%s ] [ %s%5.1lf s%s ] ", GREEN, NORMAL, GRAY, tLoad.elapsed().getSeconds(), NORMAL);
printf("n %5d m %5d t %5d ", inst.n, inst.m, inst.t);
printf("integer %d asym %d bidir %5.2lf ", inst.isInt, inst.isAsym, stats.bidirect);
printf("( %s%s%s )", GREEN, stats.name.c_str(), NORMAL);
printf(" ( best: %s", YELLOWBI);
if(bestKnown < 0) {
printf("N/A");
} else if(inst.isInt)
printf("%.0lf", bestKnown);
else
printf("%.6lf", bestKnown);
printf("%s )\n\n", NORMAL);
return inst;
}
void solve(Inst& inst)
{
BBTree bbtree(inst);
if(!params.solfile.empty()) {
Sol start = loadSol(params.solfile.c_str(), inst);
bbtree.setIncumbent(start);
}
if(params.initprep) {
Timer tPrep(true);
bbtree.initPrep();
stats.prep = inst.countInstSize();
stats.preptime = tPrep.elapsed().getSeconds();
printf("[ %sprep%s ] [ %s%5.1lf s%s ] ( %4.1lf %% )", GREEN, NORMAL, GRAY, stats.preptime, NORMAL, stats.prep.m*100.0/inst.m);
// big-M is only relevant for unrooted instances
if(params.semiBigM && inst.r == -1) {
printf(" lbM ");
if(inst.isInt)
printf("%13.0lf", format(bbtree.getLBM(), inst));
else
printf("%13.6lf", format(bbtree.getLBM(), inst));
}
printf("\n\n");
}
if(params.cutoff > 0.0)
bbtree.setCutUp(params.cutoff);
if(params.cutoffopt)
bbtree.setCutUp(bestKnown);
bbtree.setBestKnown(bestKnown);
// solve
if(params.heuronly) {
bbtree.initHeur();
} else if(params.rootonly) {
bbtree.initHeur();
if(params.timelimit >= 0)
bbtree.setTimeLim(max(0.0,params.timelimit-Timer::total.elapsed().getSeconds()));
if(params.nodelimit >= 0)
bbtree.setNodeLim(params.nodelimit);
bbtree.processRoots();
} else {
bbtree.initHeur();
if(params.timelimit >= 0)
bbtree.setTimeLim(max(0.0,params.timelimit-Timer::total.elapsed().getSeconds()));
if(params.nodelimit >= 0)
bbtree.setNodeLim(params.nodelimit);
bbtree.solve();
}
stats.bbnodes = bbtree.getNnodes();
stats.isInt = inst.isInt;
stats.isAsym = inst.isAsym;
// timing
stats.bbtime = bbtree.getTime();
stats.timeBest = bbtree.getTimeBest();
stats.roottime = bbtree.getRootTime();
stats.heurtime = bbtree.getHeurTime();
stats.heurbbtime = bbtree.getHeurBBTime();
// bounds
stats.ub = format(bbtree.getUB(), inst);
stats.lb = format(bbtree.getLB(), inst);
stats.gap = gapP(stats.lb, stats.ub);
// root
stats.rootub = format(bbtree.getRootUB(), inst);
stats.rootlb = format(bbtree.getRootLB(), inst);
stats.rootgap = gapP(stats.rootlb, stats.rootub);
stats.roots = bbtree.getNroots();
stats.oroots = bbtree.getNrootsOpen();
stats.proots = bbtree.getNrootsProcessed();
if(bbtree.getState() == BBTree::State::BB_MEMLIMIT)
stats.memout = 1;
// get running time and backmapped solution
stats.time = Timer::total.elapsed().getSeconds();
auto S = bbtree.getInc1();
weight_t ub = S.obj;
weight_t lb = bbtree.getLB();
// check if value from bound file matches computed optimum value
const bool match = (abs(format(ub, inst)-bestKnown) < 1e-5);
// validates solution
stats.valid = S.validate();
//printf("v %6d e %6d t %6d tr %6d bb %6d ", stats.initial.n, stats.initial.m, stats.initial.t, stats.initial.tr, bbtree.getIter());
printf("bbnodes %15d\n", bbtree.getNnodes());
printf("ub ");
printBoundPadded(inst, ub);
printf("\n");
printf("lb ");
printBoundPadded(inst, lb);
printf("\n");
printf("rootub ");
printBoundPadded(inst, bbtree.getRootUB());
printf("\n");
printf("rootlb ");
printBoundPadded(inst, bbtree.getRootLB());
printf("\n");
printf("gap %15.3lf\n", bbtree.getGap());
printf("gapR %15.3lf\n", bbtree.getRootGap());
printf("timeBest %15.1lf\n", stats.timeBest);
printf("time %15.1lf\n", stats.time);
printf("matches %15d\n", match);
printf("valid %15d\n", (int)stats.valid);
printf("lc %5d d1 %5d d2 %5d ma %5d ms %5d ss %5d nr %5d bb %5d\n", stats.lc, stats.d1, stats.d2, stats.ma, stats.ms, stats.ss, stats.nr, stats.boundbased);
// write output files (solution + stats)
if(!params.statsfile.empty()) {
ProgramStats::writeStats(params.statsfile.c_str());
}
if(!params.soloutfile.empty()) {
writeSolution(params.soloutfile.c_str(), bbtree.getInst1(), bbtree.getInc1());
}
if(inst.isMWCS) {
delete inst.transformation;
}
if(params.printstatsline)
printf("STAT;%s;%d;%d;%d;%.6lf;%.6lf;%.6lf;%.3lf;%d;%d;%d\n", stats.name.c_str(), inst.n, inst.m, stats.bbnodes, stats.gap, stats.lb, stats.ub, stats.time, stats.valid, match, stats.memout);
}
| [
"danzeng@CSE-YAJIE.seas.wustl.edu"
] | danzeng@CSE-YAJIE.seas.wustl.edu |
30b5855c90b6961a8b2cdf2c2405adc48266a59e | f15ec81503d395becaa7db346f7062222c3b8104 | /Space_Typers/space_typers.cpp | 7c96e00bae00e7131add8118cfc1885ded0b9887 | [] | no_license | Bade99/Space_Typers | 86aad53e737bf5fc3d644ffca840932be00a0415 | 45868800b76174b87ef4f21edcc7f1f0a37d18dd | refs/heads/master | 2022-12-01T03:06:50.889299 | 2020-08-17T18:02:28 | 2020-08-17T18:02:28 | 280,565,558 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 73,249 | cpp | #include "space_typers.h"
//REMAINDERS:
//·optimization fp:fast
//·optimization (google) intel intrinsics guide
//void game_output_sound(game_soundbuffer* sound_buf, int hz) {
// static f32 sine_t = 0;
// int volume = 3000;
// int waveperiod = sound_buf->samples_per_sec / hz;
//
// i16* sample_out = sound_buf->samples;
// for (int sample_index = 0; sample_index < sound_buf->sample_count_to_output; sample_index++) {
// f32 sine = sinf(sine_t);
// i16 sample_val = (i16)(sine * volume);
// *sample_out++ = sample_val;
// *sample_out++ = sample_val;
// sine_t += (1.f / (f32)waveperiod) * 2.f * (f32)M_PI; //Maintain position in the sine wave, otherwise on frequency change we have a discontinuity
//
// if (sine_t > (2.f * (f32)M_PI)) sine_t -= (2.f * (f32)M_PI); //INFO REMEMBER: great visualization of float losing precision, if you dont keep it between 0 and 2pi sooner or later the sine starts to be wrong
//
// }
//}
void game_get_sound_samples(game_memory* memory, game_soundbuffer* sound_buf) {
//game_assert(sizeof(game_state) <= memory->permanent_storage_sz);
//game_state* game_st = (game_state*)memory->permanent_storage;
//game_output_sound(sound_buf, game_st->hz);
}
//bool game_check_collision_point_to_rc(v2 p, rc r) {
// return p.x > (r.center.x-r.radius.x)&& p.x < (r.center.x + r.radius.x) && p.y >(r.center.y - r.radius.y) && p.y < (r.center.y + r.radius.y);
//}
img DEBUG_load_png(const char* filename) {
img res{0};
auto [img_mem, img_sz] = platform_read_entire_file(filename);
if (img_mem) {
int width, height, channels;
u8* bytes = stbi_load_from_memory((u8*)img_mem, img_sz, &width, &height, &channels, 0); //NOTE: this interface always assumes 8 bits per component
//TODO(fran): the memory for the image should be taken from the arena
platform_free_file_memory(img_mem);
if (bytes) {
game_assert(channels == 4);
game_assert(width >= 0 && height >= 0);
res.mem = bytes;
res.width = width;
res.height = height;
res.pitch = width * IMG_BYTES_PER_PIXEL;
res.width_over_height = (f32)width / (f32)height;
//res.channels = channels;
//res.bytes_per_channel = 1; //NOTE: this interface always assumes 8 bits per component
//NOTE: for premultiplied alpha to work we need to convert all our images to that "format" when loaded, therefore this changes too
u8* img_row = (u8*)res.mem; //INFO: R and B values need to be swapped
for (int y = 0; y < res.height; y++) {
u32* img_pixel = (u32*)img_row;
for (int x = 0; x < res.width; x++) {
v4 texel = { (f32)((*img_pixel & 0x000000FF) >> 0),
(f32)((*img_pixel & 0x0000FF00) >> 8),
(f32)((*img_pixel & 0x00FF0000) >> 16),
(f32)((*img_pixel & 0xFF000000) >> 24) };//TODO(fran): I can just do >>24, check that it puts 0 in the bits left behind and not 1 (when most signif bit is 1)
#if 1
texel = srgb255_to_linear1(texel);
texel.rgb *= texel.a;//premultiplying
texel = linear1_to_srgb255(texel);
#endif
//AARRGGBB
*img_pixel++ = round_f32_to_u32(texel.a) << 24 | round_f32_to_u32(texel.r) << 16 | round_f32_to_u32(texel.g) << 8 | round_f32_to_u32(texel.b) << 0;
}
img_row += res.pitch;
}
//TODO(fran): get align x and y
}
}
return res;
}
void DEBUG_unload_png(img* image) {
stbi_image_free(image->mem); //TODO(fran): use the memory arena
//TODO(fran): zero the other members?
}
void render_char(img* buf, rc2 rect, u8* bmp, int width, int height) { //TODO(fran): premultiplied alpha? and generalize img to img operation
//NOTE: stb creates top down img with 1 byte per pixel
v2_i32 min = { round_f32_to_i32(rect.get_min().x), round_f32_to_i32(rect.get_min().y) };
v2_i32 max = { round_f32_to_i32(rect.get_max().x), round_f32_to_i32(rect.get_max().y) };
int offset_x = 0;
int offset_y = 0;
if (min.x < 0) { offset_x = -min.x; min.x = 0; }
if (min.y < 0) { offset_y = -min.y; min.y = 0; }
if (max.x > buf->width)max.x = buf->width;
if (max.y > buf->height)max.y = buf->height;
int img_pitch = width;
u8* row = (u8*)buf->mem + min.y * buf->pitch + min.x * IMG_BYTES_PER_PIXEL;
u8* img_row = bmp + offset_x + offset_y * img_pitch;
f32 color_r = 255.f;
f32 color_g = 255.f;
f32 color_b = 255.f;
for (int y = min.y; y < max.y; y++) {
u32* pixel = (u32*)row;
u8* img_pixel = img_row;
for (int x = min.x; x < max.x; x++) {
//AARRGGBB
//very slow linear blend
f32 s_a = (f32)(*img_pixel) / 255.f; //source
f32 s_r = color_r;
f32 s_g = color_g;
f32 s_b = color_b;
f32 d_r = (f32)((*pixel >> 16) & 0xFF); //dest
f32 d_g = (f32)((*pixel >> 8) & 0xFF);
f32 d_b = (f32)((*pixel >> 0) & 0xFF);
f32 r = (1.f - s_a) * d_r + s_a * s_r; //TODO(fran): what if the dest had an alpha different from 255?
f32 g = (1.f - s_a) * d_g + s_a * s_g;
f32 b = (1.f - s_a) * d_b + s_a * s_b;
*pixel = 0xFF << 24 | round_f32_to_i32(r) << 16 | round_f32_to_i32(g) << 8 | round_f32_to_i32(b) << 0;
pixel++;
img_pixel++;
}
row += buf->pitch;
img_row += img_pitch;
}
}
void game_add_entity(game_state* game_st, game_entity* new_entity) {
game_assert(game_st->entity_count+1 < arr_count(game_st->entities));
game_st->entities[game_st->entity_count] = *new_entity; //TODO(fran): im pretty sure this cant be a straight copy no more, now we have the collision array
game_st->entity_count++;
}
void game_remove_entity(game_state* gs, u32 index) { //TODO(fran): remove entity for real, clear img and etc
assert(index < gs->entity_count);
if (index != gs->entity_count - 1) {
gs->entities[index] = gs->entities[gs->entity_count - 1];
}
gs->entity_count--;
}
void game_clear_entities(game_state* game_st) {
game_st->entity_count = 1;//TODO(fran): once again, 1 or 0?
game_assert(game_st->entities[0].type == entity_null);
}
bool test_wall(f32 wallx, f32 oldposx, f32 oldposy, f32 deltax, f32 deltay, f32* t_min, f32 miny, f32 maxy){ //REMEMBER: test_wall has the "hidden" rule that it checks the current t_min and only changes it if the new one is smaller
if (deltax != 0.f) {
f32 t_res = (wallx - oldposx) / deltax;
f32 Y = oldposy + t_res * deltay;
if (t_res >= 0.f && t_res < *t_min && Y >= miny && Y <= maxy) {
f32 epsilon = .001f;
*t_min = maximum(.0f, t_res - epsilon);
return true;
}
}
return false;
}
game_entity* get_entity(game_state* gs, u32 index) {
return &gs->entities[index];
}
//INFO: allows for specifying specific This entity vs This entity collision decisions, not just by entity type
void add_collision_rule(game_state* gs, game_entity* A, game_entity* B, bool can_collide) { //TODO(fran): change game_entity* to u32 indexes
//TODO: collapse this with should_collide
if (A > B) { //enforce order to simplify hash table access //TODO(fran): again probably straight checking the pointers is no good
game_entity* temp = A;
A = B;
B = temp;
}
//TODO(fran): better hash function
pairwise_collision_rule* found = 0;
u32 hash_bucket = (u32)A & (arr_count(gs->collision_rule_hash) - 1);
for (pairwise_collision_rule* rule = gs->collision_rule_hash[hash_bucket]; rule; rule = rule->next_in_hash) {
if (rule->a == A && rule->b == B) {
found = rule;
break;
}
}
if (!found) {
found = gs->first_free_collision_rule;
if (found) {
gs->first_free_collision_rule = gs->first_free_collision_rule->next_in_hash;
}
else {
found = push_type(&gs->permanent_arena, pairwise_collision_rule);//TODO(fran): pass arena as param
}
found->next_in_hash = gs->collision_rule_hash[hash_bucket];
gs->collision_rule_hash[hash_bucket] = found;
}
if (found) {
found->a = A;
found->b = B;
found->can_collide = can_collide;
}
}
bool can_overlap(game_state* gs, game_entity* mover, game_entity* region) {
bool res = false;
if (mover != region) {
if (region->type == entity_word_spawner) {
res = true;
}
}
return res;
}
void handle_overlap(game_state* gs, game_entity* mover, game_entity* region) {
//NOTE: im following handmade hero's idea for overlapping to learn new things, but probably this system is unnecessary for this game and should TODO: change it (I liked the was overlapping idea, checking collision begin, end, and already overlapping)
}
bool can_collide(game_state* gs, game_entity* A, game_entity* B) {
bool res=false;
if (A != B) {
if (A > B) { //enforce order to simplify hash table access //TODO(fran): again probably straight checking the pointers is no good
game_entity* temp = A;
A = B;
B = temp;
}
if (is_set(A, entity_flag_alive) && is_set(B, entity_flag_alive)) res = true; //TODO(fran): property based logic goes here
if (A->type == entity_word_spawner || B->type == entity_word_spawner) res = false; //TODO(fran): if I dont do this words cant get out of the spawner cause they get a tmin of 0, why doesnt this happen always someones collides with something?
//is_set(possible_collider, entity_flag_collides) && is_set(possible_collider, entity_flag_solid) && possible_collider != entity
//TODO(fran): better hash function
u32 hash_bucket = (u32)A & (arr_count(gs->collision_rule_hash) - 1);//TODO(fran): add u32 storage_index variable to game_entity struct, casting to u32 a pointer doesnt look too nice
for (pairwise_collision_rule* rule = gs->collision_rule_hash[hash_bucket]; rule; rule = rule->next_in_hash) {
if (rule->a == A && rule->b == B) {
res = rule->can_collide; //the rule overrides any other condition
break;
}
}
}
return res;
}
bool handle_collision(game_entity* A, game_entity* B) {
bool stops_on_collision = false;// is_set(entity, entity_flag_collides);
if (A->type == entity_word || B->type == entity_word || A->type==entity_word_spawner || B->type == entity_word_spawner)
stops_on_collision = false;
else
stops_on_collision = true;
if (A->type > B->type) { //enforce order to reduce collision handling routines in almost half
game_entity* temp = A;
A = B;
B = temp;
}
if (A->type == entity_word && B->type == entity_wall) {
clear_flags(A, entity_flag_alive); //TODO(fran): once a word hits a wall we probably want to add a collision rule for avoiding further collisions between those two (right now it doesnt matter cause we destroy the word at the end of the frame but later there'll probably be some animation, like a fade, of the word before being destroyed and that would cause multiple collisions thus, for example reducing the life of the player more than once)
}
//add_collision_rule(gs,entity, hit_entity, false);
return stops_on_collision;
}
bool entities_overlap(game_entity* entity, game_entity* test_entity) {
bool res = false;
for (u32 entity_area_idx = 0; !res && entity_area_idx < entity->collision.area_count; entity_area_idx++) {
game_entity_collision_area* entity_area = &entity->collision.areas[entity_area_idx];
rc2 entity_collider = rc_center_radius(entity->pos + entity_area->offset, entity_area->radius);
for (u32 test_collider_area_idx = 0; !res && test_collider_area_idx < test_entity->collision.area_count; test_collider_area_idx++) {//TODO(fran): optimization: maybe break is faster than always checking !res in both loops
game_entity_collision_area* test_area = &test_entity->collision.areas[test_collider_area_idx];
rc2 test_collider = rc_center_radius(test_entity->pos + test_area->offset, test_area->radius);
res = rcs_intersect(entity_collider, test_collider);
}
}
return res;
}
void move_entity(game_entity* entity, v2 acceleration, game_state* gs, game_input* input) { //NOTE: im starting to feel the annoyance of const, everything that is used inside here (other functions for example) would have to get const'd as well, so out it went
//rc2 e = rc_center_radius(entity->pos, entity->radius);
v2 pos_delta = .5f * acceleration * squared(input->dt_sec) + entity->velocity * input->dt_sec;//NOTE: we'll start just checking a point
entity->velocity += acceleration * input->dt_sec;//TODO: where does this go? //NOTE: Casey put it here, it had it before calculating pos_delta
//NOTE: day 67, min ~30 presents ideas on collision detection and the ways of operating on the entities that have responses/specific behaviours to collisions
//NOTE: day 80 interesting handling of "traversable" entities (overlap)
//if (is_set(entity,entity_flag_collides)) { //NOTE: everybody checks collisions, for now
for (int attempt = 0; attempt < 4; attempt++) {
f32 closest_t = 1.f; //limits the time to the full motion that can occur
v2 wall_normal{ 0,0 };
game_entity* hit_entity = 0;
v2 desired_position = entity->pos + pos_delta;
for (u32 entity_index = 1; entity_index < gs->entity_count; entity_index++)//TODO(fran): what to do, always start from 1?
{
game_entity* possible_collider = get_entity(gs,entity_index);//TODO(fran): GetEntityIndex function
//TODO(fran): re-integrate the "solid" flag or create a new "overlappable" flag
if (can_collide(gs,entity,possible_collider)) { //TODO(fran): add? can_collide || can_overlap && entities_overlap
for (u32 entity_area_idx = 0; entity_area_idx < entity->collision.area_count; entity_area_idx++) {
game_entity_collision_area* entity_area = &entity->collision.areas[entity_area_idx];
rc2 e = rc_center_radius(entity->pos+entity_area->offset, entity_area->radius);
for (u32 possible_collider_area_idx = 0; possible_collider_area_idx < possible_collider->collision.area_count; possible_collider_area_idx++) {
game_entity_collision_area* possible_collider_area = &possible_collider->collision.areas[possible_collider_area_idx];
rc2 collider = rc_center_radius(possible_collider->pos+ possible_collider_area->offset, possible_collider_area->radius);
//Following the Minkowski Sum now we reduce the entity to a point and expand every other object by the size of the entity, so with no need to change any of the code we get for free collision detection for the entire shape of the entity
collider.radius += e.radius;
v2 min_collider = collider.get_min();
v2 max_collider = collider.get_max();
//TODO: mirar dia 52 min 9:47, handmade hero NO usa e.pos acá sino "Rel" que es igual a e.pos-collider.pos
if (test_wall(min_collider.x, e.center.x, e.center.y, pos_delta.x, pos_delta.y, &closest_t, min_collider.y, max_collider.y)) {
wall_normal = { -1,0 };
hit_entity = possible_collider;
}
if (test_wall(max_collider.x, e.center.x, e.center.y, pos_delta.x, pos_delta.y, &closest_t, min_collider.y, max_collider.y)) {
wall_normal = { 1,0 };
hit_entity = possible_collider;
}
if (test_wall(min_collider.y, e.center.y, e.center.x, pos_delta.y, pos_delta.x, &closest_t, min_collider.x, max_collider.x)) {
wall_normal = { 0,-1 };
hit_entity = possible_collider;
}
if (test_wall(max_collider.y, e.center.y, e.center.x, pos_delta.y, pos_delta.x, &closest_t, min_collider.x, max_collider.x)) {
wall_normal = { 0,1 };
hit_entity = possible_collider;
}
}
}
}
}
entity->pos += pos_delta * closest_t;
if (hit_entity) {
pos_delta = desired_position - entity->pos;
//NOTE: handmade hero day 68, interesting concept, resolving an n^2 problem (double dispatch) with an n^2 solution
bool stops_on_collision = handle_collision(entity, hit_entity);
if (stops_on_collision) {
entity->velocity -= 1 * dot(entity->velocity, wall_normal) * wall_normal;//go in line with the wall
pos_delta -= 1 * dot(pos_delta, wall_normal) * wall_normal;
} //TODO(fran): need the collision table to avoid re-collisions
else {
add_collision_rule(gs, entity, hit_entity, false); //we avoid that re-collisions decrease our closest_t //TODO(fran): problem now is when to remove this rule //NOTE: casey took it out of here
}
}
else {
break;
}
//if (closest_t < 1.f) current_level->words[0].velocity = { 0,0 }; //REMEMBER: the biggest problem with the player getting stuck was because we werent cancelling it's previous velocity after a collision
}
//}
//else {
// entity->pos += pos_delta;
//}
{//Handle events based on overlapping
for (u32 test_entity_index = 1; test_entity_index < gs->entity_count; test_entity_index++) {
game_entity* test_entity = get_entity(gs, test_entity_index);
if (can_overlap(gs, entity, test_entity) && entities_overlap(entity, test_entity)) {
handle_overlap(gs, entity, test_entity);
}
}
}
}
void game_initialize_entities(game_state* gs, game_level_map lvl) {
game_clear_entities(gs);
for (u32 i = 0; i < lvl.entity_count; i++) {
game_add_entity(gs, &lvl.entities[i]);
}
}
void clear_collision_rules_for(game_state* gs, game_entity* e) {
//TODO(fran): make better data structure that allows for removing of collision rules without searching the entire table
for (u32 hash_bucket = 0; hash_bucket < arr_count(gs->collision_rule_hash); hash_bucket++) {
for (pairwise_collision_rule** rule = &gs->collision_rule_hash[hash_bucket]; *rule;) {
if ((*rule)->a == e || (*rule)->b == e) {
pairwise_collision_rule* removed = *rule;
*rule = (*rule)->next_in_hash;
removed->next_in_hash = gs->first_free_collision_rule;
gs->first_free_collision_rule = removed;
}
else {
rule = &(*rule)->next_in_hash;
}
}
}
}
game_entity_collision_area_group make_null_collision_box() {
game_entity_collision_area_group g;
g.areas = 0;
g.area_count = 0;
g.total_area = { 0 };
return g;
}
game_entity_collision_area_group make_simple_collision_box(game_memory_arena* arena, v2 offset, v2 radius) {
game_entity_collision_area_group g;
g.area_count = 1;
g.total_area.offset = offset;
g.total_area.radius = radius;
g.areas = push_arr(arena, game_entity_collision_area, g.area_count);
g.areas[0] = g.total_area;
//g.areas = push_mem(arena, game_entity_collision_area); //TODO
//g.areas[0].offset = offset;
//g.areas[0].radius = radius;
return g;
}
//NOTE: radius is used to create the collision area, TODO(fran): I dont think I want to create the collision areas until the level is loaded, so maybe better is to store the radius (and offset) in an array, on the other hand... that's almost the same size as the collision area itself, hmm
game_entity create_wall(game_memory_arena* arena, v2 pos,v2 radius, v4 color, u32 z_layer) {//TODO(fran): v4 with both xyzw and rgba access
game_entity wall; //TODO(fran): set this guys to {0} ? though living it like this generates bugs that bring me here to remember I forgot to set some new variable
wall.acceleration = { 0,0 };
wall.flags = entity_flag_collides | entity_flag_alive | entity_flag_solid;
wall.color = color;
wall.pos = pos;
//wall.radius = radius;
wall.type = entity_wall;
wall.velocity = { 0,0 };
wall.collision = make_simple_collision_box(arena, { 0,0 }, radius);
wall.anim_wall_texture = 0.f;
wall.z_layer = z_layer;
return wall;//std::move, I hope the compiler is intelligent enough
}
game_entity create_player(game_memory_arena* arena, v2 pos, v2 radius, v4 color, u32 z_layer) {
game_entity player;
player.flags = entity_flag_collides | entity_flag_alive | entity_flag_solid;
player.color = color;
player.pos = pos;
//player.radius = radius;
player.velocity = { 0,0 };
player.type = entity_player;
player.collision = make_simple_collision_box(arena, { 0,0 }, radius);
player.z_layer = z_layer;
return player;
}
game_entity create_word_spawner(game_memory_arena* arena, v2 pos, v2 radius, u32 z_layer) {
game_entity word_spawner;
word_spawner.acceleration = { 0,0 };
word_spawner.accumulated_time_sec = 0;
word_spawner.flags = entity_flag_alive;
word_spawner.color = { 0, 0.5f, 0, 1.f };
word_spawner.pos = pos;
//word_spawner.radius = radius;
word_spawner.time_till_next_word_sec = 5.f;
word_spawner.type = entity_word_spawner;
word_spawner.velocity = { 0,0 };
//TODO(fran): specify: word output direction
word_spawner.collision = make_simple_collision_box(arena, { 0,0 }, radius);
word_spawner.z_layer = z_layer;
return word_spawner;
}
img make_word_background_image(game_state* gs, game_memory_arena* transient_arena, u32 word_width_px, u32 word_height_px) {
i32 borders_hor = 1;
i32 borders_vert = 1;
i32 img_width = gs->word_corner.width * 2 + gs->word_border.width * borders_hor;
i32 img_height = gs->word_corner.height * 2 + gs->word_border.width * borders_vert;
img res = make_empty_img(transient_arena, img_width, img_height); //TODO(fran): pass arena as param
//TODO(fran): would it be better to render the top and then flip it to draw the bottom?
//IMPORTANT TODO(fran): see handmade day 85 min 39, would it make sense to store the new images in a transient arena? if so what happens when the arena gets cleared, how do I know from the word's point of view, that it's img is no longer valid? should I instead create some structure (hash table, etc) that provides access to the imgs and is referenced say by the width and height of the img, if that combination is not present then I create it and enter the entry into the hash table, we could use a similar scheme to the one handmade hero plans in that episode, with the lru(least recently used) idea, we can predict, for example a limit of say 30 words at maximum visible in a single moment (note: he made a couple typos and initialized memory with the mem size instead of the pointer)
//TODO(fran): make this go through the pipeline, create a render_group here
//draw corners
i32 offsetx = 0;
i32 offsety = 0;
game_render_img(&res, v2{ (f32)offsetx + (f32)gs->word_border.width / 2.f,(f32)offsety + (f32)gs->word_border.height / 2.f }, &gs->word_corner);
offsetx = gs->word_corner.width + gs->word_border.width * borders_hor;
offsety = 0;
game_render_img(&res, v2{ (f32)offsetx + (f32)gs->word_border.width / 2.f,(f32)offsety + (f32)gs->word_border.height / 2.f }, &gs->word_corner);
offsetx = 0;
offsety = gs->word_corner.height + gs->word_border.height * borders_vert;
game_render_img(&res, v2{ (f32)offsetx + (f32)gs->word_border.width / 2.f,(f32)offsety + (f32)gs->word_border.height / 2.f }, &gs->word_corner);
offsetx = gs->word_corner.width + gs->word_border.width * borders_hor;
offsety = gs->word_corner.height + gs->word_border.height * borders_vert;
game_render_img(&res, v2{ (f32)offsetx + (f32)gs->word_border.width / 2.f,(f32)offsety + (f32)gs->word_border.height / 2.f }, & gs->word_corner);
//draw top border
offsetx = gs->word_corner.width;
offsety = 0;
for (i32 i = 0; i < borders_hor; i++) {
game_render_img(&res, v2_from_i32(offsetx + gs->word_border.width / 2, offsety+ gs->word_border.height / 2), &gs->word_border);
offsetx+= gs->word_border.width;
}
//draw bottom border
offsetx = gs->word_corner.width;
offsety = gs->word_corner.height + gs->word_border.height*borders_vert;
for (i32 i = 0; i < borders_hor; i++) {
game_render_img(&res, v2_from_i32(offsetx + gs->word_border.width / 2, offsety + gs->word_border.height / 2), &gs->word_border);
offsetx += gs->word_border.width;
}
//draw left border
offsetx = 0;
offsety = gs->word_corner.height;
for (i32 i = 0; i < borders_hor; i++) {
game_render_img(&res, v2_from_i32(offsetx + gs->word_border.width / 2, offsety + gs->word_border.height / 2), &gs->word_border);
offsety += gs->word_corner.height;
}
//draw right border
offsetx = gs->word_corner.width+gs->word_border.width*borders_hor;
offsety = gs->word_corner.height;
for (i32 i = 0; i < borders_hor; i++) {
game_render_img(&res, v2_from_i32(offsetx + gs->word_border.width / 2, offsety + gs->word_border.height / 2), &gs->word_border);
offsety += gs->word_corner.height;
}
return res;
}
game_entity create_word(game_state* gs, game_memory_arena* transient_arena, v2 pos, v2 radius, v2 velocity, v4 color, u32 z_layer) {
//TODO(fran): radius should be determined by the lenght of the word it contains
game_entity word;
word.flags = entity_flag_collides | entity_flag_alive;
word.color = color;
word.pos = pos;
//word.radius = radius;
word.velocity = velocity;
word.type = entity_word;
word.acceleration = { 0,0 };
word.collision = make_simple_collision_box(transient_arena, { 0,0 }, radius); //TODO(fran): arena should be passed as separate param
char alphabet[] = "abcdefghijklmnopqrstuvwxyz";
word.txt[0] = alphabet[random_count(arr_count(alphabet) - 1)];
//TODO(fran): generate bitmap based on word metrics (we will need font info)
// we need a square generator that takes a corner, a side, and an inside (rotates the corner to generate the 4 ones)
word.image = make_word_background_image(gs, transient_arena, 0, 0);
word.z_layer = z_layer;
return word;
}
#if 0
img make_sphere_normal_map(game_memory_arena* arena, i32 width, i32 height, f32 Roughness=0.f)
{
img res = make_empty_img(arena, width, height);
img* Bitmap = &res;
f32 InvWidth = 1.0f / (f32)(Bitmap->width - 1);
f32 InvHeight = 1.0f / (f32)(Bitmap->height - 1);
u8* Row = (u8*)Bitmap->mem;
for (i32 Y = 0;
Y < Bitmap->height;
++Y)
{
u32* Pixel = (u32*)Row;
for (i32 X = 0;
X < Bitmap->width;
++X)
{
v2 BitmapUV = { InvWidth * (f32)X, InvHeight * (f32)Y };
f32 Nx = (2.0f * BitmapUV.x - 1.0f);
f32 Ny = (2.0f * BitmapUV.y - 1.0f);
f32 RootTerm = 1.0f - Nx * Nx - Ny * Ny;
v3 Normal = { 0, 0.707106781188f, 0.707106781188f };
f32 Nz = 0.0f;
if (RootTerm >= 0.0f)
{
Nz = square_root(RootTerm);
Normal = v3{ Nx, Ny, Nz };
}
v4 Color = { 255.0f * (0.5f * (Normal.x + 1.0f)),
255.0f * (0.5f * (Normal.y + 1.0f)),
255.0f * (0.5f * (Normal.z + 1.0f)),
255.0f * Roughness };
*Pixel++ = (((u32)(Color.a + 0.5f) << 24) |
((u32)(Color.r + 0.5f) << 16) |
((u32)(Color.g + 0.5f) << 8) |
((u32)(Color.b + 0.5f) << 0));
}
Row += Bitmap->pitch;
}
return res;
}
#else
img make_sphere_normal_map(game_memory_arena* arena,i32 width, i32 height, f32 roughness = 0.f) {
img res = make_empty_img(arena, width, height);
f32 inv_width = 1.f / (f32)(width-1);
f32 inv_height = 1.f / (f32)(height-1);
u8* row = (u8*)res.mem;
for (i32 y = 0; y < width; y++) { //TODO(fran): im drawing top down
u32* pixel = (u32*)row;
for (i32 x = 0; x < height; x++) {
//AARRGGBB
v2 uv = { (f32)x * inv_width, (f32)y * inv_height }; //[0,1]
//NOTE: this is correct for the x and y positive of the circle (y is down)
v2 n = uv * 2.f - v2{ 1.f,1.f };//[-1,1]
f32 root_term = 1.f - squared(n.x) - squared(n.y);
#if 0
v3 normal{ 0,0,1 };
#else
v3 normal{ 0,-.7071067811865475f,-.7071067811865475f };
#endif
f32 nz = 0;
if (root_term >= 0) {
nz = square_root(root_term);
normal = { n.x,n.y,nz };
}
//NOTE: I like this concept of creating your own conversions, I was trying to use i8 to have positive and negative but casey made it simpler by storing u8 and converting to f32 [-1,1]
v3 color = ((normal + v3{ 1,1,1 }) *.5f )*255.f;//[0,255]
//NOTE: NEVER use signed integers when working with bytes, when you do shifts it retains the sign and fucks up the whole 32 bits
*pixel++ = (u8)(roughness * 255.f) << 24 | (u8)round_f32_to_u32(color.r) << 16 | (u8)round_f32_to_u32(color.g) << 8 | (u8)round_f32_to_u32(color.b) << 0;
}
row += res.pitch;
}
return res;
}
#endif
img make_sphere_diffuse_map(game_memory_arena* arena, i32 width, i32 height) {
img res = make_empty_img(arena, width, height);
f32 inv_width = 1.f / (f32)(width - 1);
f32 inv_height = 1.f / (f32)(height - 1);
u8* row = (u8*)res.mem;
for (i32 y = 0; y < width; y++) { //TODO(fran): im drawing top down
u32* pixel = (u32*)row;
for (i32 x = 0; x < height; x++) {
//AARRGGBB
v2 uv = { (f32)x * inv_width, (f32)y * inv_height }; //[0,1]
//NOTE: this is correct for the x and y positive of the circle (y is down)
v2 n = uv * 2.f - v2{ 1.f,1.f };//[-1,1]
f32 root_term = 1.f - squared(n.x) - squared(n.y);
f32 alpha=0;
if (root_term >= 0) {
alpha = 1;
}
v3 color{ .2f,.2f,.2f }; color *= alpha;
*pixel++ = (u8)(alpha * 255.f) << 24 | (u8)round_f32_to_u32(color.r*255.f) << 16 | (u8)round_f32_to_u32(color.g * 255.f) << 8 | (u8)round_f32_to_u32(color.b * 255.f) << 0;
}
row += res.pitch;
}
return res;
}
img make_cylinder_normal_map(game_memory_arena* arena, i32 width, i32 height, f32 roughness = 0.f) {
img res = make_empty_img(arena, width, height);
f32 inv_width = 1.f / (f32)(width - 1);
f32 inv_height = 1.f / (f32)(height - 1);
u8* row = (u8*)res.mem;
for (i32 y = 0; y < width; y++) { //TODO(fran): im drawing top down
u32* pixel = (u32*)row;
for (i32 x = 0; x < height; x++) {
//AARRGGBB
v2 uv = { (f32)x * inv_width, (f32)y * inv_height }; //[0,1]
//NOTE: this is correct for the x and y positive of the circle (y is down)
v2 n = hadamard((uv * 2.f - v2{ 1.f,1.f }), {1,0});//[-1,1]
f32 root_term = 1.f - squared(n.x);
f32 nz = square_root(root_term);
v3 normal = { n.x,n.y,nz };
//NOTE: I like this concept of creating your own conversions, I was trying to use i8 to have positive and negative but casey made it simpler by storing u8 and converting to f32 [-1,1]
v3 color = ((normal + v3{ 1,1,1 }) * .5f) * 255.f;//[0,255]
//NOTE: NEVER use signed integers when working with bytes, when you do shifts it retains the sign and fucks up the whole 32 bits
*pixel++ = (u8)(roughness * 255.f) << 24 | (u8)round_f32_to_u32(color.r) << 16 | (u8)round_f32_to_u32(color.g) << 8 | (u8)round_f32_to_u32(color.b) << 0;
}
row += res.pitch;
}
return res;
}
u32 color_v4_to_u32(v4 color) {
color *= 255.f;
u32 res = round_f32_to_i32(color.a) << 24 | round_f32_to_i32(color.r) << 16 | round_f32_to_i32(color.g) << 8 | round_f32_to_i32(color.b) << 0;
return res;
}
environment_map make_test_env_map(game_memory_arena* arena, i32 width, i32 height, v4 color) {
color.rgb *= color.a;
environment_map res;
for (i32 idx = 0; idx < arr_count(res.LOD); idx++) {
res.LOD[idx] = make_empty_img(arena, width, height);
img* map = &res.LOD[idx];
bool row_checker_on = true;
i32 checker_width = 16;
i32 checker_height = 16;
for (i32 y = 0; y < map->height; y+=checker_height) { //TODO(fran): im drawing top down
bool checker_on = row_checker_on;
for (i32 x = 0; x < map->width; x+=checker_width) {
v4 c = checker_on ? color : v4{0, 0, 0, 1};
v2 min = v2_from_i32(x, y);
v2 max = min + v2{(f32)checker_width, (f32)checker_height};
game_render_rectangle(map,rc_min_max(min,max),c);
checker_on = !checker_on;
}
row_checker_on = !row_checker_on;
}
width /= 2;
height /= 2;
}
return res;
}
void make_test_env_map(environment_map* res, v4 color) {
color.rgb *= color.a;
for (i32 idx = 0; idx < arr_count(res->LOD); idx++) {
img* map = &res->LOD[idx];
bool row_checker_on = true;
i32 checker_width = 16;
i32 checker_height = 16;
for (i32 y = 0; y < map->height; y += checker_height) { //TODO(fran): im drawing top down
bool checker_on = row_checker_on;
for (i32 x = 0; x < map->width; x += checker_width) {
v4 c = checker_on ? color : v4{ 0, 0, 0, 1 };
v2 min = v2_from_i32(x, y);
v2 max = min + v2{ (f32)checker_width, (f32)checker_height };
game_render_rectangle(map, rc_min_max(min, max), c);
checker_on = !checker_on;
}
row_checker_on = !row_checker_on;
}
}
}
void make_wall_mask(img* mask, f32 corner_radius) {
//TODO(fran): page presents another way of calculating this, see which one is faster http://benice-equation.blogspot.com/2016/10/equation-of-rounded-rectangle.html#:~:text=The%20equation%20max(%7Cx%7C%20%2D%20a%2C%200)%C2%B2,d%C2%B2%20describes%20a%20rounded%20cuboid.
f32 width_max = (f32)mask->width-1;
f32 height_max = (f32)mask->height-1;
f32 half_width_max = width_max/2.f;
f32 half_height_max = height_max/2.f;
f32 corner_radius_sq = squared(corner_radius);
f32 corner_radius_4th = power4(corner_radius);
f32 a = half_width_max -corner_radius;
f32 b = half_height_max -corner_radius;
//centered at(0, 0) , width = 2(a + c), height = 2(b + c) , corner radius = c
u8* row = (u8*)mask->mem;
for (i32 y = 0; y < mask->height; y++) {
u32* pixel = (u32*)row;
for (i32 x = 0; x < mask->width; x++) {
//AARRGGBB
f32 alpha = 1.f;
#if 1
//Rounded Square
if (squared(maximum(absolute(x - half_width_max) - a, 0)) + squared(maximum(absolute(y - half_height_max) - b, 0)) > corner_radius_sq)
#else
//Squircle
if(power4((x-half_width_max)-a) + power4((y - half_height_max) - b) > corner_radius_4th)
#endif
alpha = 0.f;
//TODO(fran): less harsh boundary, gradual alpha decrease in a region
//TODO(fran): see squircle and other similar shapes
//TODO(fran): maybe adding support for rounded rectangles in the renderer is better, this guy will get too deformed (squircle deforms less)
*pixel++ = (u8)(alpha * 255.f) << 24;
}
row += mask->pitch;
}
}
void game_update_and_render(game_memory* memory, game_framebuffer* frame_buf, game_input* input) {
RESET_TIMED_BLOCKS;
START_TIMED_BLOCK(game_update_and_render);
//BIG TODO(fran): game_add_entity can no longer copy the game_entity, that would mean it uses the collision areas stored in the saved entity (it's fine for now, until we need to apply some transformation to collision areas)
//TODO(fran): add rgba to v3 and v4, and add xy yz zw, etc union accessors
//NOTE: handmade day 87 min 45, boolean to tell the game when the exe was reloaded (re-compiled) so it can reset-recalculate some things
game_assert(sizeof(game_state) <= memory->permanent_storage_sz);
game_state* gs = (game_state*)memory->permanent_storage;
//INFO IDEA: I see the game, we load stages from the filesystem, each stage can contain stages or levels inside, we show them in a nice rounded squares type menu, you can click to enter any stage/level, then you are sent to the real level
//NOTE:since our worlds are going to be very small we wont need to do virtualized space like Handmade Hero (day 33), but the idea is there if we decide to reuse the engine for something bigger
//IDEA: pixel art assets so we can create them fast, Im not sure how well they'll look next to the text for the words, maybe some font can fix that
//IDEA NOTE: text autocomplete makes you worse at typing, we want to train people to be able to write everything themselves
//NOTE IDEA: I see an aesthetic with oranges and white, warm colors, reds
//IDEA: different visible walls for the words to collide against, so it creates sort of a priority system where some words must be typed first cause they are going to collide with a wall that is much closer than the one on the other side of the screen
//IDEA: I see the walls candy-like red with scrolling diagonal white lines
//IDEA: screen presents a word in some random position, after n seconds fades to black, then again screen "unfades" and shows a new word in some other position, and so on, the player has to write the word/sentence before the screen turns completely black
//IDEA: special word that avoids walls
if (!memory->is_initialized) {
memory->is_initialized = true; //TODO(fran): should the platform layer do this?
//game_st->hz = 256;
game_entity null_entity{ 0 };
null_entity.type = entity_null; //NOTE: just in case
game_add_entity(gs, &null_entity); //NOTE: entity index 0 is reserved as NULL
//NOTE: the world is represented in meters, 1 meter is the unit of everything in the world
//gs->word_height_meters = 1.f;
//gs->word_height_pixels = 60;
initialize_arena(&gs->permanent_arena, (u8*)memory->permanent_storage + sizeof(game_state), memory->permanent_storage_sz - sizeof(game_state));
gs->world.stages = push_type(&gs->permanent_arena,game_stage);
gs->world.stage_count = 1;
gs->world.current_stage = 0;
gs->world.stages[0].lvls = push_arr(&gs->permanent_arena, game_level_map, 2);
gs->world.stages[0].level_count = 2; //TODO(fran): can we use sizeof_arr ?? I doubt it
gs->world.stages[0].current_lvl = 0;
game_level_map& level1 = gs->world.stages[0].lvls[0];
game_level_map& level2 = gs->world.stages[0].lvls[1];
level1.layer_nfo.layer_count = 3;
level1.layer_nfo.layers[0].current_scale = 1.f; //background
level1.layer_nfo.layers[0].scale_factor = .1f;
level1.layer_nfo.layers[1].current_scale = 1.f; //entities
level1.layer_nfo.layers[1].scale_factor = 7.82475f;
level1.layer_nfo.layers[2].current_scale = 1.f; //menu and mouse
level1.layer_nfo.layers[2].scale_factor = 0.f;
level2.layer_nfo = level1.layer_nfo;
#define LVL1_ENTITY_COUNT 3
level1.entities = push_arr(&gs->permanent_arena, game_entity, LVL1_ENTITY_COUNT);
level1.entity_count = LVL1_ENTITY_COUNT;
level2.entities = push_arr(&gs->permanent_arena, game_entity, LVL1_ENTITY_COUNT);
level2.entity_count = LVL1_ENTITY_COUNT;
{
game_entity level1_wall = create_wall(&gs->permanent_arena, v2{ 8.f , 9.5f }, v2{ .5f , 4.5f }, { 1.f,0.f,0.f,1.f }, 1);
game_entity level1_player = create_player(&gs->permanent_arena,v2{ 11.f ,5.f }, v2{ .5f , .5f }, { .0f,.0f,1.f,1.f },1);
game_entity level1_word_spawner= create_word_spawner(&gs->permanent_arena,v2{ 19.5f, 10.5f }, v2{ .5f , 4.f },1);
level1.entities[0] = level1_wall;
level1.entities[1] = level1_player;
level1.entities[2] = level1_word_spawner;
}
{
game_entity level2_wall = create_wall(&gs->permanent_arena,v2{ 8.5f , 7.5f }, v2{ .5f , 4.5f }, { 1.f,0.f,0.f,1.f },1);
game_entity level2_player = create_player(&gs->permanent_arena,v2{ 11.f ,5.f }, v2{ .75f , .75f }, { .0f,.0f,1.0f,1.f }, 1);
game_entity level2_word_spawner = create_word_spawner(&gs->permanent_arena,v2{ 16.5f , 10.5f }, v2{ .5f , .5f }, 1);
level2.entities[0] = level2_wall;
level2.entities[1] = level2_player;
level2.entities[2] = level2_word_spawner;
}
gs->DEBUG_background = DEBUG_load_png("assets/img/background.png"); //TODO(fran): release mem DEBUG_unload_png();
set_bottom_left_alignment(&gs->DEBUG_background, .5f, .5f);
gs->DEBUG_menu = DEBUG_load_png("assets/img/braid.png"); //TODO(fran): release mem DEBUG_unload_png();
gs->DEBUG_mouse = DEBUG_load_png("assets/img/mouse.png"); //TODO(fran): release mem DEBUG_unload_png();
set_bottom_left_alignment(&gs->DEBUG_mouse, .0f, 1.f);
gs->word_border = DEBUG_load_png("assets/img/word_border.png");
gs->word_corner = DEBUG_load_png("assets/img/word_corner.png");
gs->word_inside = DEBUG_load_png("assets/img/word_inside.png");
u32 wall_mask_width = 128;
u32 wall_mask_height = 512;
gs->wall_mask = make_empty_img(&gs->permanent_arena, wall_mask_width, wall_mask_height); //TODO(fran): we know walls are always gonna be stretched squares so it makes no sense to make a 256 by 256, we need more in y, that probably solves all our problems with scaling and different resolutions
make_wall_mask(&gs->wall_mask,minimum((f32)wall_mask_width, (f32)wall_mask_height)*.25f);
gs->wall_tile = DEBUG_load_png("assets/img/wall_stripes.png");
gs->camera = { 0 , 0 }; //NOTE: camera is in mtrs, it always represents the middle point of any screen/img
game_initialize_entities(gs, gs->world.stages[0].lvls[gs->world.stages[0].current_lvl]);
}
game_assert(sizeof(transient_state) <= memory->transient_storage_sz);
transient_state* ts = (transient_state*)memory->transient_storage;
if (!ts->is_initialized) {
ts->is_initialized = true;
initialize_arena(&ts->transient_arena, (u8*)memory->transient_storage + sizeof(transient_state), ((memory->transient_storage_sz - sizeof(transient_state))/2));
gs->test_diffuse = make_sphere_diffuse_map(&ts->transient_arena, 256, 256);
//gs->test_diffuse = make_empty_img(&ts->transient_arena,256, 256);
//game_render_rectangle(&gs->test_diffuse, rc_min_max({ 0,0 }, v2_from_i32( gs->test_diffuse.width,gs->test_diffuse.height)), {.5f,.5f,.5f,1});
gs->sphere_normal = make_sphere_normal_map(&ts->transient_arena, gs->test_diffuse.width, gs->test_diffuse.height);
//gs->sphere_normal = make_cylinder_normal_map(&ts->transient_arena, gs->test_diffuse.width, gs->test_diffuse.height); //TODO(fran): make correct cylinder and pyramid normal maps
ts->env_map_width = 512;
ts->env_map_height = 256;
i32 width= ts->env_map_width, height= ts->env_map_height;
for (i32 idx = 0; idx < arr_count(ts->TEST_top_env_map.LOD); idx++) {
ts->TEST_top_env_map.LOD[idx] = make_empty_img(&ts->transient_arena, width, height);
//img* map = &ts->TEST_top_env_map.LOD[idx];
width /= 2;
height /= 2;
}
width = ts->env_map_width, height = ts->env_map_height;
for (i32 idx = 0; idx < arr_count(ts->TEST_bottom_env_map.LOD); idx++) {
ts->TEST_bottom_env_map.LOD[idx] = make_empty_img(&ts->transient_arena, width, height);
//img* map = &ts->TEST_bottom_env_map.LOD[idx];
width /= 2;
height /= 2;
}
//ts->TEST_env_map = make_test_env_map(&ts->transient_arena, ts->env_map_width, ts->env_map_height, { 1.f,0,0,1.f });
//ts->TEST_env_map.LOD[0] = gs->DEBUG_background;//REMOVE: now thats pretty nice
//TODO: we can add more data structures to the transient state
//for example a hash table for the background imgs for the words, lets see if in the same level similar background sizes are used, then we could reduce memory space by reusing the background, at the cost of some performance at the time of searching for the img
}
initialize_arena(&gs->one_frame_arena, (u8*)memory->transient_storage + sizeof(transient_state) + ((memory->transient_storage_sz - sizeof(transient_state)) / 2), (memory->transient_storage_sz - sizeof(transient_state)) / 2); //NOTE: this area is reset on each frame //TODO(fran): check if the pointer should be offset by one to avoid stepping into the transient_arena's last byte
//TODO(fran): we could also create a state structure for this one and do something similar to handmade day 85 (min 49:00) where he adds the security checks for the number of temporary memory areas that are created and destroyed
//NOTE: I didnt like handmade's idea for the transient arena, since from what I understand, when you start a "sub-arena" it locks the possibility of allocating into the transient (multi frame) section until you exit the sub-arena, and I need to be able to add mem both to the multi and single frame sections (eg the word spawning requires the multiframe arena, so I cannot use a subarena for moving or rendering, depending on when I create the background img for the word)
//TODO(fran): maybe I should just render from the corners and borders each time, TIME how much slower that would be, if at all, since we also need to take into account that it takes time from the frame to generate the composited img when the img isnt there
//TODO(fran):objects may need z position to resolve conflicts with render overlapping
//REMEMBER: you get the input for the previous frame
gs->time += input->dt_sec;
if (input->controller.back.ended_down) {
gs->world.stages[0].current_lvl++;
gs->world.stages[0].current_lvl %= gs->world.stages[0].level_count;
game_initialize_entities(gs, gs->world.stages[0].lvls[gs->world.stages[0].current_lvl]);
}
game_assert(gs->entities[0].type == entity_null);
layer_info* layer_nfo = &gs->world.stages[gs->world.current_stage].lvls[gs->world.stages[gs->world.current_stage].current_lvl].layer_nfo;
//Update & Render Prep Loop
//TODO(fran): Z for scaling
if (input->controller.mouse.z != 0) {
for(u32 layer_idx =0; layer_idx<layer_nfo->layer_count;layer_idx++)
layer_nfo->layers[layer_idx].current_scale += input->dt_sec * input->controller.mouse.z * layer_nfo->layers[layer_idx].scale_factor;
}
//NOTE: handmade 108 16:00 great explanation of depth of field and focus
static bool show_boundaries = false;
if (input->controller.enter.ended_down) {
show_boundaries = !show_boundaries;
}
for (u32 entity_index = 1; entity_index < gs->entity_count; entity_index++) { //NOTE: remember to start from 1
game_entity& e= gs->entities[entity_index];
switch (gs->entities[entity_index].type) {
case entity_player:
{
v2 dd_word = { 0,0 }; //accel
if (input->controller.right.ended_down) {
dd_word.x = 1.f;
}
if (input->controller.left.ended_down) {
dd_word.x = -1.f;
}
if (input->controller.up.ended_down) {
dd_word.y = +1.f;
}
if (input->controller.down.ended_down) {
dd_word.y = -1.f;
}
if (f32 l = length_sq(dd_word); l > 1.f) { //Normalizing the vector, diagonal movement is fixed and also takes care of higher values than 1
dd_word *= (1.f / sqrtf(l));
}
f32 constant_accel = 20.f; //m/s^2
dd_word *= constant_accel;
//TODO(fran): ordinary differential eqs
dd_word += -3.5f * e.velocity; //basic "drag" //TODO(fran): understand why this doesnt completely eat the acceleration value
move_entity(&e, dd_word, gs, input); //TODO(fran): for each entity that moves
//v2 screen_offset = { (f32)frame_buf->width / 2,(f32)frame_buf->height / 2 };
gs->camera = e.pos; //TODO(fran): nicer camera update, lerp //TODO(fran): where to update the camera? //TODO(fran): camera position should be on the center, and at the time of drawing account for width and height from there
} break;
case entity_wall:
{
e.anim_wall_texture += input->dt_sec*.5f;
if (e.anim_wall_texture > 1.f) e.anim_wall_texture = 0.f;
//TODO(fran): move_entity aka moving walls?
} break;
case entity_word:
{
move_entity(&e, {0,0}, gs, input);
//NOTE: when words spawn they could scale from super small to normal, so in some levels we can show the word_spawner and it doesnt look weird how they come out of it
} break;
case entity_word_spawner:
{
e.accumulated_time_sec += input->dt_sec;
if (e.accumulated_time_sec > e.time_till_next_word_sec) {
e.accumulated_time_sec = 0;
v2 pos = { lerp(e.pos.x + e.collision.total_area.offset.x - e.collision.total_area.radius.x,e.pos.x + e.collision.total_area.offset.x + e.collision.total_area.radius.x, random_unilateral()),lerp(e.pos.y + e.collision.total_area.offset.y - e.collision.total_area.radius.y,e.pos.y + e.collision.total_area.offset.y + e.collision.total_area.radius.y, random_unilateral()) }; //TODO: probably having a rect struct is better, I can more easily get things like the min point //TODO(fran): pick one of the collision areas and spawn from there, or maybe better to just say we use only one for this guy, since it also needs to generate the direction of the word, and then we'd need to store different directions
#if 0
game_entity word = create_word(gs,&ts->transient_arena,pos, v2{ .5f , .5f }*gs->word_height_meters, v2{ -1,0 }*(5 * gs->word_height_meters)* random_unilateral(), { random_unilateral(),random_unilateral() ,random_unilateral() ,random_unilateral() },e.z_layer);
game_add_entity(gs, &word);
#endif
}
} break;
default: game_assert(0);
}
}
//Render Prep Loop
img framebuffer;
framebuffer.height = frame_buf->height;
framebuffer.width = frame_buf->width;
framebuffer.mem = frame_buf->mem;
framebuffer.pitch = frame_buf->pitch;
render_group* rg = allocate_render_group(&gs->one_frame_arena, gs->camera, Megabytes(1), layer_nfo,framebuffer.width,framebuffer.height);
clear(rg, v4{ .25f,.25f,.25f,1.f });
push_img(rg, { 10.f,10.f }, { 16.f,0.f }, { 0.f,9.f }, 0, &gs->DEBUG_background);
for (u32 entity_index = 1; entity_index < gs->entity_count; entity_index++) {
game_entity& e = gs->entities[entity_index];
switch (gs->entities[entity_index].type) {
case entity_player:
{
push_img(rg, e.pos + e.collision.total_area.offset - e.collision.total_area.radius, v2{ e.collision.total_area.radius.x * 2.f ,0.f }, v2{ 0.f, e.collision.total_area.radius.y * 2.f }, 1, &gs->DEBUG_menu);
} break;
case entity_wall:
{
v2 origin = e.pos + e.collision.total_area.offset - e.collision.total_area.radius;
#if 1
v2 x_axis = { e.collision.total_area.radius.x * 2 ,0 };
v2 y_axis = { 0,e.collision.total_area.radius.y * 2 };
#else
v2 x_axis = v2{ cosf(gs->time),sinf(gs->time) };
v2 y_axis = (e.collision.total_area.radius.y * 2) * perp(x_axis);
x_axis *= (e.collision.total_area.radius.x * 2);
#endif
//TODO(fran): one thing we could do is creating our own logic for rendering tileable objs outside the renderer, we allocate N wall buffers and do it there, it might be too expensive though, also we would need some type of dynamic storage I think
push_tileable(rg, origin, x_axis, y_axis, e.z_layer, &gs->wall_mask, &gs->wall_tile, { 0, e.anim_wall_texture }, v2{ 1.f,1.f }*1.f);
} break;
case entity_word:
{
push_img(rg, e.pos + e.collision.total_area.offset - e.collision.total_area.radius, v2{ e.collision.total_area.radius.x * 2.f ,0.f }, v2{ 0.f, e.collision.total_area.radius.y * 2.f }, e.z_layer, & e.image);
//stbtt_fontinfo font; //TODO(fran): insert the font again!
//int width, height;
//platform_read_entire_file_res f = platform_read_entire_file("c:/windows/fonts/arial.ttf"); //TODO(fran): fonts folder inside /assets
//stbtt_InitFont(&font, (u8*)f.mem, stbtt_GetFontOffsetForIndex((u8*)f.mem, 0));
//u8* bitmap = stbtt_GetCodepointBitmap(&font, 0, stbtt_ScaleForPixelHeight(&font, 50.f), e->txt[0], &width, &height, 0, 0);
//render_char(&framebuffer,
// transform_to_screen_coords(rc_center_radius(e->pos, v2{ (f32)width / 2.f,(f32)height / 2.f }*gs->word_pixels_to_meters),
// gs->word_meters_to_pixels, gs->camera, gs->lower_left_pixels), bitmap, width, height);
//platform_free_file_memory(f.mem);
//stbtt_FreeBitmap(bitmap, 0);
} break;
case entity_word_spawner:
{
//TODO
} break;
default: game_assert(0);
}
if (show_boundaries)
push_rect_boundary(rg, e.pos + e.collision.total_area.offset - e.collision.total_area.radius, v2{ e.collision.total_area.radius.x * 2.f ,0.f }, v2{ 0.f, e.collision.total_area.radius.y * 2.f }, e.z_layer, e.color);//TODO(fran): iterate over all collision areas and render each one //TODO(fran): bounding box should render above imgs
}
//TODO(fran): the mouse still comes in y is down coordinates, maybe I should ask for the platform to always send y is up
f32 mousey = gs->camera.y + ((f32)framebuffer.height*.5f - input->controller.mouse.y) * (1.f/ rg->meters_to_pixels); //TODO(fran): straight to pixels push rendering options
f32 mousex = gs->camera.x + (input->controller.mouse.x - (f32)framebuffer.width * .5f) * (1.f / rg->meters_to_pixels);
v2 mouse_x_axis = {1.f,0.f};
v2 mouse_y_axis = {0.f,1.f};
push_img(rg, { mousex,mousey}, mouse_x_axis, mouse_y_axis, 2, &gs->DEBUG_mouse); //TODO(fran): push_img_screen_position //TODO(fran): alignment so the mouse top left is at windows'normal mouse position
//game_render_img_ignore_transparency(&framebuffer, , &gs->DEBUG_background);
//NOTE or TODO(fran): stb gives the png in correct orientation by default, I'm not sure whether that's gonna cause problems with our orientation reversing
//game_render_img(&framebuffer, , &gs->DEBUG_menu,.5f); //NOTE: it's pretty interesting that you can actually see information in the pixels with full alpha, the program that generates them does not put rgb to 0 so you can see "hidden" things
//NOTE: now when we go to render we have to transform from meters, the unit everything in our game is, to pixels, the unit of the screen
#if 0
#if 1
v2 origin = v2{ 500.f,500.f } + 100.f * v2{ sinf(gs->time) ,cos(gs->time) };
#else
v2 origin = screen_offset +100.f * v2{ 3*sinf(gs->time) ,0 };
#endif
v4 color{1.f,1.f,1.f,1.f}; //NOTE: remember cos goes from [-1,1] we gotta move that to [0,1] for color
//push_img(rg, {2,5}, &ts->TEST_env_map.LOD[0]);
v2 x_axis = 256*v2{ cosf(gs->time),sinf(gs->time) };//(100.f/*+50.f*cosf(gs->time)*/)*v2{cosf(gs->time),sinf(gs->time)};
v2 y_axis = /*(256.f * (1.5f + .5f * sinf(gs->time))) * perp(normalize(x_axis));*/perp(x_axis);//(1+ sinf(gs->time))*perp(x_axis);//NOTE:we will not support skewing/shearing for now //(100.f + 50.f * sinf(gs->time)) *v2{cosf(gs->time+2.f),sinf(gs->time + 2.f) };//NOTE: v2 y_axis = (100.f + 50.f * sinf(gs->time)) *v2{cosf(gs->time-2.f),sinf(gs->time + 2.f) }; == 3d?
make_test_env_map(&ts->TEST_top_env_map, { 1.f,0,0,1.f });
ts->TEST_top_env_map.p_z = -1.f;
make_test_env_map(&ts->TEST_bottom_env_map, { 0,1.f,0,1.f });
ts->TEST_bottom_env_map.p_z = 1.f;
render_entry_coordinate_system* c = push_coord_system(rg, origin, x_axis, y_axis, color, &gs->test_diffuse, &gs->sphere_normal, &ts->TEST_top_env_map, &ts->TEST_bottom_env_map);
u32 idx = 0;
for (f32 y = 0; y < 1.f; y += .25f)
for (f32 x = 0; x < 1.f; x += .25f)
c->points[idx++] = {x,y};
push_coord_system(rg, { 200,600 }, 3*v2{ (f32)ts->TEST_top_env_map.LOD[0].width/6,0 }, 3*v2{ 0,(f32)ts->TEST_top_env_map.LOD[0].height / 6 }, color, &ts->TEST_top_env_map.LOD[0], 0, 0,0);
push_coord_system(rg, { 200,400 }, 3*v2{ (f32)ts->TEST_bottom_env_map.LOD[0].width/6,0 }, 3*v2{ 0,(f32)ts->TEST_bottom_env_map.LOD[0].height / 6 }, color, &ts->TEST_bottom_env_map.LOD[0], 0, 0,0);
#endif
//Camera bounds test
rc2 screen_bounds = get_camera_rc_at_target(rg); //TODO(fran): re-check this (handmade 110) it's ok with no scaling but if i scroll it goes wrong, or maybe what happens is right, but I dont think so
push_rect_boundary(rg, rg->camera - screen_bounds.radius, { screen_bounds.get_dim().x ,0 }, { 0,screen_bounds.get_dim().y }, 1, { 1.f,0.f,1.f,1.f });
//Render Loop
output_render_group(rg,&framebuffer);
//Deletion Loop //TODO(fran): should deletion happen before render?
for (u32 i = 1; i < gs->entity_count; i++) {
if (!is_set(&gs->entities[i], entity_flag_alive)) { //TODO(fran): would a destroy flag be better? so you dont have to set alive on each entity creation
clear_collision_rules_for(gs, &gs->entities[i]);//NOTE: I dont really know if the collision rule idea will be useful for the simple game im making right now, but it looks like an interesting concept to understand so I'm doing it anyway to learn
game_remove_entity(gs, i);
}
}
END_TIMED_BLOCK(game_update_and_render);
handle_global_cycle_counter();
}
/*NOTE:
Latency: how long it takes for an instruction from being issued to being complete (important for short sets of data)
Throughput: how many of them can I do when the pipeline is full (important for large sets of data)
1 -> you can do one in a cycle
.33 -> you can do three in a cycle
Drainout: flushing the pipeline at the end
Basics of Optimization: make sure the memory doesnt stall you and make sure you make the least amount of work on it as possible
(handmade 113)
-1st step: measure, find out where the big bottlenecks are, never optimize something until you know it needs to be
(NOTE: remember to count cycles, I wouldnt have thought of that cause I didnt think it was reliable enough but it's very useful)
-2nd step: count your operations reduced to their basic form (eg n additions, n dots, n lengths, ...)
-3rd step: with the data from 1 and 2 make an estimate of the amount you think you should be able to cut down
-4th step: prepare your function for optimization, aka remove all "zero cost abstractions"
-5th step: "wide strategy" aka how are you gonna operate wide on the things you have, are they all the same and easily packed?, in the case of rendering, do you want to have a pixel in each lane? wanna have Rs in one lane, Gs in another and so on? usually alpha is treated different from rgb so you probably dont want a lane to be the full pixel
-6th: once you have everything converted to SIMD, count all the intrinsics that you're calling in the loop and multiply each count by it's throughput (macros are your friend), then divide by the size of your wide lane (AVX->8 SSe->4), that should give you a rough estimate of how close you're to the theoretical maximum (+- some caveats)
-A more proper way to do it would be with IACA (intel arch code analyzer) (handmade 120)
Efficiency: the algorithm, doing the least work you can
Overdraw: how many times do you write the same pixel -> Renderer Efficiency
AOS vs SOA:
-AOS: array of structures (what C does, not great for SIMD): struct color{ f32 r,g,b,a;}
-SIMD register would want rrrr but we have rgba
-SOA: structure of arrays (good for doing same operations on same sorts of things) rrrr gggg bbbb aaaa
-struct colors{
f32* r; //you have one structure that has a bunch of arrays in it
f32* g; //points to sequence of Gs, perfect for SIMD
f32* b;
f32* a;
}
//This is important cause intel didnt provide a way to load the data by strides (in SSE, in AVX they added some instructions which seem very costly from what I read, gotta test), eg saying load every fourth byte, NEON does have this instructions but intel was lazy I guess, too hard
Intel intrinsics guide: https://software.intel.com/sites/landingpage/IntrinsicsGuide/
-Little endian easy remainder: means that it starts by loading into the least significant portion of the register
*/
//TODO(fran): read the intel arquitecture manual
//NOTE: handmade 112 51:00 quick and simple explanation of hyperthreading
//TODO(fran): it would be nice to be free of visual studio, so we can do things like live code editing easier, and also simpler for porting
//INFO: handmade day 55 nice example of a simple hashmap
//TODO(fran): see day 56 again
//INFO: handmade day 61, min ~30 "hit table" to differentiate between new collisions and ones that were already overlapping that same object
//INFO: day 62 introduces an interesting concept of "move spec" which abstracts movement a bit, and adds options for different types
//TODO(fran): For learning about floating point:
// -reading: "What every computer scientist should know about floating point arithmetic" (pdf)
// "Real computing made real" by Forman Acton
// "Numerical methods that work" by Forman Acton
//NOTE: Steam Hardware Survey, good base point for seeing what you are targeting on pc (2020 AVX 93%, AVX2 only 76% )
//NOTE: there are performance counters for seeing cache misses on different cache levels
//void game_render_rectangle_boundary(img* buf, rc2 rc, v4 color) {
//
// f32 thickness = 2.f;
//
// min_max_v2 m;
// m.min = rc.get_min();
// m.max.x = m.min.x + thickness; m.max.y = rc.get_max().y;
// game_render_rectangle(buf, m, color);//left
// m.min = rc.get_min(); m.min.x += thickness;
// m.max.x= rc.get_max().x - thickness; m.max.y = rc.get_min().y + thickness;//TODO(fran): here down is up again
// game_render_rectangle(buf, m, color);//top
// m.min.x = rc.get_min().x + thickness; m.min.y = rc.get_max().y - thickness;
// m.max = rc.get_max(); m.max.x -= thickness;
// game_render_rectangle(buf, m, color);//bottom
// m.min.x = rc.get_max().x - thickness; m.min.y = rc.get_min().y;
// m.max = rc.get_max();
// game_render_rectangle(buf, m, color);//right
//}
//Render Loop
//for (u32 i = 1; i < gs->entity_count; i++) {
// game_entity* e = &gs->entities[i];
// switch (e->type) {
// case entity_word:
//{
//game_render_img(&framebuffer, transform_to_screen_coords(e->pos,gs->word_meters_to_pixels,gs->camera,gs->lower_left_pixels), &e->image);
// stbtt_fontinfo font;
// int width, height;
// platform_read_entire_file_res f = platform_read_entire_file("c:/windows/fonts/arial.ttf");
// stbtt_InitFont(&font, (u8*)f.mem, stbtt_GetFontOffsetForIndex((u8*)f.mem, 0));
// u8* bitmap = stbtt_GetCodepointBitmap(&font, 0, stbtt_ScaleForPixelHeight(&font, 50.f), e->txt[0], &width, &height, 0, 0);
// render_char(&framebuffer,
// transform_to_screen_coords(rc_center_radius( e->pos , v2{(f32)width/2.f,(f32)height/2.f}*gs->word_pixels_to_meters),
// gs->word_meters_to_pixels, gs->camera, gs->lower_left_pixels), bitmap, width, height);
// platform_free_file_memory(f.mem);
// stbtt_FreeBitmap(bitmap, 0);
//} break;
//}
//game_render_rectangle_boundary(
// &framebuffer,
// transform_to_screen_coords(rc_center_radius(e->pos + e->collision.total_area.offset , e->collision.total_area.radius), gs),
// e->color);
//}
/*
#if 0 //old collision detection
{
v2 new_pos = .5f*dd_word*powf(input->dt_sec,2.f) + current_level->words[0].velocity * input->dt_sec + current_level->words[0].rect.pos;
v2 new_word_pos00{ new_pos.x - current_level->words[0].rect.radius.x,new_pos.y - current_level->words[0].rect.radius.y};
v2 new_word_pos01{ new_pos.x + current_level->words[0].rect.radius.x,new_pos.y - current_level->words[0].rect.radius.y};
v2 new_word_pos10{ new_pos.x - current_level->words[0].rect.radius.x,new_pos.y + current_level->words[0].rect.radius.y};
v2 new_word_pos11{ new_pos.x + current_level->words[0].rect.radius.x,new_pos.y + current_level->words[0].rect.radius.y}; //TODO(fran): rc to rc collision
current_level->words[0].velocity += dd_word * input->dt_sec;
if (!game_check_collision_point_to_rc(new_word_pos00, current_level->walls[0].rect) &&
!game_check_collision_point_to_rc(new_word_pos01, current_level->walls[0].rect)&&
!game_check_collision_point_to_rc(new_word_pos10, current_level->walls[0].rect)&&
!game_check_collision_point_to_rc(new_word_pos11, current_level->walls[0].rect)) { //TODO(fran): add collision checks for the mid points, if two objs are the same width for example then when they line up perfectly one can enter the other from the top or bottom. Or just move on to a new technique
//TODO(fran): fix faster diagonal movement once we properly use vectors
current_level->words[0].rect.pos = new_pos;
v2 screen_offset = { (f32)frame_buf->width/2,(f32)frame_buf->height/2 };
game_st->camera = current_level->words[0].rect.pos *game_st->word_meters_to_pixels - screen_offset;
}
else {
v2 wall_normal = {1,0};
//current_level->words[0].velocity -= 2 * dot(current_level->words[0].velocity, wall_normal)* wall_normal;//bounce
current_level->words[0].velocity -= 1 * dot(current_level->words[0].velocity, wall_normal)* wall_normal;//go in line with the wall
}
}
#elif 0 //a little more advanced collision detection
//day 45, min 37 aprox, starts with collision detection "in p"
//day 46 just multiplayer support and entities, nothing on collision
//in the end we are going go to "search in t" (day 47)
{
//we test for the walls that are in our range of motion, and then we take the closest point where we hit (in my case with the limited amount of walls we might as well test all, at least to start)
v2 pos_delta = .5f*dd_word*powf(input->dt_sec,2.f) + player_entity.velocity * input->dt_sec;//NOTE: we'll start just checking a point
player_entity.velocity += dd_word * input->dt_sec;//TODO: where does this go? //NOTE: Casey put it here, it had it before calculating pos_delta
//for each wall...
rc word = { player_entity.pos,player_entity.radius };
rc wall = { game_st->entities[2].pos , game_st->entities[2].radius };
//Following the Minkowski Sum now we reduce the word(player) to a point and expand every other object(wall) by the size of the word, so with no need to change any of the code we get for free collision detection for the entire shape of the word
wall.radius += word.radius;
v2 min_wall = wall.pos - wall.radius;
v2 max_wall = wall.pos + wall.radius;
auto test_wall = [](f32 wallx, f32 oldposx, f32 oldposy, f32 deltax, f32 deltay, f32* t_min, f32 miny, f32 maxy) -> bool {
if (deltax != 0.f) {
f32 t_res = (wallx - oldposx) / deltax;
f32 Y = oldposy + t_res * deltay;
if (t_res >= 0.f && t_res < *t_min && Y >= miny && Y <= maxy) {
f32 epsilon = .001f;
*t_min = maximum(.0f, t_res - epsilon); //probably instead of 0 should do epsilon
return true;
}
}
return false;
};
f32 remaining_t = 1.f;
for (int attempt = 0; attempt < 4 && remaining_t>0.f; attempt++) {
f32 closest_t= 1.f; //we limit the time to the full motion that can occur
v2 wall_normal{ 0,0 };
if (test_wall(min_wall.x, word.pos.x, word.pos.y, pos_delta.x, pos_delta.y, &closest_t, min_wall.y, max_wall.y)) {
wall_normal = { -1,0 };
}
if (test_wall(max_wall.x, word.pos.x, word.pos.y, pos_delta.x, pos_delta.y, &closest_t, min_wall.y, max_wall.y)) {
wall_normal = { 1,0 };
}
if (test_wall(min_wall.y, word.pos.y, word.pos.x, pos_delta.y, pos_delta.x, &closest_t, min_wall.x, max_wall.x)) {
wall_normal = { 0,-1 };
}
if (test_wall(max_wall.y, word.pos.y, word.pos.x, pos_delta.y, pos_delta.x, &closest_t, min_wall.x, max_wall.x)) {
wall_normal = { 0,1 };
}
player_entity.pos += pos_delta * closest_t;
//current_level->words[0].velocity += dd_word * input->dt_sec;//TODO: where does this go?
//if (closest_t < 1.f)
// current_level->words[0].velocity = { 0,0 }; //NOTE: REMEMBER: the biggest problem with the player getting stuck was because we werent cancelling it's previous velocity after a collision
player_entity.velocity -= 1 * dot(player_entity.velocity, wall_normal) * wall_normal;//go in line with the wall
pos_delta -= 1 * dot(pos_delta, wall_normal) * wall_normal;
remaining_t -= closest_t*remaining_t; //TODO(fran): I dont think I understand this
}
}
#endif
*/ | [
"31745377+Bade99@users.noreply.github.com"
] | 31745377+Bade99@users.noreply.github.com |
40c2bdfec543e6b86071a914e0257c007eb30cea | 44bc24f466d6edd43e040488f35a24a365ff01e3 | /src/game/shared/movevars_shared.cpp | 90320397f5fd90c876417d0cd9d7bea3fe415856 | [] | no_license | code-google-com/puzzlr | 38fdfad07cc4aa7e99c2c1ecd05440c4ff19d6cb | 3b9899a2dedf41644d6427b887977dc7f8b04945 | refs/heads/master | 2020-05-18T20:11:03.212547 | 2010-05-22T20:49:36 | 2010-05-22T20:49:36 | null | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 4,936 | cpp | //========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================//
#include "cbase.h"
#include "movevars_shared.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// some cvars used by player movement system
/* #if defined(HL2_DLL) || defined(HL2_CLIENT_DLL)
#define DEFAULT_GRAVITY_STRING "600"
#else
#define DEFAULT_GRAVITY_STRING "800"
#endif */
// Obsolete gravity code is obsolete :3
ConVar sv_gravity ( "sv_gravity","400", FCVAR_NOTIFY | FCVAR_REPLICATED, "World gravity." ); // low gravity = high fun
#if defined(DOD_DLL)
ConVar sv_stopspeed ( "sv_stopspeed","100", FCVAR_NOTIFY | FCVAR_REPLICATED, "Minimum stopping speed when on ground." );
#else
ConVar sv_stopspeed ( "sv_stopspeed","100", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Minimum stopping speed when on ground." );
#endif
ConVar sv_noclipaccelerate( "sv_noclipaccelerate", "5", FCVAR_NOTIFY | FCVAR_ARCHIVE | FCVAR_REPLICATED);
ConVar sv_noclipspeed ( "sv_noclipspeed", "5", FCVAR_ARCHIVE | FCVAR_NOTIFY | FCVAR_REPLICATED);
ConVar sv_specaccelerate( "sv_specaccelerate", "5", FCVAR_NOTIFY | FCVAR_ARCHIVE | FCVAR_REPLICATED);
ConVar sv_specspeed ( "sv_specspeed", "3", FCVAR_ARCHIVE | FCVAR_NOTIFY | FCVAR_REPLICATED);
ConVar sv_specnoclip ( "sv_specnoclip", "1", FCVAR_ARCHIVE | FCVAR_NOTIFY | FCVAR_REPLICATED);
//Tony; in the SDK, set the max speed higher so the sample class can go faster.
#if defined ( SDK_DLL )
ConVar sv_maxspeed ( "sv_maxspeed", "600", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY); // we run faster :3
#else
ConVar sv_maxspeed ( "sv_maxspeed", "320", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY);
#endif
#ifdef _XBOX
ConVar sv_accelerate ( "sv_accelerate", "7", FCVAR_NOTIFY | FCVAR_REPLICATED);
#else
ConVar sv_accelerate ( "sv_accelerate", "12", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY); // we accelerate faster :3
#endif//_XBOX
ConVar sv_airaccelerate( "sv_airaccelerate", "13", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY ); // we accelerate faster in the air
ConVar sv_wateraccelerate( "sv_wateraccelerate", "11", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY ); // and slower in the water
ConVar sv_waterfriction( "sv_waterfriction", "1", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY );
ConVar sv_footsteps ( "sv_footsteps", "1", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Play footstep sound for players" );
ConVar sv_rollspeed ( "sv_rollspeed", "250", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY); // we roll at higher speeds
ConVar sv_rollangle ( "sv_rollangle", "5", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Max view roll angle"); // we roll up to 5 degrees.
#if defined(DOD_DLL)
ConVar sv_friction ( "sv_friction","4", FCVAR_NOTIFY | FCVAR_REPLICATED, "World friction." );
#else
ConVar sv_friction ( "sv_friction","4", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "World friction." );
#endif
ConVar sv_bounce ( "sv_bounce","0", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Bounce multiplier for when physically simulated objects collide with other objects." );
ConVar sv_maxvelocity ( "sv_maxvelocity","3500", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Maximum speed any ballistically moving object is allowed to attain per axis." );
ConVar sv_stepsize ( "sv_stepsize","19", FCVAR_NOTIFY | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY ); // slightly larger steps :3
ConVar sv_skyname ( "sv_skyname", "sky_urb01", FCVAR_ARCHIVE | FCVAR_REPLICATED, "Current name of the skybox texture" );
ConVar sv_backspeed ( "sv_backspeed", "0.65", FCVAR_ARCHIVE | FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "How much to slow down backwards motion" );
ConVar sv_waterdist ( "sv_waterdist","12", FCVAR_REPLICATED | FCVAR_DEVELOPMENTONLY, "Vertical view fixup when eyes are near water plane." );
// Vehicle convars
ConVar r_VehicleViewDampen( "r_VehicleViewDampen", "1", FCVAR_CHEAT | FCVAR_NOTIFY | FCVAR_REPLICATED );
// Jeep convars
ConVar r_JeepViewDampenFreq( "r_JeepViewDampenFreq", "7.0", FCVAR_CHEAT | FCVAR_NOTIFY | FCVAR_REPLICATED );
ConVar r_JeepViewDampenDamp( "r_JeepViewDampenDamp", "1.0", FCVAR_CHEAT | FCVAR_NOTIFY | FCVAR_REPLICATED);
ConVar r_JeepViewZHeight( "r_JeepViewZHeight", "10.0", FCVAR_CHEAT | FCVAR_NOTIFY | FCVAR_REPLICATED );
// Airboat convars
ConVar r_AirboatViewDampenFreq( "r_AirboatViewDampenFreq", "7.0", FCVAR_CHEAT | FCVAR_NOTIFY | FCVAR_REPLICATED );
ConVar r_AirboatViewDampenDamp( "r_AirboatViewDampenDamp", "1.0", FCVAR_CHEAT | FCVAR_NOTIFY | FCVAR_REPLICATED);
ConVar r_AirboatViewZHeight( "r_AirboatViewZHeight", "0.0", FCVAR_CHEAT | FCVAR_NOTIFY | FCVAR_REPLICATED );
| [
"aaronweiss74@a6d7ee8f-d40e-d1f1-f2a9-9200d20d501c"
] | aaronweiss74@a6d7ee8f-d40e-d1f1-f2a9-9200d20d501c |
ed617d2a94d27f11b93bb4b915c35105a26d6315 | 17094b0b42abebbb88dc56b6635a53d582efb9dd | /src/masternode-payments.cpp | 15df014e7989929445fbe8c6ab52e646b2ef01e8 | [
"MIT"
] | permissive | ethcash/ethcash | d1eb9dafaa8ad2f8499a24503acc59b723f96b2f | 02ebc65953cfc7976e83bf8a6479e18902f86752 | refs/heads/master | 2021-07-17T14:12:50.014270 | 2017-10-24T06:36:47 | 2017-10-24T06:36:47 | 107,437,074 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 11,641 | cpp | // Copyright (c) 2014-2015 The Dash developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "masternode-payments.h"
#include "masternodeman.h"
#include "darksend.h"
#include "util.h"
#include "sync.h"
#include "spork.h"
#include "addrman.h"
#include <boost/lexical_cast.hpp>
CCriticalSection cs_masternodepayments;
/** Object for who's going to get paid on which blocks */
CMasternodePayments masternodePayments;
// keep track of Masternode votes I've seen
map<uint256, CMasternodePaymentWinner> mapSeenMasternodeVotes;
int CMasternodePayments::GetMinMasternodePaymentsProto() {
return MIN_MASTERNODE_PAYMENT_PROTO;
}
void ProcessMessageMasternodePayments(CNode* pfrom, std::string& strCommand, CDataStream& vRecv)
{
if(!darkSendPool.IsBlockchainSynced()) return;
if (strCommand == "mnget") { //Masternode Payments Request Sync
if(pfrom->HasFulfilledRequest("mnget")) {
LogPrintf("mnget - peer already asked me for the list\n");
Misbehaving(pfrom->GetId(), 20);
return;
}
pfrom->FulfilledRequest("mnget");
masternodePayments.Sync(pfrom);
LogPrintf("mnget - Sent Masternode winners to %s\n", pfrom->addr.ToString().c_str());
}
else if (strCommand == "mnw") { //Masternode Payments Declare Winner
LOCK(cs_masternodepayments);
//this is required in litemode
CMasternodePaymentWinner winner;
vRecv >> winner;
if(pindexBest == NULL) return;
CTxDestination address1;
ExtractDestination(winner.payee, address1);
CethcashcoinAddress address2(address1);
uint256 hash = winner.GetHash();
if(mapSeenMasternodeVotes.count(hash)) {
if(fDebug) LogPrintf("mnw - seen vote %s Addr %s Height %d bestHeight %d\n", hash.ToString().c_str(), address2.ToString().c_str(), winner.nBlockHeight, pindexBest->nHeight);
return;
}
if(winner.nBlockHeight < pindexBest->nHeight - 10 || winner.nBlockHeight > pindexBest->nHeight+20){
LogPrintf("mnw - winner out of range %s Addr %s Height %d bestHeight %d\n", winner.vin.ToString().c_str(), address2.ToString().c_str(), winner.nBlockHeight, pindexBest->nHeight);
return;
}
if(winner.vin.nSequence != std::numeric_limits<unsigned int>::max()){
LogPrintf("mnw - invalid nSequence\n");
Misbehaving(pfrom->GetId(), 100);
return;
}
LogPrintf("mnw - winning vote - Vin %s Addr %s Height %d bestHeight %d\n", winner.vin.ToString().c_str(), address2.ToString().c_str(), winner.nBlockHeight, pindexBest->nHeight);
if(!masternodePayments.CheckSignature(winner)){
LogPrintf("mnw - invalid signature\n");
Misbehaving(pfrom->GetId(), 100);
return;
}
mapSeenMasternodeVotes.insert(make_pair(hash, winner));
if(masternodePayments.AddWinningMasternode(winner)){
masternodePayments.Relay(winner);
}
}
}
bool CMasternodePayments::CheckSignature(CMasternodePaymentWinner& winner)
{
//note: need to investigate why this is failing
std::string strMessage = winner.vin.ToString().c_str() + boost::lexical_cast<std::string>(winner.nBlockHeight) + winner.payee.ToString();
std::string strPubKey = strMainPubKey ;
CPubKey pubkey(ParseHex(strPubKey));
std::string errorMessage = "";
if(!darkSendSigner.VerifyMessage(pubkey, winner.vchSig, strMessage, errorMessage)){
return false;
}
return true;
}
bool CMasternodePayments::Sign(CMasternodePaymentWinner& winner)
{
std::string strMessage = winner.vin.ToString().c_str() + boost::lexical_cast<std::string>(winner.nBlockHeight) + winner.payee.ToString();
CKey key2;
CPubKey pubkey2;
std::string errorMessage = "";
if(!darkSendSigner.SetKey(strMasterPrivKey, errorMessage, key2, pubkey2))
{
LogPrintf("CMasternodePayments::Sign - ERROR: Invalid Masternodeprivkey: '%s'\n", errorMessage.c_str());
return false;
}
if(!darkSendSigner.SignMessage(strMessage, errorMessage, winner.vchSig, key2)) {
LogPrintf("CMasternodePayments::Sign - Sign message failed");
return false;
}
if(!darkSendSigner.VerifyMessage(pubkey2, winner.vchSig, strMessage, errorMessage)) {
LogPrintf("CMasternodePayments::Sign - Verify message failed");
return false;
}
return true;
}
uint64_t CMasternodePayments::CalculateScore(uint256 blockHash, CTxIn& vin)
{
uint256 n1 = blockHash;
uint256 n2 = Hash(BEGIN(n1), END(n1));
uint256 n3 = Hash(BEGIN(vin.prevout.hash), END(vin.prevout.hash));
uint256 n4 = n3 > n2 ? (n3 - n2) : (n2 - n3);
//printf(" -- CMasternodePayments CalculateScore() n2 = %d \n", n2.Get64());
//printf(" -- CMasternodePayments CalculateScore() n3 = %d \n", n3.Get64());
//printf(" -- CMasternodePayments CalculateScore() n4 = %d \n", n4.Get64());
return n4.Get64();
}
bool CMasternodePayments::GetBlockPayee(int nBlockHeight, CScript& payee, CTxIn& vin)
{
BOOST_FOREACH(CMasternodePaymentWinner& winner, vWinning){
if(winner.nBlockHeight == nBlockHeight) {
payee = winner.payee;
vin = winner.vin;
return true;
}
}
return false;
}
bool CMasternodePayments::GetWinningMasternode(int nBlockHeight, CTxIn& vinOut)
{
BOOST_FOREACH(CMasternodePaymentWinner& winner, vWinning){
if(winner.nBlockHeight == nBlockHeight) {
vinOut = winner.vin;
return true;
}
}
return false;
}
bool CMasternodePayments::AddWinningMasternode(CMasternodePaymentWinner& winnerIn)
{
uint256 blockHash = 0;
if(!GetBlockHash(blockHash, winnerIn.nBlockHeight-576)) {
return false;
}
winnerIn.score = CalculateScore(blockHash, winnerIn.vin);
bool foundBlock = false;
BOOST_FOREACH(CMasternodePaymentWinner& winner, vWinning){
if(winner.nBlockHeight == winnerIn.nBlockHeight) {
foundBlock = true;
if(winner.score < winnerIn.score){
winner.score = winnerIn.score;
winner.vin = winnerIn.vin;
winner.payee = winnerIn.payee;
winner.vchSig = winnerIn.vchSig;
mapSeenMasternodeVotes.insert(make_pair(winnerIn.GetHash(), winnerIn));
return true;
}
}
}
// if it's not in the vector
if(!foundBlock){
vWinning.push_back(winnerIn);
mapSeenMasternodeVotes.insert(make_pair(winnerIn.GetHash(), winnerIn));
return true;
}
return false;
}
void CMasternodePayments::CleanPaymentList()
{
LOCK(cs_masternodepayments);
if(pindexBest == NULL) return;
int nLimit = std::max(((int)mnodeman.size())*((int)1.25), 1000);
vector<CMasternodePaymentWinner>::iterator it;
for(it=vWinning.begin();it<vWinning.end();it++){
if(pindexBest->nHeight - (*it).nBlockHeight > nLimit){
if(fDebug) LogPrintf("CMasternodePayments::CleanPaymentList - Removing old Masternode payment - block %d\n", (*it).nBlockHeight);
vWinning.erase(it);
break;
}
}
}
bool CMasternodePayments::ProcessBlock(int nBlockHeight)
{
LOCK(cs_masternodepayments);
if(nBlockHeight <= nLastBlockHeight) return false;
if(!enabled) return false;
CMasternodePaymentWinner newWinner;
int nMinimumAge = mnodeman.CountEnabled();
CScript payeeSource;
uint256 hash;
if(!GetBlockHash(hash, nBlockHeight-10)) return false;
unsigned int nHash;
memcpy(&nHash, &hash, 2);
LogPrintf(" ProcessBlock Start nHeight %d - vin %s. \n", nBlockHeight, activeMasternode.vin.ToString().c_str());
std::vector<CTxIn> vecLastPayments;
BOOST_REVERSE_FOREACH(CMasternodePaymentWinner& winner, vWinning)
{
//if we already have the same vin - we have one full payment cycle, break
if(vecLastPayments.size() > (unsigned int)nMinimumAge) break;
vecLastPayments.push_back(winner.vin);
}
// pay to the oldest MN that still had no payment but its input is old enough and it was active long enough
CMasternode *pmn = mnodeman.FindOldestNotInVec(vecLastPayments, nMinimumAge);
if(pmn != NULL)
{
LogPrintf(" Found by FindOldestNotInVec \n");
newWinner.score = 0;
newWinner.nBlockHeight = nBlockHeight;
newWinner.vin = pmn->vin;
if(pmn->rewardPercentage > 0 && (nHash % 100) <= (unsigned int)pmn->rewardPercentage) {
newWinner.payee = pmn->rewardAddress;
} else {
newWinner.payee = GetScriptForDestination(pmn->pubkey.GetID());
}
payeeSource = GetScriptForDestination(pmn->pubkey.GetID());
}
//if we can't find new MN to get paid, pick first active MN counting back from the end of vecLastPayments list
if(newWinner.nBlockHeight == 0 && nMinimumAge > 0)
{
LogPrintf(" Find by reverse \n");
BOOST_REVERSE_FOREACH(CTxIn& vinLP, vecLastPayments)
{
CMasternode* pmn = mnodeman.Find(vinLP);
if(pmn != NULL)
{
pmn->Check();
if(!pmn->IsEnabled()) continue;
newWinner.score = 0;
newWinner.nBlockHeight = nBlockHeight;
newWinner.vin = pmn->vin;
if(pmn->rewardPercentage > 0 && (nHash % 100) <= (unsigned int)pmn->rewardPercentage) {
newWinner.payee = pmn->rewardAddress;
} else {
newWinner.payee = GetScriptForDestination(pmn->pubkey.GetID());
}
payeeSource = GetScriptForDestination(pmn->pubkey.GetID());
break; // we found active MN
}
}
}
if(newWinner.nBlockHeight == 0) return false;
CTxDestination address1;
ExtractDestination(newWinner.payee, address1);
CethcashcoinAddress address2(address1);
CTxDestination address3;
ExtractDestination(payeeSource, address3);
CethcashcoinAddress address4(address3);
LogPrintf("Winner payee %s nHeight %d vin source %s. \n", address2.ToString().c_str(), newWinner.nBlockHeight, address4.ToString().c_str());
if(Sign(newWinner))
{
if(AddWinningMasternode(newWinner))
{
Relay(newWinner);
nLastBlockHeight = nBlockHeight;
return true;
}
}
return false;
}
void CMasternodePayments::Relay(CMasternodePaymentWinner& winner)
{
CInv inv(MSG_MASTERNODE_WINNER, winner.GetHash());
vector<CInv> vInv;
vInv.push_back(inv);
LOCK(cs_vNodes);
BOOST_FOREACH(CNode* pnode, vNodes){
pnode->PushMessage("inv", vInv);
}
}
void CMasternodePayments::Sync(CNode* node)
{
LOCK(cs_masternodepayments);
BOOST_FOREACH(CMasternodePaymentWinner& winner, vWinning)
if(winner.nBlockHeight >= pindexBest->nHeight-10 && winner.nBlockHeight <= pindexBest->nHeight + 20)
node->PushMessage("mnw", winner);
}
bool CMasternodePayments::SetPrivKey(std::string strPrivKey)
{
CMasternodePaymentWinner winner;
// Test signing successful, proceed
strMasterPrivKey = strPrivKey;
Sign(winner);
if(CheckSignature(winner)){
LogPrintf("CMasternodePayments::SetPrivKey - Successfully initialized as Masternode payments master\n");
enabled = true;
return true;
} else {
return false;
}
}
| [
"30493741+luanhv77@users.noreply.github.com"
] | 30493741+luanhv77@users.noreply.github.com |
60d3dc2a0a0094ae3f4de9dc7efae95d4057226f | eb944c542f0bd11b1191edc1ab72af519f65682a | /src/rpcprotocol.h | 3866e183d6c599e46a25dd6b2ca7cfc1c9c0ea5c | [
"MIT"
] | permissive | rcrtonline/rcrt | d090b5ff454338ac1cd1ce57bdb4528a4eb7a34d | 3acd714111ef8bed5e5c049210341d9c13fb03b4 | refs/heads/master | 2020-04-02T04:14:05.546316 | 2019-01-02T20:28:43 | 2019-01-02T20:28:43 | 149,267,931 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,936 | h | // Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2009-2014 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_RPCPROTOCOL_H
#define BITCOIN_RPCPROTOCOL_H
#include <list>
#include <map>
#include <stdint.h>
#include <string>
#include <boost/iostreams/concepts.hpp>
#include <boost/iostreams/stream.hpp>
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include <boost/filesystem.hpp>
#include <univalue.h>
//! HTTP status codes
enum HTTPStatusCode {
HTTP_OK = 200,
HTTP_BAD_REQUEST = 400,
HTTP_UNAUTHORIZED = 401,
HTTP_FORBIDDEN = 403,
HTTP_NOT_FOUND = 404,
HTTP_INTERNAL_SERVER_ERROR = 500,
HTTP_SERVICE_UNAVAILABLE = 503,
};
//! Recruit RPC error codes
enum RPCErrorCode {
//! Standard JSON-RPC 2.0 errors
RPC_INVALID_REQUEST = -32600,
RPC_METHOD_NOT_FOUND = -32601,
RPC_INVALID_PARAMS = -32602,
RPC_INTERNAL_ERROR = -32603,
RPC_PARSE_ERROR = -32700,
//! General application defined errors
RPC_MISC_ERROR = -1, //! std::exception thrown in command handling
RPC_FORBIDDEN_BY_SAFE_MODE = -2, //! Server is in safe mode, and command is not allowed in safe mode
RPC_TYPE_ERROR = -3, //! Unexpected type was passed as parameter
RPC_INVALID_ADDRESS_OR_KEY = -5, //! Invalid address or key
RPC_OUT_OF_MEMORY = -7, //! Ran out of memory during operation
RPC_INVALID_PARAMETER = -8, //! Invalid, missing or duplicate parameter
RPC_DATABASE_ERROR = -20, //! Database error
RPC_DESERIALIZATION_ERROR = -22, //! Error parsing or validating structure in raw format
RPC_VERIFY_ERROR = -25, //! General error during transaction or block submission
RPC_VERIFY_REJECTED = -26, //! Transaction or block was rejected by network rules
RPC_VERIFY_ALREADY_IN_CHAIN = -27, //! Transaction already in chain
RPC_IN_WARMUP = -28, //! Client still warming up
//! Aliases for backward compatibility
RPC_TRANSACTION_ERROR = RPC_VERIFY_ERROR,
RPC_TRANSACTION_REJECTED = RPC_VERIFY_REJECTED,
RPC_TRANSACTION_ALREADY_IN_CHAIN = RPC_VERIFY_ALREADY_IN_CHAIN,
//! P2P client errors
RPC_CLIENT_NOT_CONNECTED = -9, //! Recruit is not connected
RPC_CLIENT_IN_INITIAL_DOWNLOAD = -10, //! Still downloading initial blocks
RPC_CLIENT_NODE_ALREADY_ADDED = -23, //! Node is already added
RPC_CLIENT_NODE_NOT_ADDED = -24, //! Node has not been added before
RPC_CLIENT_NODE_NOT_CONNECTED = -29, //! Node to disconnect not found in connected nodes
RPC_CLIENT_INVALID_IP_OR_SUBNET = -30, //! Invalid IP/Subnet
//! Wallet errors
RPC_WALLET_ERROR = -4, //! Unspecified problem with wallet (key not found etc.)
RPC_WALLET_INSUFFICIENT_FUNDS = -6, //! Not enough funds in wallet or account
RPC_WALLET_INVALID_ACCOUNT_NAME = -11, //! Invalid account name
RPC_WALLET_KEYPOOL_RAN_OUT = -12, //! Keypool ran out, call keypoolrefill first
RPC_WALLET_UNLOCK_NEEDED = -13, //! Enter the wallet passphrase with walletpassphrase first
RPC_WALLET_PASSPHRASE_INCORRECT = -14, //! The wallet passphrase entered was incorrect
RPC_WALLET_WRONG_ENC_STATE = -15, //! Command given in wrong wallet encryption state (encrypting an encrypted wallet etc.)
RPC_WALLET_ENCRYPTION_FAILED = -16, //! Failed to encrypt the wallet
RPC_WALLET_ALREADY_UNLOCKED = -17, //! Wallet is already unlocked
};
/**
* IOStream device that speaks SSL but can also speak non-SSL
*/
template <typename Protocol>
class SSLIOStreamDevice : public boost::iostreams::device<boost::iostreams::bidirectional>
{
public:
SSLIOStreamDevice(boost::asio::ssl::stream<typename Protocol::socket>& streamIn, bool fUseSSLIn) : stream(streamIn)
{
fUseSSL = fUseSSLIn;
fNeedHandshake = fUseSSLIn;
}
void handshake(boost::asio::ssl::stream_base::handshake_type role)
{
if (!fNeedHandshake) return;
fNeedHandshake = false;
stream.handshake(role);
}
std::streamsize read(char* s, std::streamsize n)
{
handshake(boost::asio::ssl::stream_base::server); // HTTPS servers read first
if (fUseSSL) return stream.read_some(boost::asio::buffer(s, n));
return stream.next_layer().read_some(boost::asio::buffer(s, n));
}
std::streamsize write(const char* s, std::streamsize n)
{
handshake(boost::asio::ssl::stream_base::client); // HTTPS clients write first
if (fUseSSL) return boost::asio::write(stream, boost::asio::buffer(s, n));
return boost::asio::write(stream.next_layer(), boost::asio::buffer(s, n));
}
bool connect(const std::string& server, const std::string& port)
{
using namespace boost::asio::ip;
tcp::resolver resolver(stream.get_io_service());
tcp::resolver::iterator endpoint_iterator;
#if BOOST_VERSION >= 104300
try {
#endif
// The default query (flags address_configured) tries IPv6 if
// non-localhost IPv6 configured, and IPv4 if non-localhost IPv4
// configured.
tcp::resolver::query query(server.c_str(), port.c_str());
endpoint_iterator = resolver.resolve(query);
#if BOOST_VERSION >= 104300
} catch (boost::system::system_error& e) {
// If we at first don't succeed, try blanket lookup (IPv4+IPv6 independent of configured interfaces)
tcp::resolver::query query(server.c_str(), port.c_str(), resolver_query_base::flags());
endpoint_iterator = resolver.resolve(query);
}
#endif
boost::system::error_code error = boost::asio::error::host_not_found;
tcp::resolver::iterator end;
while (error && endpoint_iterator != end) {
stream.lowest_layer().close();
stream.lowest_layer().connect(*endpoint_iterator++, error);
}
if (error)
return false;
return true;
}
private:
bool fNeedHandshake;
bool fUseSSL;
boost::asio::ssl::stream<typename Protocol::socket>& stream;
};
std::string HTTPPost(const std::string& strMsg, const std::map<std::string, std::string>& mapRequestHeaders);
std::string HTTPError(int nStatus, bool keepalive, bool headerOnly = false);
std::string HTTPReplyHeader(int nStatus, bool keepalive, size_t contentLength, const char* contentType = "application/json");
std::string HTTPReply(int nStatus, const std::string& strMsg, bool keepalive, bool headerOnly = false, const char* contentType = "application/json");
bool ReadHTTPRequestLine(std::basic_istream<char>& stream, int& proto, std::string& http_method, std::string& http_uri);
int ReadHTTPStatus(std::basic_istream<char>& stream, int& proto);
int ReadHTTPHeaders(std::basic_istream<char>& stream, std::map<std::string, std::string>& mapHeadersRet);
int ReadHTTPMessage(std::basic_istream<char>& stream, std::map<std::string, std::string>& mapHeadersRet, std::string& strMessageRet, int nProto, size_t max_size);
std::string JSONRPCRequest(const std::string& strMethod, const UniValue& params, const UniValue& id);
UniValue JSONRPCReplyObj(const UniValue& result, const UniValue& error, const UniValue& id);
std::string JSONRPCReply(const UniValue& result, const UniValue& error, const UniValue& id);
UniValue JSONRPCError(int code, const std::string& message);
/** Get name of RPC authentication cookie file */
boost::filesystem::path GetAuthCookieFile();
/** Generate a new RPC authentication cookie and write it to disk */
bool GenerateAuthCookie(std::string *cookie_out);
/** Read the RPC authentication cookie from disk */
bool GetAuthCookie(std::string *cookie_out);
/** Delete RPC authentication cookie from disk */
void DeleteAuthCookie();
#endif // BITCOIN_RPCPROTOCOL_H
| [
"rcrtonline@protonmail.com"
] | rcrtonline@protonmail.com |
42b0c10c1fd9a7f289642b4fea6b25c86088c9c4 | 710b00495e333acaa254408ac12c9f07342e5c5d | /include/subTree.h | b4c6362092f9eff08dafa898ee7530d4d6ab19c4 | [] | no_license | RazorCMS/DarkPhotonAnalysis | ff2aec9bd744c325b727b6d73486b465c8b088a2 | 536f13434b590cd0c87aacdb77f7e18680d861fe | refs/heads/master | 2021-07-13T07:17:18.594322 | 2019-01-12T19:12:24 | 2019-01-12T19:12:24 | 154,596,765 | 0 | 0 | null | 2019-01-12T05:20:26 | 2018-10-25T02:15:23 | Python | UTF-8 | C++ | false | false | 3,901 | h | //////////////////////////////////////////////////////////
// This class has been automatically generated on
// Wed Dec 19 07:43:26 2018 by ROOT version 6.10/09
// from TTree tree/tree
// found on file: /mnt/hadoop/store/user/idutta/DarkPhoton/Samples/xcg2Dec2018/2Dec2018xcg_job0_scout_skimmed.root
//////////////////////////////////////////////////////////
#ifndef subTree_h
#define subTree_h
#include <TROOT.h>
#include <TChain.h>
#include <TFile.h>
// Header file for the classes stored in the TTree if any.
class subTree {
public :
TTree *fChain; //!pointer to the analyzed TTree or TChain
Int_t fCurrent; //!current Tree number in a TChain
// Fixed size dimensions of array or collections stored in the TTree if any.
// Declaration of leaf types
Float_t mass;
UChar_t category;
// List of branches
TBranch *b_mass; //!
TBranch *b_category; //!
subTree(TTree *tree=0);
virtual ~subTree();
virtual Int_t Cut(Long64_t entry);
virtual Int_t GetEntry(Long64_t entry);
virtual Long64_t LoadTree(Long64_t entry);
virtual void Init(TTree *tree);
virtual void Loop(const Long64_t &subentries);
virtual Bool_t Notify();
virtual void Show(Long64_t entry = -1);
};
#endif
#ifdef subTree_cxx
subTree::subTree(TTree *tree) : fChain(0)
{
// if parameter tree is not specified (or zero), connect the file
// used to generate this class and read the Tree.
if (tree == 0) {
TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject("/mnt/hadoop/store/user/idutta/DarkPhoton/Samples/xcg2Dec2018/2Dec2018xcg_job0_scout_skimmed.root");
if (!f || !f->IsOpen()) {
f = new TFile("/mnt/hadoop/store/user/idutta/DarkPhoton/Samples/xcg2Dec2018/2Dec2018xcg_job0_scout_skimmed.root");
}
f->GetObject("tree",tree);
}
Init(tree);
}
subTree::~subTree()
{
if (!fChain) return;
delete fChain->GetCurrentFile();
}
Int_t subTree::GetEntry(Long64_t entry)
{
// Read contents of entry.
if (!fChain) return 0;
return fChain->GetEntry(entry);
}
Long64_t subTree::LoadTree(Long64_t entry)
{
// Set the environment to read one entry
if (!fChain) return -5;
Long64_t centry = fChain->LoadTree(entry);
if (centry < 0) return centry;
if (fChain->GetTreeNumber() != fCurrent) {
fCurrent = fChain->GetTreeNumber();
Notify();
}
return centry;
}
void subTree::Init(TTree *tree)
{
// The Init() function is called when the selector needs to initialize
// a new tree or chain. Typically here the branch addresses and branch
// pointers of the tree will be set.
// It is normally not necessary to make changes to the generated
// code, but the routine can be extended by the user if needed.
// Init() will be called many times when running on PROOF
// (once per file to be processed).
// Set branch addresses and branch pointers
if (!tree) return;
fChain = tree;
fCurrent = -1;
fChain->SetMakeClass(1);
fChain->SetBranchAddress("mass", &mass, &b_mass);
fChain->SetBranchAddress("category", &category, &b_category);
Notify();
}
Bool_t subTree::Notify()
{
// The Notify() function is called when a new file is opened. This
// can be either for a new TTree in a TChain or when when a new TTree
// is started when using PROOF. It is normally not necessary to make changes
// to the generated code, but the routine can be extended by the
// user if needed. The return value is currently not used.
return kTRUE;
}
void subTree::Show(Long64_t entry)
{
// Print contents of entry.
// If entry is not specified, print current entry
if (!fChain) return;
fChain->Show(entry);
}
Int_t subTree::Cut(Long64_t entry)
{
// This function may be called from Loop.
// returns 1 if entry is accepted.
// returns -1 otherwise.
return 1;
}
#endif // #ifdef subTree_cxx
| [
"shufay.ung@gmail.com"
] | shufay.ung@gmail.com |
8f9d60d5e566125250d942d5b8a4a4ff15c01532 | 421eadb55c287255c9220d9f3564ac0b2df6513e | /multi.h | 1b38a6a5eac36e4c44573978dec77cdd13ccf6e5 | [] | no_license | Z-Jianxin/AsyncPDSparse | 767d4b8f7b83c9baacca386d24023930b99891c8 | 2db37d94214ae84299154ef744f84e2e8da25932 | refs/heads/master | 2023-03-16T21:13:44.359579 | 2017-10-22T16:20:46 | 2017-10-22T16:20:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,992 | h | #ifndef MULTITRAIN
#define MULTITRAIN
#include "util.h"
#include "NewHash.h"
class Problem{
public:
static map<string,int> label_index_map;
static vector<string> label_name_list;
static int D;//dimension
static int K;
vector<SparseVec*> data;
vector<Labels> labels;
int N;//number of samples
};
map<string,int> Problem::label_index_map;
vector<string> Problem::label_name_list;
int Problem::D = -1;
int Problem::K = -1;
class HeldoutEval{
public:
HeldoutEval(Problem* _heldout){
heldout = _heldout;
N = heldout->data.size();
D = heldout->D;
K = heldout->K;
prod = new Float[K];
for(int k=0;k<K;k++)
prod[k] = 0.0;
max_indices = new int[K];
for (int k = 0; k < K; k++)
max_indices[k] = k;
prod_is_nonzero = new bool[K];
for (int k = 0; k < K; k++)
prod_is_nonzero[k] = false;
}
~HeldoutEval(){
delete[] max_indices;
delete[] prod_is_nonzero;
delete[] prod;
}
//compute heldout accuracy using hash
double calcAcc( NewHash** w ){
hit=0.0;
for(int i=0;i<heldout->N;i++){
memset(prod, 0.0, sizeof(Float)*K);
SparseVec* xi = heldout->data.at(i);
Labels* yi = &(heldout->labels.at(i));
int top = 1;
if (top == -1)
top = yi->size();
// compute <w_k, x_i> where w_k is stored in hashmap
for(SparseVec::iterator it=xi->begin(); it!=xi->end(); it++){
int j= it->first;
Float xij = it->second;
NewHash* wj = w[j];
for (NewHash::iterator it=wj->begin();it!=wj->end();++it){
int k = it->first;
Float wjk = it->second;
prod[k] += wjk * xij;
}
}
//sort to get rank
sort(max_indices, max_indices+K, ScoreComp(prod));
for(int k=0;k<top;k++){
bool flag = false;
for (int j = 0; j < yi->size(); j++){
if (yi->at(j) == max_indices[k] ){
flag = true;
}
}
if (flag)
hit += 1.0/top;
}
}
return hit/N;
}
private:
int N,D,K;
Problem* heldout;
Float* prod;
int* max_indices;
Float hit;
bool* prod_is_nonzero;
};
class Param{
public:
char* trainFname;
char* modelFname;
char* heldoutFname;
Float lambda; //for L1-norm (default 1/N)
Float C; //weight of loss
int tau;//degree of asynchronization (for AsyncPDSparse)
int num_threads;//number of threads per node
int speed_up_rate; // speed up rate for sampling
int split_up_rate; // split up [K] into a number of subsets
Problem* train;
HeldoutEval* heldoutEval = NULL;
//solver-specific param
int solver;
int max_iter;
int max_select;
bool using_importance_sampling;
int post_solve_iter;
int early_terminate;
bool dump_model;
/** For AsyncPDSparse
*/
Float step_size_shrink;
Param(){
solver = 1;
lambda = 0.1;
C = 1.0;
tau = 10;
max_iter = 30;
max_select = -1;
using_importance_sampling = true;
post_solve_iter = INF;
early_terminate = 3;
heldoutFname == NULL;
train = NULL;
dump_model = false;
step_size_shrink = 0.1;
}
~Param(){
delete[] trainFname;
delete[] modelFname;
delete[] heldoutFname;
}
};
//only used for prediction
class StaticModel{
public:
StaticModel(){
label_name_list = new vector<string>();
label_index_map = new map<string,int>();
}
StaticModel(Problem* prob){
label_index_map = &(prob->label_index_map);
label_name_list = &(prob->label_name_list);
D = prob->D;
K = prob->K;
w = new SparseVec[D];
}
SparseVec* w;
int D;
int K;
vector<string>* label_name_list;
map<string,int>* label_index_map;
void writeModel( char* fname){
ofstream fout(fname);
fout << "nr_class " << K << endl;
fout << "label ";
for(vector<string>::iterator it=label_name_list->begin();
it!=label_name_list->end(); it++){
fout << *it << " ";
}
fout << endl;
fout << "nr_feature " << D << endl;
for(int j=0;j<D;j++){
SparseVec& wj = w[j];
fout << wj.size() << " ";
for(SparseVec::iterator it=wj.begin(); it!=wj.end(); it++){
fout << it->first << ":" << it->second << " ";
}
fout << endl;
if( j % (D/100) == 0 )
cerr << "." ;
}
cerr << endl;
fout.close();
}
};
class ThreadModelWriter{
public:
ThreadModelWriter(int _nNode, int _nThread, int node_id, int thread_id, Param* _param){
nNode = _nNode;
nThread = _nThread;
param = _param;
model_dir_name = new char[FNAME_LEN];
sprintf(model_dir_name, "model_dir.%s", param->modelFname);
char tmp[FNAME_LEN];
sprintf(tmp, "mkdir -p %s", model_dir_name);
system(tmp);
modelFname = new char[FNAME_LEN];
sprintf(modelFname, "%s/model.%d", model_dir_name, node_id*nThread+thread_id);
modelFout = new ofstream(modelFname);
}
ThreadModelWriter(int _nNode, int _nThread, Param* _param){
nNode = _nNode;
nThread = _nThread;
param = _param;
model_dir_name = new char[FNAME_LEN];
sprintf(model_dir_name, "model_dir.%s", param->modelFname);
char tmp[FNAME_LEN];
sprintf(tmp, "mkdir -p %s", model_dir_name);
system(tmp);
modelFname = new char[FNAME_LEN];
sprintf(modelFname, "%s/meta", model_dir_name);
modelFout = NULL;
}
~ThreadModelWriter(){
delete[] model_dir_name;
delete[] modelFname;
if( modelFout != NULL )
delete modelFout;
}
void writeMeta(){
ofstream fout(modelFname);
fout << "nr_class " << param->train->K << endl;
fout << "label ";
vector<string>& label_name_list = param->train->label_name_list;
for(vector<string>::iterator it=label_name_list.begin();
it!=label_name_list.end(); it++){
fout << *it << " ";
}
fout << endl;
fout << "nr_feature " << param->train->D << endl;
fout << "num_files " << nNode*nThread << endl;
fout.close();
}
void mergeModel(){
int D = param->train->D;
vector<SparseVec> W;
W.resize(D);
for(int i=0;i<nNode*nThread;i++){
char tmp[FNAME_LEN];
sprintf(tmp, "%s/model.%d", model_dir_name, i);
ifstream fin(tmp);
while( !fin.eof() ){
int class_id;
fin.read( (char*)&class_id, sizeof(int) );
if( fin.eof() )
break;
SparseVec sv;
fin >> sv;
for(SparseVec::iterator it=sv.begin(); it!=sv.end(); it++)
W[it->first].push_back(make_pair(class_id, it->second));
}
}
cerr << "output model file: " << modelFname << endl;
ofstream fout(modelFname);
fout << "nr_class " << param->train->K << endl;
fout << "label ";
vector<string>& label_name_list = param->train->label_name_list;
for(vector<string>::iterator it=label_name_list.begin();
it!=label_name_list.end(); it++){
fout << *it << " ";
}
fout << endl;
fout << "nr_feature " << param->train->D << endl;
for(int j=0;j<D;j++){
fout << W[j].size() << " ";
for(SparseVec::iterator it=W[j].begin(); it!=W[j].end(); it++)
fout << it->first << ":" << it->second << " ";
fout << endl;
if( j % (D/100) == 0 )
cerr << "." ;
}
cerr << endl;
fout.close();
char tmp[FNAME_LEN];
sprintf(tmp, "rm -rf model_dir.%s", param->modelFname);
system(tmp);
}
void writeVec(int class_id, SparseVec& sv){
(*modelFout).write( (char*) &class_id, sizeof(int) );
(*modelFout) << sv;
}
void close(){
(*modelFout).close();
}
private:
int nNode;
int nThread;
char* model_dir_name;
char* modelFname;
ofstream* modelFout;
Param* param;
};
void readData(char* fname, Problem* prob, bool add_bias)
{
map<string,int>* label_index_map = &(prob->label_index_map);
vector<string>* label_name_list = &(prob->label_name_list);
ifstream fin(fname);
char* line = new char[LINE_LEN];
int d = -1;
int line_count = 1;
while( !fin.eof() ){
fin.getline(line, LINE_LEN);
string line_str(line);
if( line_str.length() < 2 && fin.eof() )
break;
size_t found = line_str.find(" ");
while (found != string::npos){
line_str = line_str.replace(found, 2, " ");
found = line_str.find(" ");
}
found = line_str.find(", ");
while (found != string::npos){
line_str = line_str.replace(found, 2, ",");
found = line_str.find(", ");
}
vector<string> tokens = split(line_str, " ");
//get label index
Labels lab_indices;
lab_indices.clear();
map<string,int>::iterator it;
int st = 0;
while (st < tokens.size() && tokens[st].find(":") == string::npos){
// truncate , out
if (tokens[st].size() == 0){
st++;
continue;
}
vector<string> subtokens = split(tokens[st], ",");
for (vector<string>::iterator it_str = subtokens.begin(); it_str != subtokens.end(); it_str++){
string str = *it_str;
if (str == "" || str == " ")
continue;
if( (it=label_index_map->find(str)) == label_index_map->end() ){
lab_indices.push_back(label_index_map->size());
label_index_map->insert(make_pair(str, lab_indices.back()));
}else{
lab_indices.push_back(it->second);
}
}
st++;
}
SparseVec* ins = new SparseVec();
//adding Bias
if( add_bias )
ins->push_back(make_pair(0,1.0));
/////////////
for(int i=st;i<tokens.size();i++){
vector<string> kv = split(tokens[i],":");
int ind = atoi(kv[0].c_str());
Float val = atof(kv[1].c_str());
ins->push_back(make_pair(ind,val));
if( ind > d )
d = ind;
if( ind < 1 ){
cerr << "minimum feature index should be 1 (" << line_count << " line)" << endl;
exit(0);
}
}
prob->data.push_back(ins);
prob->labels.push_back(lab_indices);
line_count++;
}
fin.close();
/* Adding Bias
*/
if (prob->D < d+1){
prob->D = d+1;
}
prob->N = prob->data.size();
prob->K = label_index_map->size();
label_name_list->resize(prob->K);
for(map<string,int>::iterator it=label_index_map->begin();
it!=label_index_map->end();
it++)
(*label_name_list)[it->second] = it->first;
//random rehash labels
/*HashFunc* hashfun = new HashFunc(prob->K);
for(map<string,int>::iterator it=label_index_map->begin();
it!=label_index_map->end(); it++){
it->second = hashfun->get(it->second);
(*label_name_list)[it->second] = it->first;
}
for(int i=0;i<prob->labels.size();i++){
for(int j=0;j<prob->labels[i].size();j++)
prob->labels[i][j] = hashfun->get(prob->labels[i][j]);
}
delete hashfun;*/
delete[] line;
}
StaticModel* readModel(char* file, bool is_binary){
StaticModel* model = new StaticModel();
char* tmp = new char[LINE_LEN];
if( !is_binary ){
ifstream fin(file);
fin >> tmp >> (model->K);
fin >> tmp;
string name;
for(int k=0;k<model->K;k++){
fin >> name;
model->label_name_list->push_back(name);
model->label_index_map->insert(make_pair(name,k));
}
fin >> tmp >> (model->D);
model->w = new SparseVec[model->D];
vector<string> ind_val;
int nnz_j;
for(int j=0;j<model->D;j++){
if( j % (model->D/100) == 0 )
cerr << ".";
fin >> nnz_j;
model->w[j].resize(nnz_j);
for(int r=0;r<nnz_j;r++){
fin >> tmp;
ind_val = split(tmp,":");
int k = atoi(ind_val[0].c_str());
Float val = atof(ind_val[1].c_str());
model->w[j][r].first = k;
model->w[j][r].second = val;
}
}
cerr << endl;
}else{
//read meta
sprintf(tmp, "%s/meta", file);
ifstream fin(tmp);
fin >> tmp >> (model->K);
fin >> tmp;
string name;
for(int k=0;k<model->K;k++){
fin >> name;
model->label_name_list->push_back(name);
model->label_index_map->insert(make_pair(name,k));
}
fin >> tmp >> (model->D);
model->w = new SparseVec[model->D];
SparseVec* W = model->w;
int num_model_files;
fin >> tmp >> num_model_files;
cerr << "num_model_files=" << num_model_files << endl;
fin.close();
//read models
for(int i=0;i<num_model_files;i++){
sprintf(tmp, "%s/model.%d", file, i);
ifstream fin(tmp);
while( !fin.eof() ){
int class_id;
fin.read( (char*)&class_id, sizeof(int) );
if( fin.eof() )
break;
SparseVec sv;
fin >> sv;
for(SparseVec::iterator it=sv.begin(); it!=sv.end(); it++)
W[it->first].push_back(make_pair(class_id, it->second));
}
fin.close();
}
}
delete[] tmp;
return model;
}
#endif
| [
"a061105@gmail.com"
] | a061105@gmail.com |
ee83509bab7c182284e777febb9ed12320d6982a | 5979b4d890468e3f26c61e41643263981cdfd47e | /user.h | c762b3cd954945eed23447a52c05a031afe9a3de | [] | no_license | danieldir/carSellGui | 9580300137f8e7a3dede803fd48bb4da1befcb87 | fed1dcb3d0483da384f3ac3d634746248f8b2b31 | refs/heads/master | 2022-04-22T21:00:10.708232 | 2020-02-06T16:16:56 | 2020-02-06T16:16:56 | 234,334,018 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 85 | h | #ifndef USER_H
#define USER_H
class User
{
public:
User();
};
#endif // USER_H | [
"pikachurodrigue@gmail.com"
] | pikachurodrigue@gmail.com |
565bd79df21fd7226b16bbc7152e586beb5e8fd5 | 02095cd4aeaa3a0d724f7362cdb8795fe9a81620 | /oplink/algorithms/team/src/plugins/algorithms/NSGA2_MultiObjectivized_Fuzzy_Restart/NSGA2_MultiObjectivized_Fuzzy_Restart.cpp | 80027ca2965e094b27cf122fce77eba4e39ee1a3 | [] | no_license | PAL-ULL/software-metco | ba5123cb1423fed4a2ac678ab375728ba4bbfbc8 | 59edc4e49bddbd9fc7237bf2f24271bdfc8afd79 | refs/heads/master | 2021-04-15T04:12:56.292543 | 2021-03-08T13:29:14 | 2021-03-08T13:29:14 | 126,484,450 | 10 | 5 | null | 2020-07-21T18:43:10 | 2018-03-23T12:49:10 | C++ | ISO-8859-1 | C++ | false | false | 45,124 | cpp | /***********************************************************************************
* AUTHORS
* - Eduardo Segredo González
* - Carlos Segura González
*
* DATE
* May 2013
* *********************************************************************************/
#include "NSGA2_MultiObjectivized_Fuzzy_Restart.h"
#include <float.h>
// Define una generación de búsqueda del algoritmo
void NSGA2_MultiObjectivized_Fuzzy_Restart::runGeneration() {
// Evaluate the initial population
if (getGeneration() == 0) {
multiObjectivize(population);
rankPopulation();
}
// Push the children at the end of the population
createChildPop();
//MultiObjetivizar
multiObjectivize(offSpring);
//Fill External Archive
fillExternalArchive();
// Calculate the fitness as the rank of each element
rankCrowdingPopulation();
}
// Inicializa los parámetros iniciales del algoritmo
bool NSGA2_MultiObjectivized_Fuzzy_Restart::init(const vector<string> ¶ms) {
// Check for the algorithm parameters
if (params.size() != 7) {
cerr << "Error NSGA-II: Incorrect parameters (pc pSize minR maxR delta numGenToFuzzify k)" << endl;
cerr << params.size() << endl;
return false;
}
// Initiate the parameters
this->pc = atof(params[0].c_str());
setPopulationSize(atoi(params[1].c_str()));
this->minR = atof(params[2].c_str());
this->maxR = atof(params[3].c_str());
this->delta = atof(params[4].c_str());
this->numGenToFuzzify = atoi(params[5].c_str());
this->k = atoi(params[6].c_str());
offSpring = new vector<Individual *>();
if (delta <= 0) {
cerr << "Error NSGA-II: Parameter delta must be greater than 0" << endl;
return false;
}
if (numGenToFuzzify <= 0) {
cerr << "Error NSGA-II: Parameter numGenToFuzzify must be greater than 0" << endl;
return false;
}
if (k <= 0) {
cerr << "Error NSGA-II: Parameter k must be greater than 0" << endl;
return false;
}
if ((minR >= maxR) || (minR < 0) || (maxR < 0)) {
cerr << "Error NSGA-II: Parameters minR and maxR must be greater than or equal to 0, and minR must be lower than maxR" << endl;
return false;
}
long double value = 0;
for (int i = 0; i <= (int)((1.0 / delta) + 1.0); i++) {
initStageValues.push_back((maxR - minR) * value + minR);
value += delta;
}
initStage = true;
cout << "initStageValues: [";
for (int i = 0; i < initStageValues.size(); i++) {
cout << initStageValues[i] << ", ";
}
cout << "]" << endl;
cout << "initStageValues size: " << initStageValues.size() << endl;
int r = rand();
cout << "rand: " << r << endl;
int i = r % initStageValues.size();
cout << "i: " << i << endl;
pm = initStageValues[i];
initStageValues[i] = initStageValues[initStageValues.size() - 1];
initStageValues.pop_back();
// Definition of the Fuzzy System
// Engine
fuzzyEngine = new fl::Engine("fuzzyEngine");
// Input variables
fit = new fl::InputVariable;
fit->setName("FIT");
fit->setRange(0.0, 1.0);
fit->addTerm(new fl::Triangle("LOW", -0.5, 0, 0.5));
fit->addTerm(new fl::Triangle("MEDIUM", 0, 0.5, 1));
fit->addTerm(new fl::Triangle("HIGH", 0.5, 1, 1.5));
fuzzyEngine->addInputVariable(fit);
pmIn = new fl::InputVariable;
pmIn->setName("PM_IN");
pmIn->setRange(0.0, 1.0);
pmIn->addTerm(new fl::Triangle("LOW", -0.16667, 0, 0.16667));
pmIn->addTerm(new fl::Triangle("LOW_MED_B", 0, 0.16667, 0.33333));
pmIn->addTerm(new fl::Triangle("LOW_MED_A", 0.16667, 0.33333, 0.5));
pmIn->addTerm(new fl::Triangle("MEDIUM", 0.33333, 0.5, 0.66667));
pmIn->addTerm(new fl::Triangle("MED_HIGH_A", 0.5, 0.66667, 0.83333));
pmIn->addTerm(new fl::Triangle("MED_HIGH_B", 0.66667, 0.83333, 1));
pmIn->addTerm(new fl::Triangle("HIGH", 0.83333, 1, 1.16667));
fuzzyEngine->addInputVariable(pmIn);
var = new fl::InputVariable;
var->setName("VAR");
var->setRange(0.0, 1.0);
var->addTerm(new fl::Triangle("LOW", -0.5, 0, 0.5));
var->addTerm(new fl::Triangle("MEDIUM", 0, 0.5, 1));
var->addTerm(new fl::Triangle("HIGH", 0.5, 1, 1.5));
fuzzyEngine->addInputVariable(var);
// Output Variables
pmOut = new fl::OutputVariable;
pmOut->setName("PM_OUT");
pmOut->setRange(-0.45, 0.45);
pmOut->addTerm(new fl::Triangle("NEG_GIANT", -0.54, -0.45, -0.36));
pmOut->addTerm(new fl::Triangle("NEG_HUGE", -0.45, -0.36, -0.27));
pmOut->addTerm(new fl::Triangle("NEG_HIGH", -0.36, -0.27, -0.18));
pmOut->addTerm(new fl::Triangle("NEG_MEDIUM", -0.27, -0.18, -0.09));
pmOut->addTerm(new fl::Triangle("NEG_LOW", -0.18, -0.09, 0));
pmOut->addTerm(new fl::Triangle("ZERO", -0.09, 0, 0.09));
pmOut->addTerm(new fl::Triangle("POS_LOW", 0, 0.09, 0.18));
pmOut->addTerm(new fl::Triangle("POS_MEDIUM", 0.09, 0.18, 0.27));
pmOut->addTerm(new fl::Triangle("POS_HIGH", 0.18, 0.27, 0.36));
pmOut->addTerm(new fl::Triangle("POS_HUGE", 0.27, 0.36, 0.45));
pmOut->addTerm(new fl::Triangle("POS_GIANT", 0.36, 0.45, 0.54));
fuzzyEngine->addOutputVariable(pmOut);
// Seven different fuzzy rules sets
fl::RuleBlock* rules_low = new fl::RuleBlock;
fl::RuleBlock* rules_low_med_b = new fl::RuleBlock;
fl::RuleBlock* rules_low_med_a = new fl::RuleBlock;
fl::RuleBlock* rules_medium = new fl::RuleBlock;
fl::RuleBlock* rules_med_high_a = new fl::RuleBlock;
fl::RuleBlock* rules_med_high_b = new fl::RuleBlock;
fl::RuleBlock* rules_high = new fl::RuleBlock;
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is LOW and VAR is LOW then PM_OUT is POS_LOW", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is LOW and VAR is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is LOW and VAR is HIGH then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is MEDIUM then PM_OUT is ZERO", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is LOW then PM_OUT is NEG_MEDIUM", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is LOW then PM_OUT is NEG_HIGH", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is LOW then PM_OUT is NEG_HUGE", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is LOW then PM_OUT is NEG_GIANT", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is LOW then PM_OUT is NEG_GIANT", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is LOW then PM_OUT is NEG_GIANT", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is LOW then PM_OUT is POS_MEDIUM", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is LOW and VAR is LOW then PM_OUT is POS_LOW", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is LOW and VAR is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is LOW and VAR is HIGH then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is MEDIUM then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is LOW then PM_OUT is NEG_MEDIUM", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is LOW then PM_OUT is NEG_HIGH", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is LOW then PM_OUT is NEG_HUGE", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is LOW then PM_OUT is NEG_GIANT", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is LOW then PM_OUT is NEG_GIANT", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low_med_b->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is LOW then PM_OUT is POS_HIGH", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is LOW then PM_OUT is POS_MEDIUM", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is LOW and VAR is LOW then PM_OUT is POS_LOW", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is LOW and VAR is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is LOW and VAR is HIGH then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is MEDIUM then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is LOW then PM_OUT is NEG_MEDIUM", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is LOW then PM_OUT is NEG_HIGH", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is LOW then PM_OUT is NEG_HUGE", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is LOW then PM_OUT is NEG_GIANT", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_low_med_a->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is LOW then PM_OUT is POS_HUGE", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is LOW then PM_OUT is POS_HIGH", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is LOW then PM_OUT is POS_MEDIUM", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is LOW and VAR is LOW then PM_OUT is POS_LOW", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is LOW and VAR is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is LOW and VAR is HIGH then PM_OUT is NEG_LOW", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is MEDIUM then PM_OUT is ZERO", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is LOW then PM_OUT is NEG_MEDIUM", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is LOW then PM_OUT is NEG_HIGH", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is LOW then PM_OUT is NEG_HUGE", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_medium->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is LOW then PM_OUT is POS_GIANT", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is LOW then PM_OUT is POS_HUGE", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is LOW then PM_OUT is POS_HIGH", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is LOW then PM_OUT is POS_MEDIUM", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is LOW and VAR is LOW then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is LOW and VAR is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is LOW and VAR is HIGH then PM_OUT is NEG_LOW", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is MEDIUM then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is LOW then PM_OUT is NEG_MEDIUM", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is LOW then PM_OUT is NEG_HIGH", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_med_high_a->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is LOW then PM_OUT is POS_GIANT", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is LOW then PM_OUT is POS_GIANT", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is LOW then PM_OUT is POS_HUGE", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is LOW then PM_OUT is POS_HIGH", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is LOW then PM_OUT is POS_MEDIUM", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is LOW and VAR is LOW then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is LOW and VAR is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is LOW and VAR is HIGH then PM_OUT is NEG_LOW", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is MEDIUM then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is LOW then PM_OUT is NEG_MEDIUM", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is MEDIUM then PM_OUT is NEG_LOW", fuzzyEngine));
rules_med_high_b->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is LOW then PM_OUT is POS_GIANT", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is LOW and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is LOW then PM_OUT is POS_GIANT", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is LOW then PM_OUT is POS_GIANT", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is LOW_MED_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is LOW then PM_OUT is POS_HUGE", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is MEDIUM and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is LOW then PM_OUT is POS_HIGH", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_A and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is LOW then PM_OUT is POS_MEDIUM", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is MED_HIGH_B and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is LOW and VAR is LOW then PM_OUT is POS_LOW", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is LOW and VAR is MEDIUM then PM_OUT is POS_LOW", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is LOW and VAR is HIGH then PM_OUT is NEG_LOW", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is MEDIUM then PM_OUT is ZERO", fuzzyEngine));
rules_high->addRule(fl::FuzzyRule::parse("if PM_IN is HIGH and FIT is HIGH then PM_OUT is ZERO", fuzzyEngine));
fuzzyEngine->addRuleBlock(rules_low);
fuzzyEngine->addRuleBlock(rules_low_med_b);
fuzzyEngine->addRuleBlock(rules_low_med_a);
fuzzyEngine->addRuleBlock(rules_medium);
fuzzyEngine->addRuleBlock(rules_med_high_a);
fuzzyEngine->addRuleBlock(rules_med_high_b);
fuzzyEngine->addRuleBlock(rules_high);
fuzzyEngine->configure("Minimum", "Maximum", "Minimum", "Maximum", "Centroid");
improvements = vector< vector<long double> > (pmIn->numberOfTerms(), vector<long double>());
memberships = vector< vector<long double> > (pmIn->numberOfTerms(), vector<long double>());
weightedImprovements = vector<long double>(pmIn->numberOfTerms(), 0.0);
return true;
}
// Rellena un frente con las soluciones actuales
void NSGA2_MultiObjectivized_Fuzzy_Restart::getSolution(MOFront *p) {
//Look for the best one in the original objective
int bestIndex = 0;
double currentBestValue = (*population)[0]->getObj(0);
//Select the individual with best "original" objective
for (int i = 1; i < population->size(); i++){
if ( ((*population)[0]->getOptDirection(0) == MINIMIZE) && ((*population)[i]->getObj(0) < currentBestValue)){
bestIndex = i;
currentBestValue = (*population)[i]->getObj(0);
} else if ( ((*population)[0]->getOptDirection(0) == MAXIMIZE) && ((*population)[i]->getObj(0) > currentBestValue)){
bestIndex = i;
currentBestValue = (*population)[i]->getObj(0);
}
}
p->insert((*population)[bestIndex]);
//for (unsigned int i = 0; i < population->size(); i++) {
// p->insert((*population)[i]);
//}
}
// Muestra la información relativa al algoritmo
void NSGA2_MultiObjectivized_Fuzzy_Restart::printInfo(ostream &os) const {
os << "Genetic Algorithm NSGA2_MultiObjectivized_Fuzzy_Restart" << endl;
os << "Number of Evaluations = " << getEvaluations() << endl;
os << "Mutation Probability = " << pm << endl;
os << "Crossover Probability = " << pc << endl;
os << "Population Size = " << getPopulationSize() << endl;
}
/*******************************************************************************
* Los siguientes métodos son específicos del NSGA-II y describen las operaciones
* internas y el propio funcionamiento del algoritmo.
* *****************************************************************************/
// NSGA-II crowding operator
/*************************************************************************
* Create fronts using the non-domination rank until pSize elements have
* been selected.
* Each front is ordered using the local crowding distance.
* In: population without any order with size = pSize * 2
* Exit: population ordered using the crowded comparison operator with size pSize
* ***********************************************************************/
void NSGA2_MultiObjectivized_Fuzzy_Restart::rankCrowdingPopulation() {
int inserted = 0;
vector < vector < Individual * > > fronts;
vector < Individual *> notClassified;
//Calculate fronts
int differentsInFront0;
for (int i = 0; i < offSpring->size(); i++){
population->push_back((*offSpring)[i]);
}
FastNondominatedSort(population, fronts, notClassified, differentsInFront0, getPopulationSize());
// Order each front using the local crowding distance
for (int i = 0; i < fronts.size(); i++)
crowOrder(fronts[i]);
//Create the ordered population
population->clear();
for (int i = 0; i < fronts.size() - 1; i++){
for (int j = 0; j < fronts[i].size(); j++){
population->push_back(fronts[i][j]);
}
}
//Last front
for (int j = 0; j < fronts[fronts.size() - 1].size(); j++){
if (population->size() < (unsigned int) getPopulationSize()){
population->push_back((fronts[fronts.size() - 1][j]));
} else {
delete (fronts[fronts.size() - 1][j]);
}
}
//Delete not used individuals
for (int i = 0; i < notClassified.size(); i++){
delete (notClassified[i]);
}
}
// Sort and rank the population
// Population has size N, it reorders the population based on the
void NSGA2_MultiObjectivized_Fuzzy_Restart::rankPopulation() {
vector < vector < Individual * > > fronts;
vector < Individual *> notClassified;
int differentsInFront0 = 0;
FastNondominatedSort(population, fronts, notClassified, differentsInFront0, population->size());
population->clear();
for (int i = 0; i < fronts.size(); i++){
for (int j = 0; j< fronts[i].size(); j++){
population->push_back(fronts[i][j]);
}
}
}
/*******************************************************************************
* Create a child population by applying:
* - Selection
* - Crossover
* - Recombination
* *****************************************************************************/
void NSGA2_MultiObjectivized_Fuzzy_Restart::createChildPop() {
int tamPop = population->size();
vector<int> a1;
// Se genera un vector con los numeros de 0 a tamPop-1 (2 veces)
for (int i = 0; i < 2; i++) {
for (int j = 0; j < tamPop; j++) {
a1.push_back(j);
}
}
// Se reordena la primera mitad
for (int i = 0; i < tamPop; i++) {
int rand_value = i + (int) (((double)(tamPop-i))*rand()/(RAND_MAX+1.0));
int tmp = a1[rand_value];
a1[rand_value] = a1[i];
a1[i] = tmp;
}
// Reodenamos la segunda mitad
for (int i = tamPop; i < tamPop*2; i++) {
int rand_value = i + (int) (((double)(2*tamPop-i))*rand()/(RAND_MAX+1.0));
int tmp = a1[rand_value];
a1[rand_value] = a1[i];
a1[i] = tmp;
}
offSpring->clear();
for (int i = 0; i < (tamPop*2)-((tamPop*2) % 4); i += 4){
// Selection
int ind1 = a1[i];
int ind2 = a1[i+1];
// Binary tournment
if (ind1 < ind2){
offSpring->push_back((*population)[ind1]->internalClone());
} else{
offSpring->push_back((*population)[ind2]->internalClone());
}
int ind3 = a1[i+2];
int ind4 = a1[i+3];
if (ind3 < ind4){
offSpring->push_back((*population)[ind3]->internalClone());
} else {
offSpring->push_back((*population)[ind4]->internalClone());
}
// Crossover
double vcross = rand() / (RAND_MAX + 1.0);
if (vcross < pc) {
(*offSpring)[offSpring->size()-2]->crossover((*offSpring)[offSpring->size()-1]);
}
// Mutation
(*offSpring)[offSpring->size()- 2]->mutation(pm);
(*offSpring)[offSpring->size()- 1]->mutation(pm);
evaluate((*offSpring)[offSpring->size()-2]);
evaluate((*offSpring)[offSpring->size()-1]);
}
// If population is odd one more must be inserted
if (tamPop % 2) {
int ind1 = a1[a1.size()- 4 ];
int ind2 = a1[a1.size() - 3];
Individual *tmp;
// Binary tournment
if (ind1 < ind2) {
tmp = (*population)[ind1]->internalClone();
} else{
tmp = (*population)[ind2]->internalClone();
}
int ind3 = a1[a1.size()-2];
int ind4 = a1[a1.size()-1];
if (ind3 < ind4) {
offSpring->push_back((*population)[ind3]->internalClone());
} else {
offSpring->push_back((*population)[ind4]->internalClone());
}
// Crossover
double vcross = rand() / (RAND_MAX + 1.0);
if (vcross < pc) {
(*offSpring)[offSpring->size()-1]->crossover(tmp);
}
delete(tmp);
// Mutation
(*offSpring)[offSpring->size()- 1]->mutation(pm);
evaluate((*offSpring)[offSpring->size()-1]);
}
// The fuzzy logic controller infers the next value for the mutation rate pm
//Looks for best individual (obj[0])
Individual *best = lookForBestIndividual();
if (best == NULL) {
cerr << "Error: offSpring and population has a size equal to 0" << endl;
exit(-1);
}
if (getGeneration() == 0) {
prevBestFitness = best->getObj(0);
cout << "Generation: " << getGeneration() << endl;
cout << "pm: " << pm << endl;
cout << "prevBestFitness: " << prevBestFitness << endl;
}
if ((getGeneration() + 1) % numGenToFuzzify == 0) {
// Calculates the value of pm scaled to the range [0, 1]
long double pm_scaled = (pm - minR) / (maxR - minR);
// Updates the history of the mutation rate
pmHistory.push_back(pm_scaled);
// Calculates the improvement and updates the history of improvements
best = lookForBestIndividual();
if (best == NULL) {
cerr << "Error: offSpring and population has a size equal to 0" << endl;
exit(-1);
}
cout << "Generation: " << getGeneration() << endl;
cout << "pm: " << pm << endl;
cout << "pm_scaled: " << pm_scaled << endl;
cout << "prevBestFitness: " << prevBestFitness << endl;
cout << "bestFitness: " << best->getObj(0) << endl;
long double currentImprovement = fabs(prevBestFitness - best->getObj(0));
improvementHistory.push_back(currentImprovement);
prevBestFitness = best->getObj(0);
cout << "currentImprovement: " << currentImprovement << endl;
// Calculates the diversity of the population (moment of inertia)
long double currentMoment = 0;
if (population != offSpring) {
for (int i = 0; i < best->getNumberOfVar(); i++) {
// Calculates the centroid
long double sum = 0;
for (int j = 0; j < population->size(); j++) {
sum += (*population)[j]->getVar(i);
}
for (int j = 0; j < offSpring->size(); j++) {
sum += (*offSpring)[j]->getVar(i);
}
long double centroid = sum / (long double)(population->size() + offSpring->size());
sum = 0;
for (int j = 0; j < population->size(); j++) {
long double aux = (*population)[j]->getVar(i) - centroid;
sum += (aux * aux);
}
for (int j = 0; j < offSpring->size(); j++) {
long double aux = (*offSpring)[j]->getVar(i) - centroid;
sum += (aux * aux);
}
currentMoment += sum;
}
}
// Updates the history of moments
momentHistory.push_back(currentMoment);
// Calculates the improvements and the memberships
for (int i = 0; i < pmIn->numberOfTerms(); i++) {
long double currentMembership = (long double)pmIn->getTerm(i)->membership((fl::scalar)pm_scaled);
if (currentMembership != 0) {
improvements[i].push_back(currentImprovement);
memberships[i].push_back(currentMembership);
}
}
// Calculates the weigthed improvements
for (int i = 0; i < pmIn->numberOfTerms(); i++) {
long double num = 0;
long double denom = 0;
int lowerbound = (improvements[i].size() <= k)? 0 : improvements[i].size() - k;
for (int j = lowerbound; j < improvements[i].size(); j++) {
num += (improvements[i][j] * memberships[i][j] * (j - lowerbound + 1));
denom += (memberships[i][j] * (j - lowerbound + 1));
}
if (denom != 0) {
weightedImprovements[i] = (num / denom);
}
}
cout << "weightedImprovements = (";
for (int i = 0; i < weightedImprovements.size(); i++) {
cout << weightedImprovements[i] << ", ";
}
cout << ")" << endl;
// Input variable: pmIn
fl::scalar pmInValue = (fl::scalar)pm_scaled;
pmIn->setInput(pmInValue);
// Input variable: fit
fl::scalar fitValue = (currentImprovement != 0)? (fl::scalar)getFitValue() : 0;
fit->setInput(fitValue);
// Input Variable: varValue
fl::scalar varValue = (currentMoment != 0)? (fl::scalar)getVarValue() : 0;
var->setInput(varValue);
// Looks for the most suitable set of rules to be applied
long double max = 0;
int maxIndex = 0;
for (int i = 0; i < weightedImprovements.size(); i++) {
if (weightedImprovements[i] > max) {
max = weightedImprovements[i];
maxIndex = i;
}
}
// Clean every output variable
for (std::size_t i = 0; i < fuzzyEngine->numberOfOutputVariables(); ++i) {
fuzzyEngine->getOutputVariable(i)->output()->clear();
}
// Executes the fuzzy system with the most suitable set of rules
fuzzyEngine->getRuleBlock(maxIndex)->fireRules();
// Output variable: pmOutValue
fl::scalar pmOutValue;
pmOutValue = pmOut->defuzzify();
cout << "SET OF RULES=" << maxIndex << endl;
cout << "PM_IN=" << pmInValue << endl;
cout << "FIT=" << fitValue << endl;
cout << "VAR=" << varValue << endl;
cout << "PM_IN is " << pmIn->fuzzify(pmInValue) << endl;
cout << "FIT is " << fit->fuzzify(fitValue) << endl;
cout << "VAR is " << var->fuzzify(varValue) << endl;
cout << "PM_OUT=" << pmOutValue << endl;
cout << "PM_OUT is " << pmOut->fuzzify(pmOutValue) << endl;
cout << "--" << endl;
// Stops the initialization stage
if ((initStage) && (initStageValues.size() == 0)) {
initStage = false;
}
// Updates the mutation rate
if (initStage) {
// Obtains a random value from the initStageValues vector
int i = rand() % initStageValues.size();
long double value = initStageValues[i];
pm = value;
// Removes the selected value for the next iteration
initStageValues[i] = initStageValues[initStageValues.size() - 1];
initStageValues.pop_back();
cout << "pm actualizado en fase inicial: " << pm << endl;
} else {
pm_scaled += pmOutValue;
if (pm_scaled > 1) {
pm_scaled = 1;
} else if (pm_scaled < 0) {
pm_scaled = 0;
}
// Transforms the value from range [0, 1] to range [minR, maxR]
pm = (maxR - minR) * pm_scaled + minR;
cout << "pm actualizado con pmOutValue: " << pm << endl;
}
}
}
void NSGA2_MultiObjectivized_Fuzzy_Restart::fillExternalArchive(){
for (int i = 0; i < offSpring->size(); i++){
insertInArchive((*offSpring)[i]);
}
}
void NSGA2_MultiObjectivized_Fuzzy_Restart::multiObjectivize(vector <Individual*> *updatePop){
int start = getSampleInd()->getNumberOfObj() - getNumMultiObjectivizationPlugins();
for (int i = start; i < getSampleInd()->getNumberOfObj(); i++){
getMultiObjectivizationPlugin(i - start)->convertToMultiObjective(population, updatePop, NULL, i, getGeneration());
}
}
void NSGA2_MultiObjectivized_Fuzzy_Restart::exchangePerformed(){
multiObjectivize(population);
}
long double NSGA2_MultiObjectivized_Fuzzy_Restart::getFitValue() {
long double bestImprovement = improvementHistory[improvementHistory.size() - 1];
int lowerbound = (improvementHistory.size() <= k)? 0 : improvementHistory.size() - k;
for (int i = lowerbound; i < improvementHistory.size() - 1; i++) {
if (improvementHistory[i] > bestImprovement) {
bestImprovement = improvementHistory[i];
}
}
return (improvementHistory[improvementHistory.size() - 1] / bestImprovement);
}
long double NSGA2_MultiObjectivized_Fuzzy_Restart::getVarValue() {
long double bestMoment = momentHistory[momentHistory.size() - 1];
int lowerbound = (momentHistory.size() <= k)? 0 : momentHistory.size() - k;
for (int i = lowerbound; i < momentHistory.size() - 1; i++) {
if (momentHistory[i] > bestMoment) {
bestMoment = momentHistory[i];
}
}
return (momentHistory[momentHistory.size() - 1] / bestMoment);
}
Individual* NSGA2_MultiObjectivized_Fuzzy_Restart::lookForBestIndividual() {
Individual *best = NULL;
if (population->size() > 0){
best = (*population)[0];
} else if (offSpring->size() > 0){
best = (*offSpring)[0];
} else {
return NULL;
}
int direction = best->getInternalOptDirection(0);
for (int i = 0; i < population->size(); i++){
if ( ( (direction == MINIMIZE) && ((*population)[i]->getObj(0) < best->getObj(0)) ) ||
( (direction == MAXIMIZE) && ((*population)[i]->getObj(0) > best->getObj(0))) ){
best = (*population)[i];
}
}
if (population != offSpring){
for (int i = 0; i < offSpring->size(); i++){
if ( ( (direction == MINIMIZE) && ((*offSpring)[i]->getObj(0) < best->getObj(0)) ) ||
( (direction == MAXIMIZE) && ((*offSpring)[i]->getObj(0) > best->getObj(0))) ){
best = (*offSpring)[i];
}
}
}
return best;
}
double* NSGA2_MultiObjectivized_Fuzzy_Restart::getRestartInfo() {
// improvements size
int numImpr = 0;
for (int i = 0; i < improvements.size(); i++) {
numImpr += improvements[i].size();
}
// memberships size
int numMemb = 0;
for (int i = 0; i < memberships.size(); i++) {
numMemb += memberships[i].size();
}
double *data = new double[3 + (1 + initStageValues.size()) + (1 + improvements.size() + numImpr) + (1 + memberships.size() + numMemb) +
(1 + weightedImprovements.size()) + (1 + pmHistory.size()) + (1 + improvementHistory.size()) + (1 + momentHistory.size())];
int idx = 0;
data[idx++] = pm;
data[idx++] = prevBestFitness;
data[idx++] = initStage;
cout << "Recogiendo informacion en getRestartInfo" << endl;
cout << "pm: " << pm << endl;
cout << "prevBestFitness: " << prevBestFitness << endl;
cout << "initStage: " << initStage << endl;
// initStageValues
data[idx++] = initStageValues.size();
for (int i = 0; i < initStageValues.size(); i++) {
data[idx++] = initStageValues[i];
}
// improvements
data[idx++] = improvements.size();
for (int i = 0; i < improvements.size(); i++) {
data[idx++] = improvements[i].size();
for (int j = 0; j < improvements[i].size(); j++) {
data[idx++] = improvements[i][j];
}
}
// memberships
data[idx++] = memberships.size();
for (int i = 0; i < memberships.size(); i++) {
data[idx++] = memberships[i].size();
for (int j = 0; j < memberships[i].size(); j++) {
data[idx++] = memberships[i][j];
}
}
// weightedImprovements
data[idx++] = weightedImprovements.size();
for (int i = 0; i < weightedImprovements.size(); i++) {
data[idx++] = weightedImprovements[i];
}
// pmHistory
data[idx++] = pmHistory.size();
for (int i = 0; i < pmHistory.size(); i++) {
data[idx++] = pmHistory[i];
}
// improvementHistory
data[idx++] = improvementHistory.size();
for (int i = 0; i < improvementHistory.size(); i++) {
data[idx++] = improvementHistory[i];
}
// momentHistory
data[idx++] = momentHistory.size();
for (int i = 0; i < momentHistory.size(); i++) {
data[idx++] = momentHistory[i];
}
for (int i = 0; i < momentHistory.size(); i++) {
cout << momentHistory[i] << " ";
}
cout << endl;
return data;
}
void NSGA2_MultiObjectivized_Fuzzy_Restart::setRestartInfo(double *data) {
int idx = 0;
pm = (long double)data[idx++];
prevBestFitness = (long double)data[idx++];
initStage = (bool)data[idx++];
cout << "Restaurando informacion en setRestartInfo" << endl;
cout << "pm: " << pm << endl;
cout << "prevBestFitness: " << prevBestFitness << endl;
cout << "initStage: " << initStage << endl;
// initStageValues
int size = (int)data[idx++];
initStageValues.clear();
for (int i = 0; i < size; i++) {
initStageValues.push_back((long double)data[idx++]);
}
// improvements
int numVec = (int)data[idx++];
improvements.clear();
improvements = vector< vector<long double> > (numVec, vector<long double>());
for (int i = 0; i < numVec; i++) {
size = (int)data[idx++];
for (int j = 0; j < size; j++) {
improvements[i].push_back((long double)data[idx++]);
}
}
// memberships
numVec = (int)data[idx++];
memberships.clear();
memberships = vector< vector<long double> > (numVec, vector<long double>());
for (int i = 0; i < numVec; i++) {
size = (int)data[idx++];
for (int j = 0; j < size; j++) {
memberships[i].push_back((long double)data[idx++]);
}
}
// weightedImprovements
size = (int)data[idx++];
weightedImprovements.clear();
for (int i = 0; i < size; i++) {
weightedImprovements.push_back((long double)data[idx++]);
}
// pmHistory
size = (int)data[idx++];
pmHistory.clear();
for (int i = 0; i < size; i++) {
pmHistory.push_back((long double)data[idx++]);
}
// improvementHistory
size = (int)data[idx++];
improvementHistory.clear();
for (int i = 0; i < size; i++) {
improvementHistory.push_back((long double)data[idx++]);
}
// momentHistory
size = (int)data[idx++];
momentHistory.clear();
for (int i = 0; i < size; i++) {
momentHistory.push_back((long double)data[idx++]);
}
for (int i = 0; i < momentHistory.size(); i++) {
cout << momentHistory[i] << " ";
}
cout << endl;
}
| [
"edusegre@gmail.com"
] | edusegre@gmail.com |
e4c0804d9b867e140936fcfc7c758416a35a4d60 | 8bcca6838e85cac66d155f3d27c72ceaf848679c | /小车底盘代码/stm32/rikirobot4wd_stm32-master/Driver/PID.cpp | 9154f85570ddf5b1d4e9770a2d63ee80d2a30aca | [] | no_license | sunpeer/riki_robot | 2c1e41607fa9533d19eb2ae73536043a0440394c | 10a6d88f6795067b6c4dcb65aa36904a2117a197 | refs/heads/main | 2023-03-07T06:45:32.462096 | 2021-02-20T07:11:56 | 2021-02-20T07:11:56 | 340,587,316 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 754 | cpp | #include "PID.h"
PID::PID(float min_val, float max_val, float kp, float ki, float kd)
{
min_val_ = min_val;
max_val_ = max_val;
kp_ = kp;
ki_ = ki;
kd_ = kd;
}
double PID::compute(float setpoint, float measured_value)
{
double error;
double pid;
//setpoint is constrained between min and max to prevent pid from having too much error
error = setpoint - measured_value;
integral_ = integral_ + error;
derivative_ = error - prev_error_;
if(setpoint == 0 && error == 0){
integral_ = 0;
}
pid = (kp_ * error) + (ki_ * integral_) + (kd_ * derivative_);
prev_error_ = error;
return constrain(pid, min_val_, max_val_);
}
void PID::updateConstants(float kp, float ki, float kd)
{
kp_ = kp;
ki_ = ki;
kd_ = kd;
}
| [
"1031826952@qq.com"
] | 1031826952@qq.com |
591f217f0326d46b1caf5cadd2e719b3d7b0dc4a | dfdeec4db13dcd57599fd45ab77a52993df12cea | /HC05-AT-TEST/HC05-AT-TEST.ino | 896e4530ee2e6e94e0433da3e433421f548750c3 | [] | no_license | FabSebSingap/My-Car-Arduino-Bluetooth | 6673e23ec0cd69adede1f1d26c256744341e4053 | f182e951ab0ee2da82f794720c0efb497d55c878 | refs/heads/main | 2023-02-10T20:01:14.670634 | 2020-12-25T14:19:03 | 2020-12-25T14:19:03 | 324,158,353 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,275 | ino | /* This will work for a HC-05
*
*
* cablage
* VCC –> +5V
* GND –>GND
* TXD –> Pin 0 (RX)
* RXD –> Pin 1 (TX)
* Si HC-05 : EN (ou Key) relié au 3.3V de l'arduino
*
* Le HC-05 doit clignoter lentement (2 sec) s'il est en mode commandes AT
* La console série de l'ordi doit être sur 57600 bauds et "les deux, NL et CR" pour les fins de ligne
* le module bluetooth ne doit PAS être apparié à un téléphone ou autre
*
* will not work with a HC-06 which doesn't want \r\n for an end of line
*/
/**********************************************
* Module bluetooth HC05 envoi de commandes AT
* et affichage de la réponse du module
* Source
* http://www.instructables.com/id/AT-command-mode-of-HC-05-Bluetooth-module/?ALLSTEPS
* http://www.instructables.com/id/Modify-The-HC-05-Bluetooth-Module-Defaults-Using-A/?ALLSTEPS
*
************************************************/
#include <SoftwareSerial.h> //Software Serial Port
#define RxD 10 //Pin 2 pour arduino RX (pin0=serial)
#define TxD 11 //Pin 3 pour arduino TX
SoftwareSerial BTSerie(RxD,TxD);
void setup()
{
Serial.begin(57600); //115200 si on veut
delay(500);
Serial.println("Bonjour - Pret pour les commandes AT");
Serial.println("Le HC-05 doit clignoter lentement (2 secondes)");
// Configuration du bluetooth
pinMode(RxD, INPUT);
pinMode(TxD, OUTPUT);
BTSerie.begin(38400); //57600 / 38400
delay(500);
BTSerie.print("AT+VERSION?"); //Demande le N° de version
BTSerie.print("\r\n"); // sur HC-05, toutes les commandes doivent se terminer par \r\n
// afficher ce que le module bluetooth répond
Serial.print( BTSerie.read() ); // afficher sur console ce qui est lu sur BT
// si tout va bien, c'est le n° de version puis OK qui s'affiche
}
void loop()
{
char recvChar;
//On lit caractere par caractere sur le BTSerie et on affiche sur le Terminal Serie
if (BTSerie.available()) {
recvChar = BTSerie.read();
Serial.print(recvChar);
}
// Serial.write(blueToothSerial.read());
if (Serial.available()) {
recvChar = Serial.read();
BTSerie.write(recvChar);
}
}
| [
"noreply@github.com"
] | noreply@github.com |
0f95021ecf7cbbca3384490aadd259e4fb617401 | ac5af3d4a60ecec85ebed44502b70eece28f726f | /Kuangbin/Kuangbin专题七 线段树/qhb/H.cpp | 7c95c400475ca12956f2856c7b8eca69ae1ecc69 | [] | no_license | qhb1001/For-that-dream | 29f473cb4301bba70985c1c6ac4a152e237598fe | 624a21572e9d674f007d9f65d560e83d281d7497 | refs/heads/master | 2020-03-09T21:33:28.847612 | 2018-09-27T13:39:53 | 2018-09-27T13:39:53 | 129,012,092 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,851 | cpp | #include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <cmath>
#include <vector>
using namespace std;
const int MAX = 2e5 + 5;
struct Node {
bool type;//if all values in this segment are '1'
long long val;
}t[MAX];
int n, m;
void build() {
for(int i = n - 1; i > 0; --i) {
if(t[i<<1].type && t[i<<1|1].type) t[i].type = 1;
else t[i].type = 0;
t[i].val = t[i<<1].val + t[i<<1|1].val;
}
}
void up(int x) {
while(x > 1) {
t[x>>1].val = t[x].val + t[x^1].val;
x >>= 1;
}
}
long long deal(int x) {
if(t[x].type == 1) return t[x].val;
if(x >= n) {
// cout << x << " " << t[x].val << " -> " << (int)sqrt(t[x].val) << endl;
t[x].val = sqrt(t[x].val);
// cout << "now : " << t[x].val << endl;
if(t[x].val <= 1) t[x].type = 1;
up(x);
return t[x].val;
}
if(t[x<<1].type != 1) deal(x<<1);
if(t[x<<1|1].type != 1) deal(x<<1|1);
t[x].val = t[x<<1].val + t[x<<1|1].val;
if(t[x<<1].type && t[x<<1|1].type) t[x].type = 1;
up(x);
return t[x].val;
}
void update(int l, int r) {
for(l += n, r += n; l < r; l >>= 1, r >>= 1) {
if(l&1) deal(l++);
if(r&1) deal(--r);
}
}
long long query(int l, int r) {
long long ans = 0;
for(l += n, r += n; l < r; l >>= 1, r >>= 1) {
if(l&1) {
ans += t[l++].val;
}
if(r&1) {
ans += t[--r].val;
}
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int cnt = 1;
// freopen("input", "r", stdin);
// freopen("output.a", "w", stdout);
while(cin >> n) {
cout << "Case #" << cnt++ << ":\n";
for(int i = 0; i < n; ++i) {
cin >> t[i + n].val;
if(t[i + n].val <= 1) t[i + n].type = 1;
else t[i + n].type = 0;
}
build();
cin >> m;
int type, l, r;
while(m--) {
cin >> type >> l >> r;
if(l > r) swap(l, r);
if(type == 0) update(l - 1, r);
else cout << query(l - 1, r) << '\n';
}
cout << '\n';
}
}
| [
"z694895876@gmail.com"
] | z694895876@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.