blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 986
values | visit_date timestamp[us] | revision_date timestamp[us] | committer_date timestamp[us] | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 23
values | gha_event_created_at timestamp[us] | gha_created_at timestamp[us] | gha_language stringclasses 145
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 10.4M | extension stringclasses 122
values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
fe8e84b59f5873c45609d291dcf0899bc81f1c72 | 693e63f1c6054f7897083fec02f138392ad71d9b | /example/http/server/flex/http_server_flex.cpp | 1607a1b8ff18bfbabddbcc8b10a0a6dc747aabd0 | [
"LicenseRef-scancode-unknown-license-reference",
"BSL-1.0"
] | permissive | HowardHinnant/beast | f45f4f0bc9162e61c28a641f528634999880d1de | fa112ef5fc6b5e5ddb275b8ea2c50714df06041c | refs/heads/develop | 2021-01-23T07:33:59.604512 | 2017-09-05T17:14:51 | 2017-09-05T17:14:51 | 102,509,121 | 2 | 1 | null | 2017-09-05T17:11:59 | 2017-09-05T17:11:59 | null | UTF-8 | C++ | false | false | 18,712 | cpp | //
// Copyright (c) 2016-2017 Vinnie Falco (vinnie dot falco at gmail dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/boostorg/beast
//
//------------------------------------------------------------------------------
//
// Example: HTTP flex server (plain and SSL), asynchronous
//
//------------------------------------------------------------------------------
#include "example/common/detect_ssl.hpp"
#include "example/common/server_certificate.hpp"
#include <boost/beast/core.hpp>
#include <boost/beast/http.hpp>
#include <boost/beast/version.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/ssl/stream.hpp>
#include <boost/asio/strand.hpp>
#include <boost/config.hpp>
#include <algorithm>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <thread>
using tcp = boost::asio::ip::tcp; // from <boost/asio/ip/tcp.hpp>
namespace ssl = boost::asio::ssl; // from <boost/asio/ssl.hpp>
namespace http = boost::beast::http; // from <boost/beast/http.hpp>
// Return a reasonable mime type based on the extension of a file.
boost::beast::string_view
mime_type(boost::beast::string_view path)
{
using boost::beast::iequals;
auto const ext = [&path]
{
auto const pos = path.rfind(".");
if(pos == boost::beast::string_view::npos)
return boost::beast::string_view{};
return path.substr(pos);
}();
if(iequals(ext, ".htm")) return "text/html";
if(iequals(ext, ".html")) return "text/html";
if(iequals(ext, ".php")) return "text/html";
if(iequals(ext, ".css")) return "text/css";
if(iequals(ext, ".txt")) return "text/plain";
if(iequals(ext, ".js")) return "application/javascript";
if(iequals(ext, ".json")) return "application/json";
if(iequals(ext, ".xml")) return "application/xml";
if(iequals(ext, ".swf")) return "application/x-shockwave-flash";
if(iequals(ext, ".flv")) return "video/x-flv";
if(iequals(ext, ".png")) return "image/png";
if(iequals(ext, ".jpe")) return "image/jpeg";
if(iequals(ext, ".jpeg")) return "image/jpeg";
if(iequals(ext, ".jpg")) return "image/jpeg";
if(iequals(ext, ".gif")) return "image/gif";
if(iequals(ext, ".bmp")) return "image/bmp";
if(iequals(ext, ".ico")) return "image/vnd.microsoft.icon";
if(iequals(ext, ".tiff")) return "image/tiff";
if(iequals(ext, ".tif")) return "image/tiff";
if(iequals(ext, ".svg")) return "image/svg+xml";
if(iequals(ext, ".svgz")) return "image/svg+xml";
return "application/text";
}
// Append an HTTP rel-path to a local filesystem path.
// The returned path is normalized for the platform.
std::string
path_cat(
boost::beast::string_view base,
boost::beast::string_view path)
{
if(base.empty())
return path.to_string();
std::string result = base.to_string();
#if BOOST_MSVC
char constexpr path_separator = '\\';
if(result.back() == path_separator)
result.resize(result.size() - 1);
result.append(path.data(), path.size());
for(auto& c : result)
if(c == '/')
c = path_separator;
#else
char constexpr path_separator = '/';
if(result.back() == path_separator)
result.resize(result.size() - 1);
result.append(path.data(), path.size());
#endif
return result;
}
// This function produces an HTTP response for the given
// request. The type of the response object depends on the
// contents of the request, so the interface requires the
// caller to pass a generic lambda for receiving the response.
template<
class Body, class Allocator,
class Send>
void
handle_request(
boost::beast::string_view doc_root,
http::request<Body, http::basic_fields<Allocator>>&& req,
Send&& send)
{
// Returns a bad request response
auto const bad_request =
[&req](boost::beast::string_view why)
{
http::response<http::string_body> res{http::status::bad_request, req.version};
res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
res.set(http::field::content_type, "text/html");
res.keep_alive(req.keep_alive());
res.body = why.to_string();
res.prepare_payload();
return res;
};
// Returns a not found response
auto const not_found =
[&req](boost::beast::string_view target)
{
http::response<http::string_body> res{http::status::not_found, req.version};
res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
res.set(http::field::content_type, "text/html");
res.keep_alive(req.keep_alive());
res.body = "The resource '" + target.to_string() + "' was not found.";
res.prepare_payload();
return res;
};
// Returns a server error response
auto const server_error =
[&req](boost::beast::string_view what)
{
http::response<http::string_body> res{http::status::internal_server_error, req.version};
res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
res.set(http::field::content_type, "text/html");
res.keep_alive(req.keep_alive());
res.body = "An error occurred: '" + what.to_string() + "'";
res.prepare_payload();
return res;
};
// Make sure we can handle the method
if( req.method() != http::verb::get &&
req.method() != http::verb::head)
return send(bad_request("Unknown HTTP-method"));
// Request path must be absolute and not contain "..".
if( req.target().empty() ||
req.target()[0] != '/' ||
req.target().find("..") != boost::beast::string_view::npos)
return send(bad_request("Illegal request-target"));
// Build the path to the requested file
std::string path = path_cat(doc_root, req.target());
if(req.target().back() == '/')
path.append("index.html");
// Attempt to open the file
boost::beast::error_code ec;
http::file_body::value_type body;
body.open(path.c_str(), boost::beast::file_mode::scan, ec);
// Handle the case where the file doesn't exist
if(ec == boost::system::errc::no_such_file_or_directory)
return send(not_found(req.target()));
// Handle an unknown error
if(ec)
return send(server_error(ec.message()));
// Respond to HEAD request
if(req.method() == http::verb::head)
{
http::response<http::empty_body> res{http::status::ok, req.version};
res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
res.set(http::field::content_type, mime_type(path));
res.content_length(body.size());
res.keep_alive(req.keep_alive());
return send(std::move(res));
}
// Respond to GET request
http::response<http::file_body> res{
std::piecewise_construct,
std::make_tuple(std::move(body)),
std::make_tuple(http::status::ok, req.version)};
res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
res.set(http::field::content_type, mime_type(path));
res.content_length(body.size());
res.keep_alive(req.keep_alive());
return send(std::move(res));
}
//------------------------------------------------------------------------------
// Report a failure
void
fail(boost::system::error_code ec, char const* what)
{
std::cerr << what << ": " << ec.message() << "\n";
}
// Handles an HTTP server connection.
// This uses the Curiously Recurring Template Pattern so that
// the same code works with both SSL streams and regular sockets.
template<class Derived>
class session
{
// Access the derived class, this is part of
// the Curiously Recurring Template Pattern idiom.
Derived&
derived()
{
return static_cast<Derived&>(*this);
}
// This is the C++11 equivalent of a generic lambda.
// The function object is used to send an HTTP message.
struct send_lambda
{
session& self_;
explicit
send_lambda(session& self)
: self_(self)
{
}
template<bool isRequest, class Body, class Fields>
void
operator()(http::message<isRequest, Body, Fields>&& msg) const
{
// The lifetime of the message has to extend
// for the duration of the async operation so
// we use a shared_ptr to manage it.
auto sp = std::make_shared<
http::message<isRequest, Body, Fields>>(std::move(msg));
// Store a type-erased version of the shared
// pointer in the class to keep it alive.
self_.res_ = sp;
// Write the response
http::async_write(
self_.derived().stream(),
*sp,
self_.strand_.wrap(std::bind(
&session::on_write,
self_.derived().shared_from_this(),
std::placeholders::_1)));
}
};
std::string const& doc_root_;
http::request<http::string_body> req_;
std::shared_ptr<void> res_;
send_lambda lambda_;
protected:
boost::asio::io_service::strand strand_;
boost::beast::flat_buffer buffer_;
public:
// Take ownership of the buffer
explicit
session(
boost::asio::io_service& ios,
boost::beast::flat_buffer buffer,
std::string const& doc_root)
: doc_root_(doc_root)
, lambda_(*this)
, strand_(ios)
, buffer_(std::move(buffer))
{
}
void
do_read()
{
// Read a request
http::async_read(
derived().stream(),
buffer_,
req_,
strand_.wrap(std::bind(
&session::on_read,
derived().shared_from_this(),
std::placeholders::_1)));
}
void
on_read(boost::system::error_code ec)
{
// This means they closed the connection
if(ec == http::error::end_of_stream)
return derived().do_eof();
if(ec)
return fail(ec, "read");
// Send the response
handle_request(doc_root_, std::move(req_), lambda_);
}
void
on_write(boost::system::error_code ec)
{
if(ec == http::error::end_of_stream)
{
// This means we should close the connection, usually because
// the response indicated the "Connection: close" semantic.
return derived().do_eof();
}
if(ec)
return fail(ec, "write");
// We're done with the response so delete it
res_ = nullptr;
// Read another request
do_read();
}
};
// Handles a plain HTTP connection
class plain_session
: public session<plain_session>
, public std::enable_shared_from_this<plain_session>
{
tcp::socket socket_;
boost::asio::io_service::strand strand_;
public:
// Create the session
plain_session(
tcp::socket socket,
boost::beast::flat_buffer buffer,
std::string const& doc_root)
: session<plain_session>(
socket.get_io_service(),
std::move(buffer),
doc_root)
, socket_(std::move(socket))
, strand_(socket_.get_io_service())
{
}
// Called by the base class
tcp::socket&
stream()
{
return socket_;
}
// Start the asynchronous operation
void
run()
{
do_read();
}
void
do_eof()
{
// Send a TCP shutdown
boost::system::error_code ec;
socket_.shutdown(tcp::socket::shutdown_send, ec);
// At this point the connection is closed gracefully
}
};
// Handles an SSL HTTP connection
class ssl_session
: public session<ssl_session>
, public std::enable_shared_from_this<ssl_session>
{
tcp::socket socket_;
ssl::stream<tcp::socket&> stream_;
boost::asio::io_service::strand strand_;
public:
// Create the session
ssl_session(
tcp::socket socket,
ssl::context& ctx,
boost::beast::flat_buffer buffer,
std::string const& doc_root)
: session<ssl_session>(
socket.get_io_service(),
std::move(buffer),
doc_root)
, socket_(std::move(socket))
, stream_(socket_, ctx)
, strand_(stream_.get_io_service())
{
}
// Called by the base class
ssl::stream<tcp::socket&>&
stream()
{
return stream_;
}
// Start the asynchronous operation
void
run()
{
// Perform the SSL handshake
// Note, this is the buffered version of the handshake.
stream_.async_handshake(
ssl::stream_base::server,
buffer_.data(),
strand_.wrap(std::bind(
&ssl_session::on_handshake,
shared_from_this(),
std::placeholders::_1,
std::placeholders::_2)));
}
void
on_handshake(
boost::system::error_code ec,
std::size_t bytes_used)
{
if(ec)
return fail(ec, "handshake");
// Consume the portion of the buffer used by the handshake
buffer_.consume(bytes_used);
do_read();
}
void
do_eof()
{
// Perform the SSL shutdown
stream_.async_shutdown(
strand_.wrap(std::bind(
&ssl_session::on_shutdown,
shared_from_this(),
std::placeholders::_1)));
}
void
on_shutdown(boost::system::error_code ec)
{
if(ec)
return fail(ec, "shutdown");
// At this point the connection is closed gracefully
}
};
//------------------------------------------------------------------------------
// Detects SSL handshakes
class detect_session : public std::enable_shared_from_this<detect_session>
{
tcp::socket socket_;
ssl::context& ctx_;
boost::asio::io_service::strand strand_;
std::string const& doc_root_;
boost::beast::flat_buffer buffer_;
public:
explicit
detect_session(
tcp::socket socket,
ssl::context& ctx,
std::string const& doc_root)
: socket_(std::move(socket))
, ctx_(ctx)
, strand_(socket_.get_io_service())
, doc_root_(doc_root)
{
}
// Launch the detector
void
run()
{
async_detect_ssl(
socket_,
buffer_,
strand_.wrap(std::bind(
&detect_session::on_detect,
shared_from_this(),
std::placeholders::_1,
std::placeholders::_2)));
}
void
on_detect(boost::system::error_code ec, boost::tribool result)
{
if(ec)
return fail(ec, "detect");
if(result)
{
// Launch SSL session
std::make_shared<ssl_session>(
std::move(socket_),
ctx_,
std::move(buffer_),
doc_root_)->run();
return;
}
// Launch plain session
std::make_shared<plain_session>(
std::move(socket_),
std::move(buffer_),
doc_root_)->run();
}
};
// Accepts incoming connections and launches the sessions
class listener : public std::enable_shared_from_this<listener>
{
ssl::context& ctx_;
boost::asio::io_service::strand strand_;
tcp::acceptor acceptor_;
tcp::socket socket_;
std::string const& doc_root_;
public:
listener(
boost::asio::io_service& ios,
ssl::context& ctx,
tcp::endpoint endpoint,
std::string const& doc_root)
: ctx_(ctx)
, strand_(ios)
, acceptor_(ios)
, socket_(ios)
, doc_root_(doc_root)
{
boost::system::error_code ec;
// Open the acceptor
acceptor_.open(endpoint.protocol(), ec);
if(ec)
{
fail(ec, "open");
return;
}
// Bind to the server address
acceptor_.bind(endpoint, ec);
if(ec)
{
fail(ec, "bind");
return;
}
// Start listening for connections
acceptor_.listen(
boost::asio::socket_base::max_connections, ec);
if(ec)
{
fail(ec, "listen");
return;
}
}
// Start accepting incoming connections
void
run()
{
if(! acceptor_.is_open())
return;
do_accept();
}
void
do_accept()
{
acceptor_.async_accept(
socket_,
std::bind(
&listener::on_accept,
shared_from_this(),
std::placeholders::_1));
}
void
on_accept(boost::system::error_code ec)
{
if(ec)
{
fail(ec, "accept");
}
else
{
// Create the detector session and run it
std::make_shared<detect_session>(
std::move(socket_),
ctx_,
doc_root_)->run();
}
// Accept another connection
do_accept();
}
};
//------------------------------------------------------------------------------
int main(int argc, char* argv[])
{
// Check command line arguments.
if (argc != 5)
{
std::cerr <<
"Usage: http-server-sync <address> <port> <doc_root> <threads>\n" <<
"Example:\n" <<
" http-server-sync 0.0.0.0 8080 .\n";
return EXIT_FAILURE;
}
auto const address = boost::asio::ip::address::from_string(argv[1]);
auto const port = static_cast<unsigned short>(std::atoi(argv[2]));
std::string const doc_root = argv[3];
auto const threads = std::max<std::size_t>(1, std::atoi(argv[4]));
// The io_service is required for all I/O
boost::asio::io_service ios{threads};
// The SSL context is required, and holds certificates
ssl::context ctx{ssl::context::sslv23};
// This holds the self-signed certificate used by the server
load_server_certificate(ctx);
// Create and launch a listening port
std::make_shared<listener>(
ios,
ctx,
tcp::endpoint{address, port},
doc_root)->run();
// Run the I/O service on the requested number of threads
std::vector<std::thread> v;
v.reserve(threads - 1);
for(auto i = threads - 1; i > 0; --i)
v.emplace_back(
[&ios]
{
ios.run();
});
ios.run();
return EXIT_SUCCESS;
}
| [
"vinnie.falco@gmail.com"
] | vinnie.falco@gmail.com |
c66b1cd2ed16e89bd59292279f100b2c4a78c97f | 7789ad02373dd0f836133e147d50ba69bdd95994 | /PowerMsgLog/stdafx.cpp | 242fb77be15e223656867806a4929dacad16bc45 | [] | no_license | wfschmitt/logging_ce | 0124eb9f970a0a5b2573f3e237933fefbb334e85 | bf6d04a3c816620c98f5b38e2bd8e5838faa6d22 | refs/heads/master | 2021-01-16T22:59:33.664435 | 2014-05-22T08:02:50 | 2014-05-22T08:02:50 | 20,857,992 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 298 | cpp | // stdafx.cpp : source file that includes just the standard includes
// PowerMsgLog.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
// TODO: reference any additional headers you need in STDAFX.H
// and not in this file
| [
"hjgode@gmail.com"
] | hjgode@gmail.com |
33c9fb513a62aaac52d9c1bb87b2d75a48657b32 | f5758ed70a5fb4d2e8ffeb5ede061cbe0dab0197 | /hw3.cpp | d44a4b69ccc4aaacaf72ce42544aa3aa216b6a97 | [] | no_license | jjongchan/learningc | 85d88f89eb9116cca2f0176c303fbe47919b00bd | 34cb0e01f277ee70221f56e11bc713eea8c97419 | refs/heads/master | 2021-04-29T01:03:56.628351 | 2017-01-02T17:14:59 | 2017-01-02T17:14:59 | 77,786,823 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 504 | cpp | #include<stdio.h>
int main()
{
int time_by_sec = 54321; // 초 단위로 주어진 시간
int hour, min, sec;
sec = time_by_sec; //초에 주어진 값을 대입
hour = (sec / 3600); // 초를 이용하여 시간을 계산
sec = sec - (hour * 3600);// 초에서 시간단위만큼 빼줌
min = (sec / 60); // 남은 초에서 분을 계산
sec = sec - (min * 60); // 분을 뺀 나머지가 초
printf("%d초는 %d시간 %d분 %d초 입니다.\n", time_by_sec, hour, min, sec);
return 0;
} | [
"alehfkr@naver.com"
] | alehfkr@naver.com |
9e35cafb83cc3e41f6de1e60bb7724d92a941448 | 8c339f9b8c9c3edbbc668bf69e773ece2f27fc84 | /112A.cpp | e99fbbb91ca61075582061286008becb02904b5f | [] | no_license | saptarsi96/Codes | 8828b1da724a6daf2905ef720c5d7a0c8db65ab7 | 52fd11265eec9de9ccbff88a68fa7d33950170db | refs/heads/master | 2021-06-17T02:30:56.081683 | 2021-03-09T03:23:30 | 2021-03-09T03:23:30 | 170,972,612 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 398 | cpp | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string>
using namespace std;
string s1,s2;
int main() {
//freopen("a.in","r",stdin);
getline(cin,s1);
getline(cin,s2);
for (int i=0;i<s1.size();++i) {
if (s1[i]>=97) s1[i]-=32;
if (s2[i]>=97) s2[i]-=32;
}
if (s1==s2) printf("0\n");
else {
if (s1<s2) printf("-1\n");
else printf("1\n");
}
} | [
"saptarshi.saha0@gmail.com"
] | saptarshi.saha0@gmail.com |
805ecb567f3b451f72e684e2e266d72decde413d | c9ec1fcf9a3462f3f9deafa974d107a58f9b5545 | /UMAD/UMAD/HeaderFiles/classifier/util/ReadLabel.h | 32515eff12668c0487c30f3326fc5ded2561512f | [] | no_license | geekzph/UMAD | 85c6b4ef89e12b824dc198f25d475a0c6315421f | 532bb8ed51e2d2eeaa77e2d4ebd0b9f8452bd5aa | refs/heads/master | 2021-01-21T07:57:18.763598 | 2015-05-07T16:32:15 | 2015-05-07T16:32:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 756 | h | #ifndef READLABEL_H
#define READLABEL_H
#include "../../../HeaderFiles/metricdata/MetricData.h"
#include <fstream>
#include <string>
#include <sstream>
#include <map>
using namespace std;
/**
*@ file readlabel.h
*@ classes store data number and the class label of train data
*@ author Ping Li
*@ version 2014-08-01
*/
/**
*@ class CReadLabel
*@ brief store data number and the class label of train data
*@ author Ping Li
*/
class CReadLabel:public CMetricData
{
public:
/**
*@ store the class label of train data
*@ param fileName: fileName is the primary data file that store attribute and class label
*@ param maxDataNum: the total number of the data list
*/
static vector<string> loadLabel(string fileName,int maxDataNum);
};
#endif | [
"maorui@szu1304"
] | maorui@szu1304 |
df3ec22a63a286f3c3e73db718f864ff17834b10 | 96202389c4800b77670f51653e821192d336fb0f | /BET.h | 76046129015c982f95c853f82e35ec8eb6fd42f6 | [] | no_license | ChristelleNieves/Binary-Expression-Tree | 17f28b71618b2581933bbdcec8b286af0cc4e64e | 745d0b55f7a3cb94a42b18df68a501dead503885 | refs/heads/master | 2022-04-24T09:27:58.722824 | 2020-04-24T02:25:00 | 2020-04-24T02:25:00 | 258,383,385 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,235 | h | // **********************************************************
// * Name: Christelle Nieves * *
// * Assignment: Assignment 4: Binary Expression Tree *
// * Date: March 15, 2020 * *
// **********************************************************
#ifndef _BET_H
#define _BET_H
#include <iostream>
class BET
{
// Nested BinaryNode class
class BinaryNode
{
public:
std::string element;
BinaryNode * left, * right;
};
public:
BET(); // Default zero param constructor
BET(const std::string& postfix); // One-param constructor. Postfix is string separated by spaces.
BET(const BET&); // Copy constructor
~BET(); // Destructor
bool buildFromPostfix(const std::string& postfix); // Build BET from a postfix string.
const BET& operator=(const BET&); // Assignment operator.
void printInfixExpression(); // Print the infix expression by calling the private recursive function.
void printPostfixExpression(); // Print the postfix expression by calling the private recursive function.
size_t size(); // Return the number of nodes in the tree by calling the private recursive function.
bool empty(); // Return true if the tree is empty, false otherwise.
size_t leaf_nodes(); // Return number of leaf nodes by calling the private recursive function.
// BET private helper functions (Must be implemented recursively)
private:
void printInfixExpression(BinaryNode *n); // Print infix to std output.
void makeEmpty(BinaryNode* &t); // Delete all nodes in the subtree pointed to by t.
BinaryNode * clone(BinaryNode *t); // Clone all nodes in the subtree pointed to by t.
void printPostfixExpression(BinaryNode *n); // Print postfix to std output.
size_t size(BinaryNode *t); // Return the number of nodes in the subtree pointed to by t.
size_t leaf_nodes(BinaryNode *t); // Return the number of lead nodes in the subtree pointed to by t.
// BET attributes
BinaryNode * root;
};
#include "BET.hpp"
#endif | [
"noreply@github.com"
] | ChristelleNieves.noreply@github.com |
1c047a5963d4b3888b5f6fbb96a19f79c4a828be | 4feb898677e53120ada56f82ddad9165f6553f3d | /reference-gui/src/ColumnChooser.h | 2d0bc23ae9ca59995dd93157d492c4e93e2c99f7 | [] | no_license | ifaoe/daisi-gui | 0b2567a43787fdca6ba522ba9cabe939f0859cd0 | c786a460cd1c422e39b055c962d9deb3c3639f31 | refs/heads/master | 2020-04-15T15:02:57.202263 | 2016-06-03T08:25:53 | 2016-06-03T08:25:53 | 44,369,004 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 878 | h | /*
* ColumnChooser.h
*
* Created on: Aug 13, 2015
* Author: awg
*/
#ifndef SRC_COLUMNCHOOSER_H_
#define SRC_COLUMNCHOOSER_H_
#include <qdialog.h>
#include "UserSettings.h"
#include <QDialogButtonBox>
#include <QButtonGroup>
#include <QLayout>
class ColumnChooser: public QDialog {
Q_OBJECT
public:
ColumnChooser(UserSettings * config, QWidget * parent =0);
virtual ~ColumnChooser();
void addColumn(QString text, QString column_name);
private:
// Ui::ColumnOptions * ui;
UserSettings * config;
QWidget * main_widget;
QWidget * column_widget;
QVBoxLayout * vertical_layout;
QGridLayout * column_layout;
QButtonGroup * column_boxes;
QDialogButtonBox * button_box;
int max_rows = 10;
int current_row = 0;
int current_column = 0;
private slots:
void onAccept();
void onReject();
};
#endif /* SRC_COLUMNCHOOSER_H_ */
| [
"a.wegener@ifaoe.de"
] | a.wegener@ifaoe.de |
7f0a6ed3e3c11fc875b26b4ca54ea82547f9269a | e72026242a7d4bfc8d2d0e8e03c7303c77ed3746 | /BinaryMeshFitting/ChunkBlocks.hpp | 5d71eb179ddc7a06e281021b003a4931e32ec058 | [
"MIT"
] | permissive | torss/BinaryMeshFitting | a732c52de93704b1697dbb38d64917e67c0ed78a | d44ee7c995d461ae704f6da83f2a0b96c3957580 | refs/heads/master | 2021-09-12T20:22:34.247830 | 2018-04-20T16:58:58 | 2018-04-20T16:58:58 | 124,610,750 | 0 | 0 | MIT | 2018-03-10T15:00:11 | 2018-03-10T01:22:35 | C++ | UTF-8 | C++ | false | false | 3,473 | hpp | #pragma once
#include <cstdint>
#include <string>
#include <FastNoiseSIMD.h>
#include "LinkedNode.hpp"
#include "Vertices.hpp"
struct BinaryBlock : public LinkedNode<BinaryBlock>
{
uint32_t size;
uint32_t* data;
bool initialized;
inline BinaryBlock()
{
initialized = false;
size = 0;
data = 0;
}
inline ~BinaryBlock()
{
_aligned_free(data);
size = 0;
initialized = false;
}
void init(uint32_t _raw_size, uint32_t _binary_size)
{
if (initialized)
return;
_aligned_free(data);
data = (uint32_t*)_aligned_malloc(sizeof(uint32_t) * _binary_size, 16);
initialized = true;
}
};
struct DensityBlock : public LinkedNode<DensityBlock>
{
uint32_t size;
float* data;
bool initialized;
inline DensityBlock()
{
initialized = false;
size = 0;
data = 0;
}
inline ~DensityBlock()
{
_aligned_free(data);
size = 0;
initialized = false;
}
void init(uint32_t _size)
{
if (initialized)
return;
_aligned_free(data);
data = (float*)_aligned_malloc(sizeof(float) * _size, 16);
initialized = true;
}
};
struct IsoVertexBlock : public LinkedNode<IsoVertexBlock>
{
uint32_t size;
DMC_Isovertex* data;
bool initialized;
inline IsoVertexBlock()
{
initialized = false;
size = 0;
data = 0;
}
inline ~IsoVertexBlock()
{
_aligned_free(data);
size = 0;
initialized = false;
}
void init(uint32_t _size)
{
if (initialized)
return;
_aligned_free(data);
data = (DMC_Isovertex*)_aligned_malloc(sizeof(DMC_Isovertex) * _size, 16);
initialized = true;
}
};
struct NoiseBlock : public LinkedNode<NoiseBlock>
{
uint32_t size;
float* dest_noise;
FastNoiseVectorSet vectorset;
bool initialized;
inline NoiseBlock()
{
initialized = false;
size = 0;
dest_noise = 0;
}
inline ~NoiseBlock()
{
_aligned_free(dest_noise);
size = 0;
initialized = false;
}
void init(uint32_t noise_size)
{
if (initialized)
return;
_aligned_free(dest_noise);
dest_noise = (float*)_aligned_malloc(sizeof(float) * noise_size, 16);
vectorset.SetSize(noise_size);
initialized = true;
}
};
struct MasksBlock : public LinkedNode<MasksBlock>
{
uint32_t size;
uint64_t* data;
bool initialized;
inline MasksBlock()
{
initialized = false;
size = 0;
data = 0;
}
inline ~MasksBlock()
{
_aligned_free(data);
size = 0;
initialized = false;
}
void init(uint32_t _size)
{
if (initialized)
return;
_aligned_free(data);
data = (uint64_t*)_aligned_malloc(sizeof(uint64_t) * _size, 16);
initialized = true;
}
};
struct VerticesIndicesBlock : public LinkedNode<VerticesIndicesBlock>
{
SmartContainer<DualVertex> vertices;
SmartContainer<uint32_t> mesh_indexes;
inline VerticesIndicesBlock()
{
}
inline ~VerticesIndicesBlock()
{
}
void init()
{
vertices.count = 0;
mesh_indexes.count = 0;
}
};
struct IndexesBlock : public LinkedNode<IndexesBlock>
{
uint32_t size;
uint32_t* inds;
bool initialized;
inline IndexesBlock()
{
initialized = false;
size = 0;
inds = 0;
}
inline ~IndexesBlock()
{
_aligned_free(inds);
size = 0;
initialized = false;
}
void init(uint32_t size)
{
if (initialized)
return;
_aligned_free(inds);
inds = (uint32_t*)_aligned_malloc(sizeof(uint32_t) * size, 16);
initialized = true;
}
};
struct DMC_CellsBlock : public LinkedNode<DMC_CellsBlock>
{
SmartContainer<DMC_Cell> cells;
inline DMC_CellsBlock()
{
}
inline ~DMC_CellsBlock()
{
}
void init()
{
cells.count = 0;
}
};
| [
"charliejennings2@hotmail.com"
] | charliejennings2@hotmail.com |
fd84c2a3b383bc02462e037b9b41b5767e4f144e | 316f02ec85e3be5f231579db1536e9dfd59ddf34 | /lSource.cpp | 1ae09cfe3ec3ccf9091c0231fae55f7f9986f2df | [] | no_license | Kirill12043/Practic | cfe574eaf717068907175810b38f07d53c21ec92 | 2a3c1eeddcd373dfae9fd4ff4bf6baa743825953 | refs/heads/master | 2020-06-13T22:37:26.773269 | 2019-07-03T19:24:18 | 2019-07-03T19:24:18 | 194,810,466 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,109 | cpp | #include <stdio.h>
#include <iostream>
#include <fstream>
#include <chrono>
#include <ctime>
#include "opencv2/core.hpp"
#include "opencv2/features2d.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/imgproc.hpp"
using namespace cv;
using namespace std;
void my_mouse_callback(int event, int x, int y, int flags, void* param);
int reading();
int main() {
/*Mat image = imread("map.jpg");
namedWindow("maps");
setMouseCallback("maps", my_mouse_callback, &image );
while(true){
imshow("maps",image);
waitKey(1);}*/
reading();
return(0);
}
void my_mouse_callback(int event, int x, int y, int flags, void* param)
{
if (event == EVENT_LBUTTONDOWN)
{
Mat* pImage = (Mat*)param;
Mat image = *pImage;
circle(image, Point(x, y), 20, Scalar(0xff, 0xff, 0xff));
ofstream file;
file.open("coordinat.txt", ios_base::app);
unsigned long milliseconds_since_epoch = std::chrono::system_clock::now().time_since_epoch() / std::chrono::milliseconds(1);
file << milliseconds_since_epoch << " " << x << " " << y << endl;
file.close();
}
} | [
"noreply@github.com"
] | Kirill12043.noreply@github.com |
61e9d6db5a5e7d91352b405f77091f1d5025f444 | e68c1f9134b44ddea144f7efa7523076f3f12d3a | /FinalCode/Skeleton_King_Whirlwind_Loop.cpp | e065496cdc91d1012964b4a5c610d0aa1710d114 | [] | no_license | iso5930/Direct-3D-Team-Portfolio | 4ac710ede0c9176702595cba5579af42887611cf | 84e64eb4e91c7e5b4aed77212cd08cfee038fcd3 | refs/heads/master | 2021-08-23T08:15:00.128591 | 2017-12-04T06:14:39 | 2017-12-04T06:14:39 | 112,998,717 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,303 | cpp | #include "StdAfx.h"
#include "Skeleton_King_Whirlwind_Loop.h"
CSkeleton_King_Whirlwind_Loop::CSkeleton_King_Whirlwind_Loop(void)
{
// StateType
m_eStateType = STATE_TYPE_SKELETON_KING_WHIRLWIND_LOOP;
// Mode
m_iMode = 0;
// Time
m_fTime = 0.0f;
// Effect
m_iEffect = 0;
}
CSkeleton_King_Whirlwind_Loop::~CSkeleton_King_Whirlwind_Loop(void)
{
}
void CSkeleton_King_Whirlwind_Loop::Initialize()
{
CMonsterState::Initialize();
// SetAnimation
m_pOwner->SetAnimation(4);
// Player
CObject* pPlayer = NULL;
m_pOwner->GetLayer()->FindObject(pPlayer, _T("Player"), LAYER_TYPE_PLAYER);
if(pPlayer == NULL)
return;
// PlayerTransformCom
CTransformCom* pPlayerTransformCom = (CTransformCom*)pPlayer->GetComponent(COM_TYPE_TRANSFORM);
if(D3DXVec3Length(&(pPlayerTransformCom->m_vPos - m_pTransformCom->m_vPos)) >= 100.0f)
m_pPathFindCom->Enable();
}
CMonsterState* CSkeleton_King_Whirlwind_Loop::Action()
{
if(m_iEffect == 0)
{
//CSkeletonKing_CenterTrail* pCenterTrail = new CSkeletonKing_CenterTrail(NULL, OBJ_TYPE_DYNAMIC, m_pOwner);
//m_pOwner->GetLayer()->AddObject(pCenterTrail, LAYER_TYPE_EFFECT);
//CTransformCom* pTransformCom = (CTransformCom*)pCenterTrail->GetComponent(COM_TYPE_TRANSFORM);
//D3DXVec3TransformCoord(&pTransformCom->m_vPos, &pTransformCom->m_vPos, &((CSkeleton_King*)m_pOwner)->m_CenterBone.mWorld);
//pTransformCom->m_vAngle = m_pTransformCom->m_vAngle;
//pCenterTrail->Initialize();
//pCenterTrail = new CSkeletonKing_CenterTrail(NULL, OBJ_TYPE_DYNAMIC, m_pOwner);
//m_pOwner->GetLayer()->AddObject(pCenterTrail, LAYER_TYPE_EFFECT);
//pTransformCom = (CTransformCom*)pCenterTrail->GetComponent(COM_TYPE_TRANSFORM);
//D3DXVec3TransformCoord(&pTransformCom->m_vPos, &pTransformCom->m_vPos, &((CSkeleton_King*)m_pOwner)->m_CenterBone.mWorld);
//pTransformCom->m_vAngle = -m_pTransformCom->m_vAngle;
//pCenterTrail->Initialize();
m_iEffect = 1;
}
if(m_iEffect == 1 && m_pAnimController->GetTrackPos() > 0.654f)
{
CSkeletonKing_WeaponTrail* pWeaponTrail = new CSkeletonKing_WeaponTrail(NULL, OBJ_TYPE_DYNAMIC, m_pOwner);
m_pOwner->GetLayer()->AddObject(pWeaponTrail, LAYER_TYPE_EFFECT);
CTransformCom* pTransformCom = (CTransformCom*)pWeaponTrail->GetComponent(COM_TYPE_TRANSFORM);
D3DXVec3TransformCoord(&pTransformCom->m_vPos, &pTransformCom->m_vPos, &((CSkeleton_King*)m_pOwner)->m_CenterTopBone.mWorld);
pTransformCom->m_vAngle = m_pTransformCom->m_vAngle;
pWeaponTrail->Initialize();
m_iEffect = 2;
}
if(m_iEffect == 2 && m_pAnimController->GetTrackPos() > 1.515f)
{
CSkeletonKing_WeaponTrail* pWeaponTrail = new CSkeletonKing_WeaponTrail(NULL, OBJ_TYPE_DYNAMIC, m_pOwner);
m_pOwner->GetLayer()->AddObject(pWeaponTrail, LAYER_TYPE_EFFECT);
CTransformCom* pTransformCom = (CTransformCom*)pWeaponTrail->GetComponent(COM_TYPE_TRANSFORM);
D3DXVec3TransformCoord(&pTransformCom->m_vPos, &pTransformCom->m_vPos, &((CSkeleton_King*)m_pOwner)->m_CenterTopBone.mWorld);
pTransformCom->m_vAngle = m_pTransformCom->m_vAngle;
pWeaponTrail->Initialize();
m_iEffect = 3;
}
if(m_pAnimController->m_dFrameTime - 0.25 <= m_pAnimController->GetTrackPos())
return new CSkeleton_King_Whirlwind_End;
switch(m_iMode)
{
case 0:
return Mode0();
case 1:
return Mode1();
case 2:
return Mode2();
case 3:
return Mode3();
}
return NULL;
}
CMonsterState* CSkeleton_King_Whirlwind_Loop::Mode0()
{
// Player
CObject* pPlayer = NULL;
m_pOwner->GetLayer()->FindObject(pPlayer, _T("Player"), LAYER_TYPE_PLAYER);
if(pPlayer == NULL)
return NULL;
// PlayerTransformCom
CTransformCom* pPlayerTransformCom = (CTransformCom*)pPlayer->GetComponent(COM_TYPE_TRANSFORM);
D3DXVECTOR3 vDir = pPlayerTransformCom->m_vPos - m_pTransformCom->m_vPos;
vDir.y = 0.0f;
D3DXVec3Normalize(&vDir, &vDir);
D3DXVECTOR3 vMovePos = m_pTransformCom->m_vPos + (vDir * 80);
m_pPathFindCom->Move(&vMovePos);
vDir = pPlayerTransformCom->m_vPos - m_pTransformCom->m_vPos;
if(!Equals(vDir.x, 0.0f, MIN_EPSILON) || !Equals(vDir.z, 0.0f, MIN_EPSILON))
{
// Normalize
vDir.y = 0.0f;
D3DXVec3Normalize(&vDir, &vDir);
// DotX
float fDotX = D3DXVec3Dot(&-m_pTransformCom->m_vAxisX, &vDir);
fDotX = RevisionDot(fDotX);
// DotZ
float fDotZ = D3DXVec3Dot(&-m_pTransformCom->m_vAxisZ, &vDir);
fDotZ = RevisionDot(fDotZ);
if(fDotX > 0.0f)
m_pTransformCom->m_vAngle.y += acosf(fDotZ);
else
m_pTransformCom->m_vAngle.y -= acosf(fDotZ);
}
m_fTime += CTimeMgr::GetInstance()->GetDeltaTime();
if(m_fTime > 0.0f)
{
m_pOwner->CreateAttack();
m_fTime = 0.0f;
++m_iMode;
}
return NULL;
}
CMonsterState* CSkeleton_King_Whirlwind_Loop::Mode1()
{
m_fTime += CTimeMgr::GetInstance()->GetDeltaTime();
if(m_fTime > 0.9f)
{
m_pOwner->RemoveAttack();
m_fTime = 0.0f;
++m_iMode;
}
return NULL;
}
CMonsterState* CSkeleton_King_Whirlwind_Loop::Mode2()
{
// Player
CObject* pPlayer = NULL;
m_pOwner->GetLayer()->FindObject(pPlayer, _T("Player"), LAYER_TYPE_PLAYER);
if(pPlayer == NULL)
return NULL;
// PlayerTransformCom
CTransformCom* pPlayerTransformCom = (CTransformCom*)pPlayer->GetComponent(COM_TYPE_TRANSFORM);
D3DXVECTOR3 vDir = pPlayerTransformCom->m_vPos - m_pTransformCom->m_vPos;
vDir.y = 0.0f;
D3DXVec3Normalize(&vDir, &vDir);
D3DXVECTOR3 vMovePos = m_pTransformCom->m_vPos + (vDir * 80);
m_pPathFindCom->Move(&vMovePos);
vDir = pPlayerTransformCom->m_vPos - m_pTransformCom->m_vPos;
if(!Equals(vDir.x, 0.0f, MIN_EPSILON) || !Equals(vDir.z, 0.0f, MIN_EPSILON))
{
// Normalize
vDir.y = 0.0f;
D3DXVec3Normalize(&vDir, &vDir);
// DotX
float fDotX = D3DXVec3Dot(&-m_pTransformCom->m_vAxisX, &vDir);
fDotX = RevisionDot(fDotX);
// DotZ
float fDotZ = D3DXVec3Dot(&-m_pTransformCom->m_vAxisZ, &vDir);
fDotZ = RevisionDot(fDotZ);
if(fDotX > 0.0f)
m_pTransformCom->m_vAngle.y += acosf(fDotZ);
else
m_pTransformCom->m_vAngle.y -= acosf(fDotZ);
}
m_fTime += CTimeMgr::GetInstance()->GetDeltaTime();
if(m_fTime > 0.0f)
{
m_pOwner->CreateAttack();
m_fTime = 0.0f;
++m_iMode;
}
return NULL;
}
CMonsterState* CSkeleton_King_Whirlwind_Loop::Mode3()
{
m_fTime += CTimeMgr::GetInstance()->GetDeltaTime();
if(m_fTime > 0.7f)
{
m_pOwner->RemoveAttack();
m_fTime = 0.0f;
++m_iMode;
}
return NULL;
}
| [
"iso5930@naver.com"
] | iso5930@naver.com |
cde91a16fe74e5f31eb12c5fcd7c76393ed2fed3 | 0d610860a4a4106c48fd6c0350d48b29a919db41 | /classic/caseIdoNotUnderstand/chigua/constant/turbulenceProperties | a472f0163841cf276bc24f1037c778a60e474588 | [] | no_license | randomwangran/CMP | 8fd722f941634e146a5b1a98557c760c4200838a | e4f742c9099aae47f448fa8c57059071a0be35e6 | refs/heads/master | 2022-08-28T01:40:55.988534 | 2020-05-21T21:34:14 | 2020-05-21T21:34:14 | 163,246,681 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,260 |
/*--------------------------------*- C++ -*----------------------------------*\ | ========= | | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | | \\ / O peration | Version: 5 | | \\ / A nd | Web: www.OpenFOAM.org | | \\/ M anipulation | | \*---------------------------------------------------------------------------*/ FoamFile { version 2.0; format ascii; class dictionary; location "constant"; object turbulenceProperties; } // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // simulationType LES; LES { LESModel kEqn; //dynamicKEqn; turbulence on; printCoeffs on; delta cubeRootVol; // kEqnCoeffs //dynamicKEqnCoeffs //{ // filter simple; // } cubeRootVolCoeffs { deltaCoeff 1; } PrandtlCoeffs { delta cubeRootVol; cubeRootVolCoeffs { deltaCoeff 1; } smoothCoeffs { delta cubeRootVol; cubeRootVolCoeffs { deltaCoeff 1; } maxDeltaRatio 1.1; } Cdelta 0.158; } vanDriestCoeffs { delta cubeRootVol; cubeRootVolCoeffs { deltaCoeff 1; } smoothCoeffs { delta cubeRootVol; cubeRootVolCoeffs { deltaCoeff 1; } maxDeltaRatio 1.1; } Aplus 26; Cdelta 0.158; } smoothCoeffs { delta cubeRootVol; cubeRootVolCoeffs { deltaCoeff 1; } maxDeltaRatio 1.1; } } // ************************************************************************* //
| [
"randombazinga@gmail.com"
] | randombazinga@gmail.com | |
7443b643e8307198bba71349b5c1dc1b13988f68 | 07fe910f4a2c7d14e67db40ab88a8c91d9406857 | /game/t3/compiler/Reference_Node.inl | 6c17b9576e49204437ddd19d64f90cc08381afa0 | [] | no_license | SEDS/GAME | e6d7f7a8bb034e421842007614d306b3a6321fde | 3e4621298624b9189b5b6b43ff002306fde23f08 | refs/heads/master | 2021-03-12T23:27:39.115003 | 2015-09-22T15:05:33 | 2015-09-22T15:05:33 | 20,278,561 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 193 | inl | // -*- C++ -*-
// $Id$
//
// T3_Reference_Node
//
inline
T3_Reference_Node::T3_Reference_Node (void)
{
}
//
// ~T3_Reference_Node
//
inline
T3_Reference_Node::~T3_Reference_Node (void)
{
}
| [
"hillj@cs.iupui.edu"
] | hillj@cs.iupui.edu |
d2be48ff11ff0bab75befc5c30ca32caf2a16c68 | 8973dd51588517ac8755230820e97b8215cadc92 | /cores/Cosa/api/Cosa/Canvas/Font/Segment32x50.cpp | ad3da523a8c271b0594f1c170a0dbffa664a8181 | [
"BSD-3-Clause"
] | permissive | UECIDE/UECIDE_data | 3fa6b17113743de7bcb7d3cb8d430637efb494b6 | 96bf6b15910ec3794bd7c13e5274e5ac03379aa9 | refs/heads/master | 2016-09-06T17:38:44.223404 | 2014-02-15T00:48:46 | 2014-02-15T00:48:46 | 13,354,806 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 12,137 | cpp | /**
* @file Cosa/Canvas/Font/Segment32x50.cpp
* @version 1.0
*
* @section License
* Copyright (C) 2012-2013, Mikael Patel
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA
*
* This file is part of the Arduino Che Cosa project.
*/
#include "Cosa/Canvas/Font/Segment32x50.hh"
Segment32x50 segment32x50;
const uint8_t Segment32x50::bitmap[] __PROGMEM = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFE,0x00,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x60,0x0C,0xFF,0xFE,0xF0,0x1E,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3E,0x00,0x00,0x78,0x38,0x00,0x00,0x18,0x20,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x38,0x00,0x00,0x18,0x3E,0x00,0x00,0x78,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x1E,0x00,0x00,0xF0,0x0C,0xFF,0xFE,0x60,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x00,0x00,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 0
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0xF0,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x00,0x78,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x78,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x00,0xF0,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 1
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFE,0x00,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x60,0x00,0xFF,0xFE,0xF0,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x00,0x78,0x01,0xFF,0xFE,0x18,0x03,0xFF,0xFF,0x88,0x0F,0xFF,0xFF,0xE0,0x27,0xFF,0xFF,0xC0,0x39,0xFF,0xFF,0x00,0x3E,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x1E,0x00,0x00,0x00,0x0C,0xFF,0xFE,0x00,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x00,0x00,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 2
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFE,0x00,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x60,0x00,0xFF,0xFE,0xF0,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x00,0x78,0x01,0xFF,0xFE,0x18,0x03,0xFF,0xFF,0x88,0x0F,0xFF,0xFF,0xE0,0x07,0xFF,0xFF,0xC0,0x01,0xFF,0xFF,0x18,0x00,0x00,0x00,0x78,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x00,0xF0,0x00,0xFF,0xFE,0x60,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x00,0x00,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 3
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x60,0x0C,0x00,0x00,0xF0,0x1E,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3E,0x00,0x00,0x78,0x39,0xFF,0xFE,0x18,0x23,0xFF,0xFF,0x88,0x0F,0xFF,0xFF,0xE0,0x07,0xFF,0xFF,0xC0,0x01,0xFF,0xFF,0x18,0x00,0x00,0x00,0x78,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x00,0xF0,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 4
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFE,0x00,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x00,0x0C,0xFF,0xFE,0x00,0x1E,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x39,0xFF,0xFE,0x00,0x23,0xFF,0xFF,0x80,0x0F,0xFF,0xFF,0xE0,0x07,0xFF,0xFF,0xC0,0x01,0xFF,0xFF,0x18,0x00,0x00,0x00,0x78,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x00,0xF0,0x00,0xFF,0xFE,0x60,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x00,0x00,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 5
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFE,0x00,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x00,0x0C,0xFF,0xFE,0x00,0x1E,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x3E,0x00,0x00,0x00,0x39,0xFF,0xFE,0x00,0x23,0xFF,0xFF,0x80,0x0F,0xFF,0xFF,0xE0,0x27,0xFF,0xFF,0xC0,0x39,0xFF,0xFF,0x18,0x3E,0x00,0x00,0x78,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x1E,0x00,0x00,0xF0,0x0C,0xFF,0xFE,0x60,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x00,0x00,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 6
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFE,0x00,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x60,0x00,0xFF,0xFE,0xF0,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x00,0x78,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x08,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x78,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x00,0xF0,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 7
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFE,0x00,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x60,0x0C,0xFF,0xFE,0xF0,0x1E,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3E,0x00,0x00,0x78,0x39,0xFF,0xFE,0x18,0x23,0xFF,0xFF,0x88,0x0F,0xFF,0xFF,0xE0,0x27,0xFF,0xFF,0xC0,0x39,0xFF,0xFF,0x18,0x3E,0x00,0x00,0x78,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x1E,0x00,0x00,0xF0,0x0C,0xFF,0xFE,0x60,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x00,0x00,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 8
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFE,0x00,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x60,0x0C,0xFF,0xFE,0xF0,0x1E,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3F,0x00,0x01,0xF8,0x3E,0x00,0x00,0x78,0x39,0xFF,0xFE,0x18,0x23,0xFF,0xFF,0x88,0x0F,0xFF,0xFF,0xE0,0x07,0xFF,0xFF,0xC0,0x01,0xFF,0xFF,0x18,0x00,0x00,0x00,0x78,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x01,0xF8,0x00,0x00,0x00,0xF0,0x00,0xFF,0xFE,0x60,0x01,0xFF,0xFF,0x00,0x03,0xFF,0xFF,0x80,0x01,0xFF,0xFF,0x00,0x00,0xFF,0xFE,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // 9
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0x00,0x00,0x01,0xF0,0x00,0x00,0x03,0xF8,0x00,0x00,0x03,0xF8,0x00,0x00,0x03,0xF8,0x00,0x00,0x01,0xF0,0x00,0x00,0x00,0xE0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xE0,0x00,0x00,0x01,0xF0,0x00,0x00,0x03,0xF8,0x00,0x00,0x03,0xF8,0x00,0x00,0x03,0xF8,0x00,0x00,0x01,0xF0,0x00,0x00,0x00,0xE0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, // :
};
| [
"matt@majenko.co.uk"
] | matt@majenko.co.uk |
c6052237bad61f88e348143303b20680ae189e08 | 502f2ff4dddc707b2ced51e3cd4058b5ad8f1502 | /UVA/871_counting_cells_in_a_blob.cpp | 72128f184f14a31339dd3854b830695cb42f210d | [] | no_license | miguelAlessandro/CompetitiveProgramming | 609a68a646f0976ed1c00fbcf861777844c7040d | 64ac15eafb9c62dc713ce3d4b679ba6a032e1d5f | refs/heads/master | 2021-06-01T11:02:22.439109 | 2020-10-08T06:26:27 | 2020-10-08T06:26:27 | 51,873,676 | 1 | 1 | null | 2020-10-08T06:26:28 | 2016-02-16T22:01:20 | C++ | UTF-8 | C++ | false | false | 4,107 | cpp | #include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <vector>
#include <list>
#include <map>
#include <complex>
#include <utility>
#include <iterator>
#include <sstream>
#include <string>
#include <cstring>
#include <cctype>
#include <cmath>
#include <queue>
#include <stack>
#include <set>
#include <bitset>
#include <unordered_map> //c++11
#include <unordered_set> //c++11
#define f(x, y, z) for(int x = y; x < (int)z; ++x)
#define fd(x, y, z) for(int x = y; x >= (int)z; --x)
#define fa(X, it) for(auto& it : X) //c++11
#define fe(x, y, z) for(int x = y; x <= (int)z; ++x)
#define FOR(A, it) for(typeof A.begin() it = A.begin(); it != A.end(); ++it)
#define CFOR(A, it) for(typeof A.cbegin() it = A.cbegin(); it != A.cend(); ++it) //c++11
#define RFOR(A, it) for(typeof A.rbegin(); it = A.rbegin(); it != A.rend(); ++it)
#define CRFOR(A, it) for(typeof A.crbegin() it = A.crbegin(); it != A.crend(); ++it) //c++11
#define all(V) V.begin(), V.end()
#define rall(V) V.rbegin(), V.rend()
#define UNIQUE(V) (V).resize(unique(all(V)) - (V).begin())
#define sz(A) int((A).size())
#define present(A, x) ((A).find(x) != (A).end())
#define cpresent(A, x) (find(all(A), x) != (A).end())
#define pb push_back
#define pf push_front
#define mp make_pair
#define fst first
#define snd second
//to memset
#define MAX_INFINITE 0x7f
#define MINUS_INFINITE 0x80
#define HALF_INFINITE 0x3f
#define INFINITE 0x2d
#define FAST_INFINITE 0x01
#define ones(X) __builtin_popcount(X)
#define NOsync ios_base::sync_with_stdio(0)
#define cua(X) ((X)*(X))
#define debug(X) cout << #X << " = " << X << endl;
#define Adebug(X, n) cout << #X << endl; f(i, 0, n) cout << X[i] << " \n"[i+1==n] //c++11
#define Mdebug(X, m, n) cout << #X << endl; f(i, 0, m) f(j, 0, n) cout << X[i][j] << " \n"[j+1==n] //c++11
#define clr(A, x) memset(A, x, sizeof A)
#define citor const_iterator //c++11
#define critor const_reverse_iterator //c++11
#define ritor reverse_iterator
using namespace::std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef map<int, int> mii;
typedef unordered_map<int, int> umii;
typedef map<string, int> msi;
typedef unordered_map<string, int> umsi;
typedef vector<ii> vii;
typedef pair<int, ii> iii;
typedef priority_queue<iii> pqiii;
typedef complex<double> point;
const int N = 30;
const double eps = (1e-9);
const double pi = 2.0f*acos(0.0f);
const int oo = (1 << 30);
const ll OO = (1LL << 60);
template<typename T> inline void MAXI(T& a, T b){if(a > b) a=b;}
template<typename T> inline void MINI(T& a, T b){if(a < b) a=b;}
int t, n, m, times, r,
dx[8] = {1, 1, 0, -1, -1, -1, 0, 1},
dy[8] = {0, -1, -1, -1, 0, 1, 1, 1};
bool M[N][N], visit[N][N];
char A[N];
void dfs(int s1, int s2){
visit[s1][s2] = true; ++times;
f(i, 0, 8){
int a = s1 + dy[i], b = s2 + dx[i];
if(a >= 0 && a < m && b >= 0 && b < n && M[a][b] && !visit[a][b])
dfs(a, b);
}
}
int main(){
scanf("%d%*c", &t);
fgets(A, N, stdin);
while(t--){
m = 0;
while(fgets(A, N, stdin) != NULL && A[1] != '\0'){
n=0;
for(; A[n] != '\0' && A[n] != ' '; ++n)
M[m][n] = bool(A[n] == '1');
m++;
}
r = 0;
f(i, 0, m)
f(j, 0, n)
if(M[i][j] && !visit[i][j])
{
times = 0;
dfs(i, j);
r = max(r, times);
}
printf("%d\n", r);
if(t) puts("");
clr(visit, 0x0);
}
return 0;
}
| [
"mminih@uni.pe"
] | mminih@uni.pe |
f9170118025b73fbb42c3decec0744b0eef92960 | 071860b148295683c995a488c195908f7499579d | /chapter_5/futures/basic_futures.cpp | 5542ddcfd477767c6428d9e5a318145947bbb97a | [] | no_license | ChadMcintire/Masteringmultithreading | 3c35428b756ab8d12da007cdb3be2153b4884003 | d22d1d9fb287b779de5e34c7ec9ba16e7dcdc058 | refs/heads/main | 2023-03-02T00:51:16.812248 | 2021-02-09T01:39:16 | 2021-02-09T01:39:16 | 332,611,683 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 579 | cpp | #include <iostream>
#include <future>
#include <chrono>
bool is_prime (int x) {
for (int i = 2; i < x; ++i){
if (x%i==0){
return false;
}
return true;
}
}
int main() {
std::future<bool> fut = std::async (is_prime, 444444443);
std::cout << "Checking, please wait\n";
std::chrono::milliseconds span(100);
while (fut.wait_for(span) == std::future_status::timeout) {
std::cout << '.' << std::flush;
}
bool x = fut.get();
std::cout << "\n444444443 " << (x?"is":"is not") << " prime.\n";
return 0;
}
| [
"chadmcintirecloud@gmail.com"
] | chadmcintirecloud@gmail.com |
9f58cce8f2bd4a7463e0a1ce3634d6bcd74f12c5 | 76beaa7e67f69cbf469a14bea1a756bc289ba0e0 | /latihan3/latihan3.cpp | 4e4ce06966dd3943cd47c3452491473ef44862fd | [] | no_license | raizafahra/praktikum7 | 3fd140643fddf19c4bd7205bcd9f3579c4633e4b | f8fa0a381e8e45b921543ff66d2903a669fa2890 | refs/heads/master | 2020-04-10T10:52:27.147228 | 2018-12-08T21:26:18 | 2018-12-08T21:26:18 | 160,978,246 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 255 | cpp | #include<iostream>
#include<string.h>
using namespace std;
void balik(char *s)
{
if (*s != '\0'){
balik(&s[1]);
cout << s[0];
}
}
int main()
{
char* kata = (char*) "raiza";
balik(kata);
cout << endl;
return 0;
}
| [
"raizafahra@mhs.pelitabangsa.ac.id"
] | raizafahra@mhs.pelitabangsa.ac.id |
259cebb373d0b7a889d6c3b37a582191891efd0e | 412d5bba3d728a81314ef5b8238e4ac90ed27ec9 | /engine/runtime/render_b/src/sys/d3d/d3ddrawprim.cpp | 45a8eaf80ce0bd4be94cd9d618df30fc16c1586a | [] | no_license | DrItanium/ltjs | 2684fdc3f6bde3526d0d72083a0869a7d5bfc6f4 | 15fa9599368dd46774eb9ecacf8951e30b429a82 | refs/heads/master | 2020-06-13T05:03:25.753873 | 2015-08-01T18:51:05 | 2015-08-01T18:51:05 | 75,443,663 | 0 | 0 | null | 2016-12-03T01:20:23 | 2016-12-03T01:20:23 | null | UTF-8 | C++ | false | false | 79,112 | cpp | //------------------------------------------------------------------
//
// MODULE : D3DDRAWPRIM.CPP
//
// PURPOSE : Implements interface CD3DDrawPrim
//
// CREATED : On 8/11/00 At 2:06:07 PM
//
// COPYRIGHT : (C) 2000 LithTech Inc
//
//------------------------------------------------------------------
// Includes....
#include "bdefs.h"
//IClientShell game client shell object.
#include "iclientshell.h"
static IClientShell *i_client_shell;
define_holder(IClientShell, i_client_shell);
#include "d3ddrawprim.h"
#include "d3d_draw.h"
#include "d3d_viewparams.h"
#include "common_draw.h"
#include "lteffectimpl.h"
#include "lteffectshadermgr.h"
#include "ltshaderdevicestateimp.h"
#include "rendererconsolevars.h"
#ifndef __ILTTEXINTERFACE_H__
#include "ilttexinterface.h"
#endif
static ILTTexInterface *pTexInterface;
define_holder(ILTTexInterface, pTexInterface);
// EXTERNS...
extern uint32 g_ScreenWidth;
extern uint32 g_ScreenHeight;
// Note : This is an evil hack so we can get access to the most recent near/farz
extern ViewParams g_ViewParams;
//Not a fan of this, but it makes the code below much easier to read.
#define EFFECT_SHADER_MACRO(result, primcall)\
LTEffectImpl* pEffectShader = (LTEffectImpl*)LTEffectShaderMgr::GetSingleton().GetEffectShader(m_nEffectShaderID);\
if(pEffectShader)\
{\
ID3DXEffect* pD3DEffect = pEffectShader->GetEffect();\
if(pD3DEffect)\
{\
i_client_shell->OnEffectShaderSetParams(pEffectShader, NULL, NULL, LTShaderDeviceStateImp::GetSingleton());\
UINT nPasses = 0;\
pD3DEffect->Begin(&nPasses, 0);\
for(UINT i = 0; i < nPasses; ++i)\
{\
pD3DEffect->BeginPass(i);\
result = primcall;\
pD3DEffect->EndPass();\
}\
pD3DEffect->End();\
}\
}\
else\
{\
result = primcall;\
}\
//------------------------------------------------------------------------------
//Utility classes
//CAutoDrawPrimBlock
//
// class to automatically handle beginning and ending a draw primitive block.
// this is intended for use inside of draw primitive functions so that the
// block doesn't have to be ended in every single return branch. It will begin
// the block in the constructor, and end it in the destructor
class CAutoDrawPrimBlock
{
public:
CAutoDrawPrimBlock(ILTDrawPrim* pDrawPrim) :
m_pDrawPrim(pDrawPrim)
{
//make sure that we have a valid draw primitive
assert(m_pDrawPrim && "Invalid construction of CAutoDrawPrimBlock, it must have a valid draw primitive");
//we do, so begin the block
m_pDrawPrim->BeginDrawPrim();
}
~CAutoDrawPrimBlock()
{
//just end the block
m_pDrawPrim->EndDrawPrim();
}
private:
//the draw primitive we are going through
ILTDrawPrim* m_pDrawPrim;
};
//------------------------------------------------------------------------------
// interface database
define_interface(CD3DDrawPrim, ILTDrawPrim);
instantiate_interface(CD3DDrawPrim, ILTDrawPrim, Internal);
//------------------------------------------------------------------------------
//CD3DDrawPrim
CD3DDrawPrim::CD3DDrawPrim() :
m_nBlockCount(0)
{
}
LTRESULT CD3DDrawPrim::BeginDrawPrim()
{
//don't bother pushing them if we are already in a block
if(m_nBlockCount++ > 0)
return LT_OK;
PushRenderStates(r_GetRenderStruct()->GetD3DDevice());
//success
return LT_OK;
}
LTRESULT CD3DDrawPrim::EndDrawPrim()
{
//make sure we can pop
if(m_nBlockCount == 0)
{
//too many pops!
assert(!"Too many calls to EndDrawPrim");
return LT_ERROR;
}
//ok, now we need to see if we are bailing out
if(m_nBlockCount == 1)
{
//we indeed are
PopRenderStates(r_GetRenderStruct()->GetD3DDevice());
}
//decrement our count
m_nBlockCount--;
//success
return LT_OK;
}
//helper macro to aid in the setting of states. This sets the specified variable
//if it is different, and if inside of a draw primitive block, it will call the
//specified function
//
// Note that it always sets the value. For some reason, everything gets completely
// screwed up if it doesn't. Looking into it.
#define SETDRAWPRIMSTATE(Value, SetVal, Func) \
{ \
if((Value) != (SetVal)) \
{ \
(Value) = (SetVal); \
if(m_nBlockCount > 0) \
(Func)(r_GetRenderStruct()->GetD3DDevice()); \
} \
return LT_OK; \
}
// Sets the current camera to use (viewport, field of view etc)
LTRESULT CD3DDrawPrim::SetCamera(const HOBJECT hCamera)
{
SETDRAWPRIMSTATE(m_pCamera, hCamera, SetCamera);
}
//Specifiy whether or not to be in really close space for rendering
LTRESULT CD3DDrawPrim::SetReallyClose(bool bReallyClose)
{
SETDRAWPRIMSTATE(m_bReallyClose, bReallyClose, SetReallyClose);
}
// Sets current texture
LTRESULT CD3DDrawPrim::SetTexture(const HTEXTURE hTexture)
{
SETDRAWPRIMSTATE(m_pTexture, hTexture, SetTexture);
}
// Sets transform type
LTRESULT CD3DDrawPrim::SetTransformType(const ELTTransformType eType)
{
SETDRAWPRIMSTATE(m_eTransType, eType, SetTransformMode);
}
// Sets color operation
LTRESULT CD3DDrawPrim::SetColorOp(const ELTColorOp eColorOp)
{
SETDRAWPRIMSTATE(m_ColorOp, eColorOp, SetColorOp);
}
// Sets source/dest alpha blending operation
LTRESULT CD3DDrawPrim::SetAlphaBlendMode(const ELTBlendMode eBlendMode)
{
SETDRAWPRIMSTATE(m_BlendMode, eBlendMode, SetBlendMode);
}
// Enables/disables z buffering
LTRESULT CD3DDrawPrim::SetZBufferMode(const ELTZBufferMode eZBufferMode)
{
SETDRAWPRIMSTATE(m_eZBufferMode, eZBufferMode, SetZBufferMode);
}
// Set AlphaTest Mode (on/off)
LTRESULT CD3DDrawPrim::SetAlphaTestMode(const ELTTestMode eTestMode)
{
SETDRAWPRIMSTATE(m_eTestMode, eTestMode, SetTestMode);
}
// set the type of clipping to be done
LTRESULT CD3DDrawPrim::SetClipMode(const ELTClipMode eClipMode)
{
SETDRAWPRIMSTATE(m_eClipType, eClipMode, SetClipMode);
}
// set the fill mode
LTRESULT CD3DDrawPrim::SetFillMode(ELTDPFillMode eFillMode)
{
SETDRAWPRIMSTATE(m_eFillMode, eFillMode, SetFillMode);
}
// set the cull mode
LTRESULT CD3DDrawPrim::SetCullMode(ELTDPCullMode eCullMode)
{
SETDRAWPRIMSTATE(m_eCullMode, eCullMode, SetCullMode);
}
// set the fog enable status
LTRESULT CD3DDrawPrim::SetFogEnable(bool bFogEnable)
{
SETDRAWPRIMSTATE(m_bFogEnable, bFogEnable, SetFogEnable);
}
//saves the current D3D state into the member variables
void CD3DDrawPrim::SaveStates(LPDIRECT3DDEVICE9 pDevice)
{
// Save the render states...
pDevice->GetTextureStageState(0,D3DTSS_COLOROP,(unsigned long*)&m_PrevColorOp);
pDevice->GetRenderState(D3DRS_ALPHABLENDENABLE,(unsigned long*)&m_PrevAlphaBlendEnable);
pDevice->GetRenderState(D3DRS_SRCBLEND,(unsigned long*)&m_PrevSrcBlend);
pDevice->GetRenderState(D3DRS_DESTBLEND,(unsigned long*)&m_PrevDstBlend);
pDevice->GetRenderState(D3DRS_ZENABLE,(unsigned long*)&m_PrevZEnable);
pDevice->GetRenderState(D3DRS_ZWRITEENABLE,(unsigned long*)&m_PrevZWriteEnable);
pDevice->GetRenderState(D3DRS_ALPHATESTENABLE,(unsigned long*)&m_PrevAlphaTestEnable);
pDevice->GetRenderState(D3DRS_ALPHAFUNC,(unsigned long*)&m_PrevAlphaTestFunc);
pDevice->GetRenderState(D3DRS_FILLMODE,(unsigned long*)&m_PrevFillMode);
pDevice->GetRenderState(D3DRS_CLIPPING,(unsigned long*)&m_PrevClipMode);
pDevice->GetRenderState(D3DRS_CULLMODE,(unsigned long*)&m_PrevCullMode);
pDevice->GetRenderState(D3DRS_FOGENABLE,(unsigned long*)&m_PrevFogMode);
pDevice->GetTransform(D3DTS_VIEW,&m_PrevTransView);
pDevice->GetTransform(D3DTS_PROJECTION,&m_PrevTransProj);
pDevice->GetViewport(&m_PrevViewport);
m_bResetViewport = false;
}
//sets up the appropriate state for the each section
void CD3DDrawPrim::SetClipMode(LPDIRECT3DDEVICE9 pDevice)
{
switch (m_eClipType)
{
case DRAWPRIM_NOCLIP : pDevice->SetRenderState(D3DRS_CLIPPING,false); break;
case DRAWPRIM_FASTCLIP : pDevice->SetRenderState(D3DRS_CLIPPING,true); break;
case DRAWPRIM_FULLCLIP : pDevice->SetRenderState(D3DRS_CLIPPING,true); break;
default:
assert(false);
break;
}
}
void CD3DDrawPrim::SetTexture(LPDIRECT3DDEVICE9 pDevice)
{
if (m_pTexture)
{
r_GetRenderStruct()->DrawPrimSetTexture(m_pTexture);
// If we've got an effect
LTEffectImpl* pEffectShader = (LTEffectImpl*)LTEffectShaderMgr::GetSingleton().GetEffectShader(m_nEffectShaderID);
if(pEffectShader)
{
ID3DXEffect* pD3DEffect = pEffectShader->GetEffect();
if(pD3DEffect)
{
if(m_pTexture)
{
RTexture* pRTexture = (RTexture*)m_pTexture->m_pRenderData;
pD3DEffect->SetTexture("texture0", pRTexture->m_pD3DTexture);
}
}
}
}
else
{
r_GetRenderStruct()->DrawPrimDisableTextures();
}
}
void CD3DDrawPrim::SetReallyClose(LPDIRECT3DDEVICE9 pDevice)
{
SetCamera(pDevice);
SetTransformMode(pDevice);
}
LTRESULT CD3DDrawPrim::SetEffectShaderID(uint32 nEffectShaderID)
{
m_nEffectShaderID = nEffectShaderID;
return LT_OK;
}
void CD3DDrawPrim::SetCamera(LPDIRECT3DDEVICE9 pDevice)
{
// Check the current viewport, may need to get changed...
D3DVIEWPORT9 PrevViewport;
pDevice->GetViewport(&PrevViewport);
float MinZ = (m_bReallyClose) ? 0.0f : m_PrevViewport.MinZ;
float MaxZ = (m_bReallyClose) ? 0.1f : m_PrevViewport.MaxZ;
if (m_pCamera)
{
LTObject* pLTCameraObj = (LTObject*)m_pCamera; // Set the Camera (if there is one)...
CameraInstance* pCamera = pLTCameraObj->ToCamera();
if ((pCamera->m_Left != (int)PrevViewport.X) ||
(pCamera->m_Top != (int)PrevViewport.Y) ||
((pCamera->m_Right - pCamera->m_Left) != (int)PrevViewport.Width) ||
((pCamera->m_Bottom - pCamera->m_Top) != (int)PrevViewport.Height))
{
D3DVIEWPORT9 vp;
vp.MinZ = MinZ;
vp.MaxZ = MaxZ;
vp.X = PrevViewport.X;
vp.Y = PrevViewport.Y;
vp.Width = PrevViewport.Width;
vp.Height = PrevViewport.Height;
PD3DDEVICE->SetViewport(&vp);
m_bResetViewport = true;
}
}
else
{
if (0 != PrevViewport.X || 0 != PrevViewport.Y || g_ScreenWidth != PrevViewport.Width || g_ScreenHeight != PrevViewport.Height)
{
D3DVIEWPORT9 vp;
vp.MinZ = MinZ;
vp.MaxZ = MaxZ;
vp.X = 0;
vp.Y = 0;
vp.Width = g_ScreenWidth;
vp.Height = g_ScreenHeight;
PD3DDEVICE->SetViewport(&vp);
m_bResetViewport = true;
}
}
}
void CD3DDrawPrim::SetTransformMode(LPDIRECT3DDEVICE9 pDevice)
{
D3DXMATRIX mIdentity;
D3DXMatrixIdentity(&mIdentity);
CameraInstance* pCamera = NULL;
if (m_pCamera)
{
pCamera = ((LTObject*)m_pCamera)->ToCamera();
}
//see if we are in really close, if so we need to assume camera space transform
//with a different projection matrix
if(m_bReallyClose)
{
// [RP] 4/24/02 - The viewport minZ & maxZ needs to be changed for accurately
// setting the position for a reallyclose primitive.
D3DVIEWPORT9 curVP;
PD3DDEVICE->GetViewport(&curVP);
D3DVIEWPORT9 ViewportData;
ViewportData.X = curVP.X;
ViewportData.Y = curVP.Y;
ViewportData.Width = curVP.Width;
ViewportData.Height = curVP.Height;
ViewportData.MinZ = 0;
ViewportData.MaxZ = 0.1f;
PD3DDEVICE->SetViewport(&ViewportData);
m_bResetViewport = true;
//setup our new projection based on player view parameters.
D3DXMATRIX NewProj;
float aspect = g_ScreenWidth / float(g_ScreenHeight);
D3DXMatrixPerspectiveFovLH(&NewProj,g_CV_PVModelFOV.m_Val * 0.01745329251994f,
aspect,
g_CV_ModelNear.m_Val,
g_CV_ModelFar.m_Val);
//setup the new matrices
PD3DDEVICE->SetTransform(D3DTS_PROJECTION, &NewProj);
PD3DDEVICE->SetTransform(D3DTS_VIEW,&mIdentity);
}
else
{
//not really close, so pick the transform that is most applicable
switch (m_eTransType)
{
case DRAWPRIM_TRANSFORM_WORLD :
if (m_pCamera)
{
ViewParams cDrawPrimParams;
d3d_InitFrustum(&cDrawPrimParams, pCamera->m_xFov, pCamera->m_yFov,
// Note : This sucks, but we don't have any other way of getting the near/farZ at this point
g_ViewParams.m_NearZ, g_ViewParams.m_FarZ,
pCamera->m_Left, pCamera->m_Top, pCamera->m_Right, pCamera->m_Bottom,
&pCamera->m_Pos, &pCamera->m_Rotation,
ViewParams::eRenderMode_Normal);
d3d_SetD3DTransformStates(cDrawPrimParams);
}
break;
case DRAWPRIM_TRANSFORM_CAMERA :
if (m_pCamera)
{
ViewParams cDrawPrimParams;
d3d_InitFrustum(&cDrawPrimParams, pCamera->m_xFov, pCamera->m_yFov,
// Note : This sucks, but we don't have any other way of getting the near/farZ at this point
g_ViewParams.m_NearZ, g_ViewParams.m_FarZ,
pCamera->m_Left, pCamera->m_Top, pCamera->m_Right, pCamera->m_Bottom,
&pCamera->m_Pos, &pCamera->m_Rotation,
ViewParams::eRenderMode_Normal);
d3d_SetD3DTransformStates(cDrawPrimParams);
}
g_RenderStateMgr.SetTransform(D3DTS_VIEW,&mIdentity);
break;
case DRAWPRIM_TRANSFORM_SCREEN :
g_RenderStateMgr.SetTransform(D3DTS_PROJECTION,&mIdentity);
break;
default:
assert(false);
break;
}
}
}
void CD3DDrawPrim::SetColorOp(LPDIRECT3DDEVICE9 pDevice)
{
switch (m_ColorOp)
{
case DRAWPRIM_NOCOLOROP :
pDevice->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_SELECTARG2);
pDevice->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG2);
break;
case DRAWPRIM_MODULATE :
pDevice->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE);
pDevice->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_MODULATE);
break;
case DRAWPRIM_ADD :
pDevice->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_ADD);
pDevice->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_ADD);
break;
case DRAWPRIM_DECAL :
pDevice->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_SELECTARG1);
pDevice->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_SELECTARG1);
break;
default:
assert(false);
break;
}
}
void CD3DDrawPrim::SetBlendMode(LPDIRECT3DDEVICE9 pDevice)
{
switch (m_BlendMode)
{
case DRAWPRIM_NOBLEND :
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,false);
break;
case DRAWPRIM_BLEND_ADD :
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,true);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_ONE);
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);
break;
case DRAWPRIM_BLEND_SATURATE :
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,true);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_INVDESTCOLOR);
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);
break;
case DRAWPRIM_BLEND_MOD_SRCALPHA :
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,true);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
break;
case DRAWPRIM_BLEND_MOD_SRCCOLOR :
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,true);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCCOLOR);
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCCOLOR);
break;
case DRAWPRIM_BLEND_MOD_DSTCOLOR :
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,true);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_DESTCOLOR);
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVDESTCOLOR);
break;
case DRAWPRIM_BLEND_MUL_SRCALPHA_ONE :
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,true);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);
break;
case DRAWPRIM_BLEND_MUL_SRCALPHA :
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,true);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCALPHA);
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ZERO);
break;
case DRAWPRIM_BLEND_MUL_SRCCOL_DSTCOL :
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,true);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCCOLOR);
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_DESTCOLOR);
break;
case DRAWPRIM_BLEND_MUL_SRCCOL_ONE :
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,true);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_SRCCOLOR);
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);
break;
case DRAWPRIM_BLEND_MUL_DSTCOL_ZERO :
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,true);
pDevice->SetRenderState(D3DRS_SRCBLEND,D3DBLEND_DESTCOLOR);
pDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ZERO);
break;
default:
assert(false);
break;
}
}
void CD3DDrawPrim::SetZBufferMode(LPDIRECT3DDEVICE9 pDevice)
{
switch (m_eZBufferMode)
{
case DRAWPRIM_ZRW :
pDevice->SetRenderState(D3DRS_ZENABLE,true);
pDevice->SetRenderState(D3DRS_ZWRITEENABLE,true);
break;
case DRAWPRIM_ZRO :
pDevice->SetRenderState(D3DRS_ZENABLE,true);
pDevice->SetRenderState(D3DRS_ZWRITEENABLE,false);
break;
case DRAWPRIM_NOZ :
pDevice->SetRenderState(D3DRS_ZENABLE,false);
pDevice->SetRenderState(D3DRS_ZWRITEENABLE,false);
break;
default:
assert(false);
break;
}
}
void CD3DDrawPrim::SetTestMode(LPDIRECT3DDEVICE9 pDevice)
{
switch (m_eTestMode)
{
case DRAWPRIM_NOALPHATEST :
pDevice->SetRenderState(D3DRS_ALPHATESTENABLE,false);
break;
case DRAWPRIM_ALPHATEST_LESS :
pDevice->SetRenderState(D3DRS_ALPHATESTENABLE,true);
pDevice->SetRenderState(D3DRS_ALPHAFUNC,D3DCMP_LESS);
break;
case DRAWPRIM_ALPHATEST_LESSEQUAL :
pDevice->SetRenderState(D3DRS_ALPHATESTENABLE,true);
pDevice->SetRenderState(D3DRS_ALPHAFUNC,D3DCMP_LESSEQUAL);
break;
case DRAWPRIM_ALPHATEST_GREATER :
pDevice->SetRenderState(D3DRS_ALPHATESTENABLE,true);
pDevice->SetRenderState(D3DRS_ALPHAFUNC,D3DCMP_GREATER);
break;
case DRAWPRIM_ALPHATEST_GREATEREQUAL :
pDevice->SetRenderState(D3DRS_ALPHATESTENABLE,true);
pDevice->SetRenderState(D3DRS_ALPHAFUNC,D3DCMP_GREATEREQUAL);
break;
case DRAWPRIM_ALPHATEST_EQUAL :
pDevice->SetRenderState(D3DRS_ALPHATESTENABLE,true);
pDevice->SetRenderState(D3DRS_ALPHAFUNC,D3DCMP_EQUAL);
break;
case DRAWPRIM_ALPHATEST_NOTEQUAL :
pDevice->SetRenderState(D3DRS_ALPHATESTENABLE,true);
pDevice->SetRenderState(D3DRS_ALPHAFUNC,D3DCMP_NOTEQUAL);
break;
default:
assert(false);
break;
}
}
void CD3DDrawPrim::SetFillMode(LPDIRECT3DDEVICE9 pDevice)
{
switch (m_eFillMode)
{
case DRAWPRIM_WIRE : pDevice->SetRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME); break;
case DRAWPRIM_FILL : pDevice->SetRenderState(D3DRS_FILLMODE,D3DFILL_SOLID); break;
default:
assert(false);
break;
}
}
void CD3DDrawPrim::SetCullMode(LPDIRECT3DDEVICE9 pDevice)
{
switch (m_eCullMode)
{
case DRAWPRIM_CULL_NONE : pDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_NONE); break;
case DRAWPRIM_CULL_CCW : pDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_CCW); break;
case DRAWPRIM_CULL_CW : pDevice->SetRenderState(D3DRS_CULLMODE,D3DCULL_CW); break;
default:
assert(false);
break;
}
}
void CD3DDrawPrim::SetFogEnable(LPDIRECT3DDEVICE9 pDevice)
{
pDevice->SetRenderState(D3DRS_FOGENABLE, m_bFogEnable);
}
// Set the render states (and save the old ones)...
void CD3DDrawPrim::PushRenderStates(LPDIRECT3DDEVICE9 pDevice)
{
//saves the current D3D state into the member variables
SaveStates(pDevice);
// save the reallyclose setting so it will properly reset
m_bPrevReallyClose = m_bReallyClose;
//clear out any old textures
r_GetRenderStruct()->DrawPrimDisableTextures();
//sets up the appropriate state for the each section
SetClipMode(pDevice);
SetTransformMode(pDevice);
SetColorOp(pDevice);
SetBlendMode(pDevice);
SetZBufferMode(pDevice);
SetTestMode(pDevice);
SetFillMode(pDevice);
SetCullMode(pDevice);
SetFogEnable(pDevice);
SetTexture(pDevice);
SetCamera(pDevice);
//not necessary, it just calls set camera and set transform mode...
//SetReallyClose(pDevice);
//setup states that are independant of the various possible settings
pDevice->SetRenderState(D3DRS_LIGHTING,false);
pDevice->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
pDevice->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_CURRENT);
pDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
pDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, D3DTA_CURRENT);
D3DXMATRIX mIdentity;
D3DXMatrixIdentity(&mIdentity);
g_RenderStateMgr.SetTransform(D3DTS_WORLDMATRIX(0), &mIdentity);
}
// Reset the old renderstates...
void CD3DDrawPrim::PopRenderStates(LPDIRECT3DDEVICE9 pDevice)
{
pDevice->SetTextureStageState(0,D3DTSS_COLOROP,m_PrevColorOp);
pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,m_PrevAlphaBlendEnable);
pDevice->SetRenderState(D3DRS_SRCBLEND,m_PrevSrcBlend);
pDevice->SetRenderState(D3DRS_DESTBLEND,m_PrevDstBlend);
pDevice->SetRenderState(D3DRS_ZENABLE,m_PrevZEnable);
pDevice->SetRenderState(D3DRS_ZWRITEENABLE,m_PrevZWriteEnable);
pDevice->SetRenderState(D3DRS_ALPHATESTENABLE,m_PrevAlphaTestEnable);
pDevice->SetRenderState(D3DRS_ALPHAFUNC,m_PrevAlphaTestFunc);
pDevice->SetRenderState(D3DRS_FILLMODE,m_PrevFillMode);
pDevice->SetRenderState(D3DRS_CLIPPING,m_PrevClipMode);
pDevice->SetRenderState(D3DRS_CULLMODE,m_PrevCullMode);
pDevice->SetRenderState(D3DRS_FOGENABLE,m_PrevFogMode);
pDevice->SetTransform(D3DTS_VIEW,&m_PrevTransView);
pDevice->SetTransform(D3DTS_PROJECTION,&m_PrevTransProj);
pDevice->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_MODULATE);
pDevice->SetTextureStageState(0,D3DTSS_ALPHAOP,D3DTOP_MODULATE);
pDevice->SetTextureStageState(0,D3DTSS_COLORARG1,D3DTA_TEXTURE);
pDevice->SetTextureStageState(0,D3DTSS_COLORARG2,D3DTA_DIFFUSE);
pDevice->SetTextureStageState(0,D3DTSS_ALPHAARG1,D3DTA_TEXTURE);
pDevice->SetTextureStageState(0,D3DTSS_ALPHAARG2,D3DTA_DIFFUSE);
if (m_bResetViewport)
{
PD3DDEVICE->SetViewport(&m_PrevViewport);
}
SetTexture((HTEXTURE)0);
// reset the reallyclose setting
m_bReallyClose = m_bPrevReallyClose;
}
void CD3DDrawPrim::SetUVWH (LT_POLYGT4 *pPrim, HTEXTURE pTex,
float u, float v,
float w, float h)
{
if (!pPrim) return;
uint32 ttw,tth;
float tw, th;
if (pTex) {
pTexInterface->GetTextureDims(pTex, ttw, tth);
tw = (float)ttw;
th = (float)tth;
float factor = 1.0f;
float pixelcenterh = 0.05/tw;
float pixelcenterv = 0.05/th;
pPrim->verts[0].u = u / tw + pixelcenterh;
pPrim->verts[0].v = v / th + pixelcenterv;
pPrim->verts[1].u = (u + w + factor) / tw + pixelcenterh;
pPrim->verts[1].v = v / th + pixelcenterv;
pPrim->verts[2].u = (u + w + factor) / tw + pixelcenterh;
pPrim->verts[2].v = (v + h + factor) / th + pixelcenterv;
pPrim->verts[3].u = u / tw + pixelcenterh;
pPrim->verts[3].v = (v + h + factor) / th + pixelcenterv;
}
else {
pPrim->verts[0].u = pPrim->verts[1].u = pPrim->verts[2].u = pPrim->verts[3].u = 0.0f;
pPrim->verts[0].v = pPrim->verts[1].v = pPrim->verts[2].v = pPrim->verts[3].v = 0.0f;
}
}
void CD3DDrawPrim::SaveViewport( void )
{
PD3DDEVICE->GetViewport( &m_SavedViewport );
}
void CD3DDrawPrim::RestoreViewport( void )
{
PD3DDEVICE->SetViewport( &m_SavedViewport );
}
// Draw primitive calls (triangles)
LTRESULT CD3DDrawPrim::DrawPrim(LT_POLYGT3 *pPrim, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nCount, pPrim, sizeof(LT_VERTGT)));
if (hRes != D3D_OK)
return LT_ERROR;
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYGT3* pSrcPtr = pPrim;
while (nCount) {
DRAWPRIM_D3DTRANS_TEX* pDstPtr = m_VertTransBufT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[0].rgba.r,pSrcPtr->verts[0].rgba.g,pSrcPtr->verts[0].rgba.b,pSrcPtr->verts[0].rgba.a);
pDstPtr->u = pSrcPtr->verts[0].u; pDstPtr->v = pSrcPtr->verts[0].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[1].rgba.r,pSrcPtr->verts[1].rgba.g,pSrcPtr->verts[1].rgba.b,pSrcPtr->verts[1].rgba.a);
pDstPtr->u = pSrcPtr->verts[1].u; pDstPtr->v = pSrcPtr->verts[1].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[2].x; pDstPtr->y = pSrcPtr->verts[2].y; pDstPtr->z = pSrcPtr->verts[2].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[2].rgba.r,pSrcPtr->verts[2].rgba.g,pSrcPtr->verts[2].rgba.b,pSrcPtr->verts[2].rgba.a);
pDstPtr->u = pSrcPtr->verts[2].u; pDstPtr->v = pSrcPtr->verts[2].v;
++pDstPtr;
--nCount; nDstBufSize -= 3; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nDrawCount, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrim(LT_POLYFT3 *pPrim, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYFT3* pSrcPtr = pPrim;
while (nCount) {
LT_VERTGT* pDstPtr = m_VertBufGT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rgba = pSrcPtr->rgba;
pDstPtr->u = pSrcPtr->verts[0].u; pDstPtr->v = pSrcPtr->verts[0].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rgba = pSrcPtr->rgba;
pDstPtr->u = pSrcPtr->verts[1].u; pDstPtr->v = pSrcPtr->verts[1].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[2].x; pDstPtr->y = pSrcPtr->verts[2].y; pDstPtr->z = pSrcPtr->verts[2].z;
pDstPtr->rgba = pSrcPtr->rgba;
pDstPtr->u = pSrcPtr->verts[2].u; pDstPtr->v = pSrcPtr->verts[2].v;
++pDstPtr;
--nCount; nDstBufSize -= 3; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nDrawCount, m_VertBufGT, sizeof(LT_VERTGT)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYFT3* pSrcPtr = pPrim;
while (nCount) {
DRAWPRIM_D3DTRANS_TEX* pDstPtr = m_VertTransBufT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
pDstPtr->u = pSrcPtr->verts[0].u; pDstPtr->v = pSrcPtr->verts[0].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
pDstPtr->u = pSrcPtr->verts[1].u; pDstPtr->v = pSrcPtr->verts[1].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[2].x; pDstPtr->y = pSrcPtr->verts[2].y; pDstPtr->z = pSrcPtr->verts[2].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
pDstPtr->u = pSrcPtr->verts[2].u; pDstPtr->v = pSrcPtr->verts[2].v;
++pDstPtr;
--nCount; nDstBufSize -= 3; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nDrawCount, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrim(LT_POLYG3 *pPrim, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
if (hRes != D3D_OK) return LT_ERROR;
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nCount, pPrim, sizeof(LT_VERTG)));
if (hRes != D3D_OK)
return LT_ERROR;
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYG3* pSrcPtr = pPrim;
while (nCount) {
DRAWPRIM_D3DTRANS* pDstPtr = m_VertTransBuf;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[0].rgba.r,pSrcPtr->verts[0].rgba.g,pSrcPtr->verts[0].rgba.b,pSrcPtr->verts[0].rgba.a);
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[1].rgba.r,pSrcPtr->verts[1].rgba.g,pSrcPtr->verts[1].rgba.b,pSrcPtr->verts[1].rgba.a);
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[2].x; pDstPtr->y = pSrcPtr->verts[2].y; pDstPtr->z = pSrcPtr->verts[2].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[2].rgba.r,pSrcPtr->verts[2].rgba.g,pSrcPtr->verts[2].rgba.b,pSrcPtr->verts[2].rgba.a);
++pDstPtr;
--nCount; nDstBufSize -= 3; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nDrawCount, m_VertTransBuf, sizeof(DRAWPRIM_D3DTRANS)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrim(LT_POLYF3 *pPrim, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYF3* pSrcPtr = pPrim;
while (nCount) {
LT_VERTG* pDstPtr = m_VertBufG;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rgba = pSrcPtr->rgba;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rgba = pSrcPtr->rgba;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[2].x; pDstPtr->y = pSrcPtr->verts[2].y; pDstPtr->z = pSrcPtr->verts[2].z;
pDstPtr->rgba = pSrcPtr->rgba;
++pDstPtr;
--nCount; nDstBufSize -= 3; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nDrawCount, m_VertBufG, sizeof(LT_VERTG)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYF3* pSrcPtr = pPrim;
while (nCount) {
DRAWPRIM_D3DTRANS* pDstPtr = m_VertTransBuf;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[2].x; pDstPtr->y = pSrcPtr->verts[2].y; pDstPtr->z = pSrcPtr->verts[2].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
++pDstPtr;
--nCount; nDstBufSize -= 3; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes,pDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nDrawCount, m_VertTransBuf, sizeof(DRAWPRIM_D3DTRANS)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
return LT_OK;
}
// Draw primitive calls (quadrilaterals)
LTRESULT CD3DDrawPrim::DrawPrim(LT_POLYGT4 *pPrim, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYGT4* pPrimPtr = pPrim;
while (nCount)
{ // Note: Not checking return everytime for speed...
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, pPrimPtr, sizeof(LT_VERTGT)));
--nCount; ++pPrimPtr;
}
if (hRes != D3D_OK)
return LT_ERROR;
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
if (nCount > 2) {
LT_POLYGT4* pSrcPtr = pPrim;
while (nCount) {
DRAWPRIM_D3DTRANS_TEX* pDstPtr = m_VertTransBufT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 6;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[0].rgba.r,pSrcPtr->verts[0].rgba.g,pSrcPtr->verts[0].rgba.b,pSrcPtr->verts[0].rgba.a);
pDstPtr->u = pSrcPtr->verts[0].u; pDstPtr->v = pSrcPtr->verts[0].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[1].rgba.r,pSrcPtr->verts[1].rgba.g,pSrcPtr->verts[1].rgba.b,pSrcPtr->verts[1].rgba.a);
pDstPtr->u = pSrcPtr->verts[1].u; pDstPtr->v = pSrcPtr->verts[1].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[2].x; pDstPtr->y = pSrcPtr->verts[2].y; pDstPtr->z = pSrcPtr->verts[2].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[2].rgba.r,pSrcPtr->verts[2].rgba.g,pSrcPtr->verts[2].rgba.b,pSrcPtr->verts[2].rgba.a);
pDstPtr->u = pSrcPtr->verts[2].u; pDstPtr->v = pSrcPtr->verts[2].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[0].rgba.r,pSrcPtr->verts[0].rgba.g,pSrcPtr->verts[0].rgba.b,pSrcPtr->verts[0].rgba.a);
pDstPtr->u = pSrcPtr->verts[0].u; pDstPtr->v = pSrcPtr->verts[0].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[2].x; pDstPtr->y = pSrcPtr->verts[2].y; pDstPtr->z = pSrcPtr->verts[2].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[2].rgba.r,pSrcPtr->verts[2].rgba.g,pSrcPtr->verts[2].rgba.b,pSrcPtr->verts[2].rgba.a);
pDstPtr->u = pSrcPtr->verts[2].u; pDstPtr->v = pSrcPtr->verts[2].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[3].x; pDstPtr->y = pSrcPtr->verts[3].y; pDstPtr->z = pSrcPtr->verts[3].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[3].rgba.r,pSrcPtr->verts[3].rgba.g,pSrcPtr->verts[3].rgba.b,pSrcPtr->verts[3].rgba.a);
pDstPtr->u = pSrcPtr->verts[3].u; pDstPtr->v = pSrcPtr->verts[3].v;
++pDstPtr;
--nCount; nDstBufSize -= 6; nDrawCount += 2; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nDrawCount, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
{
return LT_ERROR;
}
} }
else {
LT_POLYGT4* pPrimPtr = pPrim;
while (nCount) { // Note: Not checking return everytime for speed...
for (int i=0;i<4;++i) {
m_VertTransBufT[i].x = pPrimPtr->verts[i].x; m_VertTransBufT[i].y = pPrimPtr->verts[i].y; m_VertTransBufT[i].z = pPrimPtr->verts[i].z; m_VertTransBufT[i].rhw = 1.0f;
m_VertTransBufT[i].rgba = RGBA_MAKE(pPrimPtr->verts[i].rgba.r,pPrimPtr->verts[i].rgba.g,pPrimPtr->verts[i].rgba.b,pPrimPtr->verts[i].rgba.a);
m_VertTransBufT[i].u = pPrimPtr->verts[i].u; m_VertTransBufT[i].v = pPrimPtr->verts[i].v; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
--nCount; ++pPrimPtr; } }
}
return LT_OK;
}
// special version added by adam s. for optimized wide font rendering
LTRESULT CD3DDrawPrim::DrawPrim(LT_POLYGT4 **ppPrim, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYGT4** ppPrimPtr = ppPrim;
while (nCount)
{ // Note: Not checking return everytime for speed...
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, *ppPrimPtr, sizeof(LT_VERTGT)));
if (hRes != D3D_OK)
return LT_ERROR;
--nCount; ++ppPrimPtr; }
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
if (nCount > 2) {
LT_POLYGT4** pPtrArray = ppPrim;
LT_POLYGT4* pSrcPtr;
//LT_POLYGT4* pSrcPtr = pPrim;
while (nCount) {
DRAWPRIM_D3DTRANS_TEX* pDstPtr = m_VertTransBufT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 6;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pSrcPtr = *pPtrArray;
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[0].rgba.r,pSrcPtr->verts[0].rgba.g,pSrcPtr->verts[0].rgba.b,pSrcPtr->verts[0].rgba.a);
pDstPtr->u = pSrcPtr->verts[0].u; pDstPtr->v = pSrcPtr->verts[0].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[1].rgba.r,pSrcPtr->verts[1].rgba.g,pSrcPtr->verts[1].rgba.b,pSrcPtr->verts[1].rgba.a);
pDstPtr->u = pSrcPtr->verts[1].u; pDstPtr->v = pSrcPtr->verts[1].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[2].x; pDstPtr->y = pSrcPtr->verts[2].y; pDstPtr->z = pSrcPtr->verts[2].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[2].rgba.r,pSrcPtr->verts[2].rgba.g,pSrcPtr->verts[2].rgba.b,pSrcPtr->verts[2].rgba.a);
pDstPtr->u = pSrcPtr->verts[2].u; pDstPtr->v = pSrcPtr->verts[2].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[0].rgba.r,pSrcPtr->verts[0].rgba.g,pSrcPtr->verts[0].rgba.b,pSrcPtr->verts[0].rgba.a);
pDstPtr->u = pSrcPtr->verts[0].u; pDstPtr->v = pSrcPtr->verts[0].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[2].x; pDstPtr->y = pSrcPtr->verts[2].y; pDstPtr->z = pSrcPtr->verts[2].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[2].rgba.r,pSrcPtr->verts[2].rgba.g,pSrcPtr->verts[2].rgba.b,pSrcPtr->verts[2].rgba.a);
pDstPtr->u = pSrcPtr->verts[2].u; pDstPtr->v = pSrcPtr->verts[2].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[3].x; pDstPtr->y = pSrcPtr->verts[3].y; pDstPtr->z = pSrcPtr->verts[3].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[3].rgba.r,pSrcPtr->verts[3].rgba.g,pSrcPtr->verts[3].rgba.b,pSrcPtr->verts[3].rgba.a);
pDstPtr->u = pSrcPtr->verts[3].u; pDstPtr->v = pSrcPtr->verts[3].v;
++pDstPtr;
--nCount; nDstBufSize -= 6; nDrawCount += 2; ++pPtrArray; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLELIST, nDrawCount, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
else {
LT_POLYGT4** pPrimPtr = ppPrim;
while (nCount)
{ // Note: Not checking return everytime for speed...
for (int i=0;i<4;++i) {
m_VertTransBufT[i].x = (*pPrimPtr)->verts[i].x; m_VertTransBufT[i].y = (*pPrimPtr)->verts[i].y; m_VertTransBufT[i].z = (*pPrimPtr)->verts[i].z; m_VertTransBufT[i].rhw = 1.0f;
m_VertTransBufT[i].rgba = RGBA_MAKE((*pPrimPtr)->verts[i].rgba.r,(*pPrimPtr)->verts[i].rgba.g,(*pPrimPtr)->verts[i].rgba.b,(*pPrimPtr)->verts[i].rgba.a);
m_VertTransBufT[i].u = (*pPrimPtr)->verts[i].u; m_VertTransBufT[i].v = (*pPrimPtr)->verts[i].v; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
--nCount; ++pPrimPtr; } }
}
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrim(LT_POLYFT4 *pPrim, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYFT4* pPrimPtr = pPrim;
while (nCount) { // Note: Not checking return everytime for speed...
for (int i=0;i<4;++i) {
m_VertBufGT[i].x = pPrimPtr->verts[i].x; m_VertBufGT[i].y = pPrimPtr->verts[i].y; m_VertBufGT[i].z = pPrimPtr->verts[i].z;
m_VertBufGT[i].rgba = pPrimPtr->rgba;
m_VertBufGT[i].u = pPrimPtr->verts[i].u; m_VertBufGT[i].v = pPrimPtr->verts[i].v; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, m_VertBufGT, sizeof(LT_VERTGT)));
if (hRes != D3D_OK)
return LT_ERROR;
--nCount; ++pPrimPtr; }
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYFT4* pPrimPtr = pPrim;
while (nCount) { // Note: Not checking return everytime for speed...
for (int i=0;i<4;++i) {
m_VertTransBufT[i].x = pPrimPtr->verts[i].x; m_VertTransBufT[i].y = pPrimPtr->verts[i].y; m_VertTransBufT[i].z = pPrimPtr->verts[i].z; m_VertTransBufT[i].rhw = 1.0f;
m_VertTransBufT[i].rgba = RGBA_MAKE(pPrimPtr->rgba.r,pPrimPtr->rgba.g,pPrimPtr->rgba.b,pPrimPtr->rgba.a);
m_VertTransBufT[i].u = pPrimPtr->verts[i].u; m_VertTransBufT[i].v = pPrimPtr->verts[i].v; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
--nCount; ++pPrimPtr; }
}
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrim(LT_POLYG4 *pPrim, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYG4* pPrimPtr = pPrim;
while (nCount)
{ // Note: Not checking return everytime for speed...
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, pPrimPtr, sizeof(LT_VERTG)));
if (hRes != D3D_OK)
return LT_ERROR;
--nCount; ++pPrimPtr; }
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYG4* pPrimPtr = pPrim;
while (nCount) { // Note: Not checking return everytime for speed...
for (int i=0;i<4;++i) {
m_VertTransBuf[i].x = pPrimPtr->verts[i].x; m_VertTransBuf[i].y = pPrimPtr->verts[i].y; m_VertTransBuf[i].z = pPrimPtr->verts[i].z; m_VertTransBuf[i].rhw = 1.0f;
m_VertTransBuf[i].rgba = RGBA_MAKE(pPrimPtr->verts[i].rgba.r,pPrimPtr->verts[i].rgba.g,pPrimPtr->verts[i].rgba.b,pPrimPtr->verts[i].rgba.a); }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, m_VertTransBuf, sizeof(DRAWPRIM_D3DTRANS)));
if (hRes != D3D_OK)
return LT_ERROR;
--nCount; ++pPrimPtr; }
}
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrim(LT_POLYF4 *pPrim, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYF4* pPrimPtr = pPrim;
while (nCount) { // Note: Not checking return everytime for speed...
for (int i=0;i<4;++i) {
m_VertBufG[i].x = pPrimPtr->verts[i].x; m_VertBufG[i].y = pPrimPtr->verts[i].y; m_VertBufG[i].z = pPrimPtr->verts[i].z;
m_VertBufG[i].rgba = pPrimPtr->rgba; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, m_VertBufG, sizeof(LT_VERTG)));
if (hRes != D3D_OK)
return LT_ERROR;
--nCount; ++pPrimPtr; }
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_POLYF4* pPrimPtr = pPrim;
while (nCount) { // Note: Not checking return everytime for speed...
for (int i=0;i<4;++i) {
m_VertTransBuf[i].x = pPrimPtr->verts[i].x; m_VertTransBuf[i].y = pPrimPtr->verts[i].y; m_VertTransBuf[i].z = pPrimPtr->verts[i].z; m_VertTransBuf[i].rhw = 1.0f;
m_VertTransBuf[i].rgba = RGBA_MAKE(pPrimPtr->rgba.r,pPrimPtr->rgba.g,pPrimPtr->rgba.b,pPrimPtr->rgba.a); }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, m_VertTransBuf, sizeof(DRAWPRIM_D3DTRANS)));
if (hRes != D3D_OK)
return LT_ERROR;
--nCount; ++pPrimPtr; }
}
return LT_OK;
}
// Draw primitives using lines (Note: nCount is Line count).
LTRESULT CD3DDrawPrim::DrawPrim (LT_LINEGT *pPrim, uint32 nCount)
{
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
EFFECT_SHADER_MACRO(hRes,pDevice->DrawPrimitiveUP(D3DPT_LINELIST, nCount, pPrim, sizeof(LT_VERTGT)));
if (hRes != D3D_OK)
return LT_ERROR;
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_LINEGT* pSrcPtr = pPrim;
while (nCount) {
DRAWPRIM_D3DTRANS_TEX* pDstPtr = m_VertTransBufT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 2;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[0].rgba.r,pSrcPtr->verts[0].rgba.g,pSrcPtr->verts[0].rgba.b,pSrcPtr->verts[0].rgba.a);
pDstPtr->u = pSrcPtr->verts[0].u; pDstPtr->v = pSrcPtr->verts[0].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[1].rgba.r,pSrcPtr->verts[1].rgba.g,pSrcPtr->verts[1].rgba.b,pSrcPtr->verts[1].rgba.a);
pDstPtr->u = pSrcPtr->verts[1].u; pDstPtr->v = pSrcPtr->verts[1].v;
++pDstPtr;
--nCount; nDstBufSize -= 2; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_LINELIST, nDrawCount, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrim (LT_LINEFT *pPrim, uint32 nCount)
{
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
LT_LINEFT* pSrcPtr = pPrim;
while (nCount) {
LT_VERTGT* pDstPtr = m_VertBufGT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 2;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rgba = pSrcPtr->rgba;
pDstPtr->u = pSrcPtr->verts[0].u; pDstPtr->v = pSrcPtr->verts[0].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rgba = pSrcPtr->rgba;
pDstPtr->u = pSrcPtr->verts[1].u; pDstPtr->v = pSrcPtr->verts[1].v;
++pDstPtr;
--nCount; nDstBufSize -= 2; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_LINELIST, nDrawCount, m_VertBufGT, sizeof(LT_VERTGT)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_LINEFT* pSrcPtr = pPrim;
while (nCount) {
DRAWPRIM_D3DTRANS_TEX* pDstPtr = m_VertTransBufT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 2;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
pDstPtr->u = pSrcPtr->verts[0].u; pDstPtr->v = pSrcPtr->verts[0].v;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
pDstPtr->u = pSrcPtr->verts[1].u; pDstPtr->v = pSrcPtr->verts[1].v;
++pDstPtr;
--nCount; nDstBufSize -= 2; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_LINELIST, nDrawCount, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrim (LT_LINEG *pPrim, uint32 nCount)
{
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
if (hRes != D3D_OK) return LT_ERROR;
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_LINELIST, nCount, pPrim, sizeof(LT_VERTG)));
if (hRes != D3D_OK)
return LT_ERROR;
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_LINEG* pSrcPtr = pPrim;
while (nCount) {
DRAWPRIM_D3DTRANS* pDstPtr = m_VertTransBuf;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 2;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[0].rgba.r,pSrcPtr->verts[0].rgba.g,pSrcPtr->verts[0].rgba.b,pSrcPtr->verts[0].rgba.a);
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->verts[1].rgba.r,pSrcPtr->verts[1].rgba.g,pSrcPtr->verts[1].rgba.b,pSrcPtr->verts[1].rgba.a);
++pDstPtr;
--nCount; nDstBufSize -= 2; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_LINELIST, nDrawCount, m_VertTransBuf, sizeof(DRAWPRIM_D3DTRANS)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrim (LT_LINEF *pPrim, uint32 nCount)
{
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
if (hRes != D3D_OK) return LT_ERROR;
LT_LINEF* pSrcPtr = pPrim;
while (nCount) {
LT_VERTG* pDstPtr = m_VertBufG;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 2;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rgba = pSrcPtr->rgba;
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rgba = pSrcPtr->rgba;
++pDstPtr;
--nCount; nDstBufSize -= 2; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_LINELIST, nDrawCount, m_VertBufG, sizeof(LT_VERTG)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_LINEF* pSrcPtr = pPrim;
while (nCount) {
DRAWPRIM_D3DTRANS* pDstPtr = m_VertTransBuf;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 2;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->verts[0].x; pDstPtr->y = pSrcPtr->verts[0].y; pDstPtr->z = pSrcPtr->verts[0].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
++pDstPtr;
pDstPtr->x = pSrcPtr->verts[1].x; pDstPtr->y = pSrcPtr->verts[1].y; pDstPtr->z = pSrcPtr->verts[1].z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
++pDstPtr;
--nCount; nDstBufSize -= 2; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_LINELIST, nDrawCount, m_VertTransBuf, sizeof(DRAWPRIM_D3DTRANS)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
return LT_OK;
}
// Draw primitives using points (Note: nCount is Point count).
LTRESULT CD3DDrawPrim::DrawPrimPoint (LT_VERTGT *pVerts, uint32 nCount)
{
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_POINTLIST, nCount, pVerts, sizeof(LT_VERTGT)));
if (hRes != D3D_OK)
return LT_ERROR;
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_VERTGT* pSrcPtr = pVerts;
while (nCount) {
DRAWPRIM_D3DTRANS_TEX* pDstPtr = m_VertTransBufT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 1;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
pDstPtr->u = pSrcPtr->u; pDstPtr->v = pSrcPtr->v;
++pDstPtr;
--nCount; --nDstBufSize; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_POINTLIST, nDrawCount, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrimPoint (LT_VERTG *pVerts, uint32 nCount)
{
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
if (hRes != D3D_OK) return LT_ERROR;
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_POINTLIST, nCount, pVerts, sizeof(LT_VERTG)));
if (hRes != D3D_OK)
return LT_ERROR;
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_VERTG* pSrcPtr = pVerts;
while (nCount) {
DRAWPRIM_D3DTRANS* pDstPtr = m_VertTransBuf;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 1;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z;
pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
++pDstPtr;
--nCount; --nDstBufSize; ++nDrawCount; ++pSrcPtr; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_POINTLIST, nDrawCount, m_VertTransBuf, sizeof(DRAWPRIM_D3DTRANS)));
if (hRes != D3D_OK)
return LT_ERROR;
} }
return LT_OK;
}
// Draw primitive calls using triangle fans
LTRESULT CD3DDrawPrim::DrawPrimFan(LT_VERTGT *pVerts, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, nCount-2, pVerts, sizeof(LT_VERTGT)));
if (hRes != D3D_OK)
return LT_ERROR;
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
bool bNotFirstLoop = false;
LT_VERTGT* pSrcPtr = pVerts;
while (nCount) {
DRAWPRIM_D3DTRANS_TEX* pDstPtr = m_VertTransBufT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
if (bNotFirstLoop) { // If it's not the first, need to grab the first vert (already moved back the source pointer by one)...
pDstPtr->x = pVerts->x; pDstPtr->y = pVerts->y; pDstPtr->z = pVerts->z; pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pVerts->rgba.r,pVerts->rgba.g,pVerts->rgba.b,pVerts->rgba.a);
pDstPtr->u = pVerts->u; pDstPtr->v = pVerts->v;
++pDstPtr; --nCount; ++nDrawCount; }
else bNotFirstLoop = true;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z; pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pVerts->rgba.r,pVerts->rgba.g,pVerts->rgba.b,pVerts->rgba.a);
pDstPtr->u = pSrcPtr->u; pDstPtr->v = pSrcPtr->v;
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, nDrawCount-2, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { --pSrcPtr; nCount += 2; } } } // Skip back one (see notes by bNotFirstLoop)...
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrimFan(LT_VERTFT *pVerts, uint32 nCount, LT_VERTRGBA rgba) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
bool bNotFirstLoop = false;
LT_VERTFT* pSrcPtr = pVerts;
while (nCount) {
LT_VERTGT* pDstPtr = m_VertBufGT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
if (bNotFirstLoop) { // If it's not the first, need to grab the first vert (already moved back the source pointer by one)...
pDstPtr->x = pVerts->x; pDstPtr->y = pVerts->y; pDstPtr->z = pVerts->z;
pDstPtr->rgba = rgba;
pDstPtr->u = pVerts->u; pDstPtr->v = pVerts->v;
++pDstPtr; --nCount; ++nDrawCount; }
else bNotFirstLoop = true;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z;
pDstPtr->rgba = rgba;
pDstPtr->u = pSrcPtr->u; pDstPtr->v = pSrcPtr->v;
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, nDrawCount-2, m_VertBufGT, sizeof(LT_VERTGT)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { --pSrcPtr; nCount += 2; } } } // Skip back one (see notes by bNotFirstLoop)...
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
bool bNotFirstLoop = false;
LT_VERTFT* pSrcPtr = pVerts;
while (nCount) {
DRAWPRIM_D3DTRANS_TEX* pDstPtr = m_VertTransBufT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
if (bNotFirstLoop) { // If it's not the first, need to grab the first vert (already moved back the source pointer by one)...
pDstPtr->x = pVerts->x; pDstPtr->y = pVerts->y; pDstPtr->z = pVerts->z; pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(rgba.r,rgba.g,rgba.b,rgba.a);
pDstPtr->u = pVerts->u; pDstPtr->v = pVerts->v;
++pDstPtr; --nCount; ++nDrawCount; }
else bNotFirstLoop = true;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z; pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(rgba.r,rgba.g,rgba.b,rgba.a);
pDstPtr->u = pSrcPtr->u; pDstPtr->v = pSrcPtr->v;
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, nDrawCount-2, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { --pSrcPtr; nCount += 2; } } } // Skip back one (see notes by bNotFirstLoop)...
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrimFan(LT_VERTG *pVerts, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
if (hRes != D3D_OK) return LT_ERROR;
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, nCount-2, pVerts, sizeof(LT_VERTG)));
if (hRes != D3D_OK)
return LT_ERROR;
}
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
bool bNotFirstLoop = false;
LT_VERTG* pSrcPtr = pVerts;
while (nCount) {
DRAWPRIM_D3DTRANS* pDstPtr = m_VertTransBuf;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
if (bNotFirstLoop) { // If it's not the first, need to grab the first vert (already moved back the source pointer by one)...
pDstPtr->x = pVerts->x; pDstPtr->y = pVerts->y; pDstPtr->z = pVerts->z; pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pVerts->rgba.r,pVerts->rgba.g,pVerts->rgba.b,pVerts->rgba.a);
++pDstPtr; --nCount; ++nDrawCount; }
else bNotFirstLoop = true;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z; pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(pVerts->rgba.r,pVerts->rgba.g,pVerts->rgba.b,pVerts->rgba.a);
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, nDrawCount-2, m_VertTransBuf, sizeof(DRAWPRIM_D3DTRANS)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { --pSrcPtr; nCount += 2; } } } // Skip back one (see notes by bNotFirstLoop)...
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrimFan(LT_VERTF *pVerts, uint32 nCount, LT_VERTRGBA rgba) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
if (hRes != D3D_OK) return LT_ERROR;
bool bNotFirstLoop = false;
LT_VERTF* pSrcPtr = pVerts;
while (nCount) {
LT_VERTG* pDstPtr = m_VertBufG;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
if (bNotFirstLoop) { // If it's not the first, need to grab the first vert (already moved back the source pointer by one)...
pDstPtr->x = pVerts->x; pDstPtr->y = pVerts->y; pDstPtr->z = pVerts->z;
pDstPtr->rgba = rgba;
++pDstPtr; --nCount; ++nDrawCount; }
else bNotFirstLoop = true;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z;
pDstPtr->rgba = rgba;
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, nDrawCount-2, m_VertBufG, sizeof(LT_VERTG)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { --pSrcPtr; nCount += 2; } } } // Skip back one (see notes by bNotFirstLoop)...
else { // Use Transform and Lit verts...
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
bool bNotFirstLoop = false;
LT_VERTF* pSrcPtr = pVerts;
while (nCount) {
DRAWPRIM_D3DTRANS* pDstPtr = m_VertTransBuf;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
if (bNotFirstLoop) { // If it's not the first, need to grab the first vert (already moved back the source pointer by one)...
pDstPtr->x = pVerts->x; pDstPtr->y = pVerts->y; pDstPtr->z = pVerts->z; pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(rgba.r,rgba.g,rgba.b,rgba.a);
++pDstPtr; --nCount; ++nDrawCount; }
else bNotFirstLoop = true;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z; pDstPtr->rhw = 1.0f;
pDstPtr->rgba = RGBA_MAKE(rgba.r,rgba.g,rgba.b,rgba.a);
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, nDrawCount-2, m_VertTransBuf, sizeof(DRAWPRIM_D3DTRANS)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { --pSrcPtr; nCount += 2; } } } // Skip back one (see notes by bNotFirstLoop)...
return LT_OK;
}
// Draw primitive calls using triangle strips
LTRESULT CD3DDrawPrim::DrawPrimStrip(LT_VERTGT *pVerts, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, nCount-2, pVerts, sizeof(LT_VERTGT)));
if (hRes != D3D_OK)
return LT_ERROR;
}
else {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_VERTGT* pSrcPtr = pVerts;
while (nCount) {
DRAWPRIM_D3DTRANS_TEX* pDstPtr = m_VertTransBufT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
pDstPtr->u = pSrcPtr->u; pDstPtr->v = pSrcPtr->v;
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, nDrawCount-2, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { pSrcPtr -= 2; nCount += 2; } } } // Skip back two (since it's a strip - need to send those two again)...Need to check the Cull direction (might be backwards).
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrimStrip(LT_VERTFT *pVerts, uint32 nCount, LT_VERTRGBA rgba) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1);
if (hRes != D3D_OK) return LT_ERROR;
LT_VERTFT* pSrcPtr = pVerts;
while (nCount) {
LT_VERTGT* pDstPtr = m_VertBufGT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z;
pDstPtr->rgba = rgba;
pDstPtr->u = pSrcPtr->u; pDstPtr->v = pSrcPtr->v;
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, nDrawCount-2, m_VertBufGT, sizeof(LT_VERTGT)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { pSrcPtr -= 2; nCount += 2; } } } // Skip back two (since it's a strip - need to send those two again)...Need to check the Cull direction (might be backwards).
else {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_TEX_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_VERTFT* pSrcPtr = pVerts;
while (nCount) {
DRAWPRIM_D3DTRANS_TEX* pDstPtr = m_VertTransBufT;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z;
pDstPtr->rgba = RGBA_MAKE(rgba.r,rgba.g,rgba.b,rgba.a);
pDstPtr->u = pSrcPtr->u; pDstPtr->v = pSrcPtr->v;
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, nDrawCount-2, m_VertTransBufT, sizeof(DRAWPRIM_D3DTRANS_TEX)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { pSrcPtr -= 2; nCount += 2; } } } // Skip back two (since it's a strip - need to send those two again)...Need to check the Cull direction (might be backwards).
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrimStrip(LT_VERTG *pVerts, uint32 nCount) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
if (hRes != D3D_OK) return LT_ERROR;
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, nCount-2, pVerts, sizeof(LT_VERTG)));
if (hRes != D3D_OK)
return LT_ERROR;
}
else {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_VERTG* pSrcPtr = pVerts;
while (nCount) {
DRAWPRIM_D3DTRANS* pDstPtr = m_VertTransBuf;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z;
pDstPtr->rgba = RGBA_MAKE(pSrcPtr->rgba.r,pSrcPtr->rgba.g,pSrcPtr->rgba.b,pSrcPtr->rgba.a);
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, nDrawCount-2, m_VertTransBuf, sizeof(DRAWPRIM_D3DTRANS)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { pSrcPtr -= 2; nCount += 2; } } } // Skip back two (since it's a strip - need to send those two again)...Need to check the Cull direction (might be backwards).
return LT_OK;
}
LTRESULT CD3DDrawPrim::DrawPrimStrip(LT_VERTF *pVerts, uint32 nCount, LT_VERTRGBA rgba) {
LPDIRECT3DDEVICE9 pDevice = r_GetRenderStruct()->GetD3DDevice();
if (!pDevice) return LT_ERROR;
CAutoDrawPrimBlock AutoDPBlock(this);
if (m_eTransType != DRAWPRIM_TRANSFORM_SCREEN) {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE);
if (hRes != D3D_OK) return LT_ERROR;
LT_VERTF* pSrcPtr = pVerts;
while (nCount) {
LT_VERTG* pDstPtr = m_VertBufG;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z;
pDstPtr->rgba = rgba;
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, nDrawCount-2, m_VertBufG, sizeof(LT_VERTG)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { pSrcPtr -= 2; nCount += 2; } } } // Skip back two (since it's a strip - need to send those two again)...Need to check the Cull direction (might be backwards).
else {
HRESULT hRes = pDevice->SetVertexShader(NULL);
if (hRes != D3D_OK) return LT_ERROR;
hRes = pDevice->SetFVF(DRAWPRIM_D3DTRANS_FLAGS);
if (hRes != D3D_OK) return LT_ERROR;
LT_VERTF* pSrcPtr = pVerts;
while (nCount) {
DRAWPRIM_D3DTRANS* pDstPtr = m_VertTransBuf;
uint32 nDrawCount = 0;
int32 nDstBufSize = CD3DDRAWPRIM_BUFSIZE - 3;
while (nCount && nDstBufSize > 0) { // Copy the tri to the buffer,..
pDstPtr->x = pSrcPtr->x; pDstPtr->y = pSrcPtr->y; pDstPtr->z = pSrcPtr->z;
pDstPtr->rgba = RGBA_MAKE(rgba.r,rgba.g,rgba.b,rgba.a);
++pDstPtr; ++pSrcPtr;
--nCount; --nDstBufSize; ++nDrawCount; }
EFFECT_SHADER_MACRO(hRes, pDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, nDrawCount-2, m_VertTransBuf, sizeof(DRAWPRIM_D3DTRANS)));
if (hRes != D3D_OK)
return LT_ERROR;
if (nCount) { pSrcPtr -= 2; nCount += 2; } } } // Skip back two (since it's a strip - need to send those two again)...Need to check the Cull direction (might be backwards).
return LT_OK;
}
| [
"bibendovsky@hotmail.com"
] | bibendovsky@hotmail.com |
2a3dbf155bc9082fcd2ab6ddfeee96d1efadbe9c | ccb12171ae70b198a55e5d76801dfffd3bafe720 | /HelloGL/Physics.cpp | 67143624db11c65087f1cd9b82ac9337dff68b6c | [] | no_license | Augek158/Particles | 9383d0184964f1b76d50fea6cf056bfaa2beeaf3 | 695406e28efc89d66cb49ed3ebd1b1302bccce10 | refs/heads/master | 2016-09-09T12:28:39.297729 | 2014-06-03T14:20:12 | 2014-06-03T14:20:12 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 166 | cpp | //
// Physics.cpp
// HelloGL
//
// Created by Oscar Johnson on 2014-05-20.
// Copyright (c) 2014 August Nam-Ki Ek. All rights reserved.
//
#include "Physics.h"
| [
"o.johnsson@live.se"
] | o.johnsson@live.se |
d6f1864698b1041b7126ec497f5f66181fc6ef8e | 8c72fd61a0115fec9ea69536b0d3db1ffb63128f | /src/condor_utils/file_modified_trigger.h | 6a6c7826c57b2c40f893ce44ea01954449c9ffce | [
"DOC",
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | pavlo-svirin/htcondor | 0aee74af7857ede238f07f68ca0c0109b7e90e9a | 9e00a5874cc2579f5fdc81bb778f540b40b48c87 | refs/heads/master | 2021-06-20T02:22:17.819621 | 2019-06-26T21:54:10 | 2019-06-26T21:54:10 | 193,559,154 | 0 | 0 | Apache-2.0 | 2019-06-24T18:34:57 | 2019-06-24T18:34:56 | null | UTF-8 | C++ | false | false | 1,643 | h | /******************************************************************************
*
* Copyright (C) 1990-2018, Condor Team, Computer Sciences Department,
* University of Wisconsin-Madison, WI.
*
* 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 _CONDOR_FILE_MODIFIED_TRIGGER_H
#define _CONDOR_FILE_MODIFIED_TRIGGER_H
class FileModifiedTrigger {
public:
FileModifiedTrigger( const std::string & filename );
virtual ~FileModifiedTrigger( void );
bool isInitialized( void ) const { return initialized; }
void releaseResources();
// Timeout is in milliseconds. Returns -1 if invalid, 0 if timed
// out, 1 if file has changed (like poll()).
int wait( int timeout = -1 );
private:
// Only needed for better log messages.
std::string filename;
bool initialized;
FileModifiedTrigger( const FileModifiedTrigger & fmt );
FileModifiedTrigger & operator =( const FileModifiedTrigger & fmt );
#if defined( LINUX )
int read_inotify_events( void );
int inotify_fd;
#else
int statfd;
off_t lastSize;
#endif
};
#endif
| [
"tlmiller@cs.wisc.edu"
] | tlmiller@cs.wisc.edu |
d6e6f6004ae43df19ce3a5aa7d6c643ca1c71045 | 0c75f825c49b38791e428de4e90dbefeffbd3e9d | /progs/others/final.cpp | 85b5bd1ede8dccbc9d76516c3b5515f3ebc324ff | [] | no_license | sadiqueamu/sadiqueamu | f5e375be4a14b1b5f2121e59bafb51ac04939687 | dfc4617c4eb7e970a3fea1c9f1c838e97dab8461 | refs/heads/master | 2020-12-02T22:18:31.892834 | 2017-07-03T13:43:38 | 2017-07-03T13:43:38 | 96,111,220 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 418 | cpp | #include<iostream>
using namespace std;
class final;
class makeFinal {
private:
makeFinal() { cout<<"makeFinal()\n"; }
friend final;
};
class final:virtual makeFinal {
public:
final() { cout<<"final()\n"; }
};
/* Can't inherit final as makeFinal dtor is private */
class derived:public final {
public:
derived() { cout<<"derived()\n"; }
};/**/
int main() {
final f;
return 0;
}
| [
"sadiqueamu@gmail.com"
] | sadiqueamu@gmail.com |
e8f7089783a70205ba9d3517c182682538712e42 | 11f15450a21c30b2557ea1ceb8b268988c85f23e | /util/VectorUtil.h | 8dfe6312bb172d47fd652e89053a704f8ec8171c | [
"MIT"
] | permissive | wzx140/Tube_connect | c06a9756be0a924813cfdb0a099b4c95c3bdafea | b5e7d204b076779f7698765d4127747aa2568b52 | refs/heads/master | 2020-04-09T12:37:19.749725 | 2019-07-20T02:33:42 | 2019-07-20T02:34:12 | 160,357,537 | 0 | 0 | MIT | 2019-03-04T06:03:42 | 2018-12-04T12:56:43 | C++ | UTF-8 | C++ | false | false | 5,623 | h | //
// Created by wzx on 18-11-30.
//
#ifndef TUBE_CONNECT_VECTORUTIL_H
#define TUBE_CONNECT_VECTORUTIL_H
#include <vtkMath.h>
#include <vtkDataArray.h>
#include <vtkPolyData.h>
#include <vtkPolyDataNormals.h>
#include <vtkCellData.h>
#include <vtkDataArray.h>
#include <array>
using std::array;
namespace VectorUtil {
/**
* get vector from point1 -> point2
* @param point1: three components
* @param point2: three components
* @return the return vector
*/
inline array<double, 3> getVector(const array<double, 3> &point1, const array<double, 3> &point2);
/**
* get angle of two vectors
* @param vector1: three components
* @param vector2: three components
* @return deg
*/
inline double getAngle(const array<double, 3> &vector1, const array<double, 3> &vector2);
/**
* reverse vector
* @param vector: three components
*/
inline void reverse(array<double, 3> &vector);
/**
* regularize the vector
* @param vector: three components
*/
inline void regularize(array<double, 3> &vector);
/**
* if the cells in tube are dense, there will be some equal normals of cells. this function designed to get different vector
* @param normals
* @param vector: three components
* @return
*/
inline array<double, 3> getDifferentVector(vtkSmartPointer<vtkDataArray> normals, const array<double, 3> &vector);
/**
* compare two vector with 0.001 epsilon
* @param vector1
* @param vector2
* @return
*/
inline bool isEqual(const array<double, 3> &vector1, const array<double, 3> &vector2);
/**
* calculate normals of data's cells
* @param data
* @return three-components tuple
*/
inline vtkSmartPointer<vtkDataArray> calculateNormals(vtkSmartPointer<vtkPolyData> data);
/**
* get two vertical vectors in xy plane
* @param vector
* @return two vertical vectors
*/
inline array<array<double, 3>, 2> getVerVector(array<double, 3> &vector);
/**
* move the point
* @param point
* @param vector
* @param length
* @return
*/
inline array<double, 3> movePoint(array<double, 3> &point, array<double, 3> &vector, double length);
}
namespace VectorUtil {
array<double, 3> getVector(const array<double, 3> &point1, const array<double, 3> &point2) {
array<double, 3> vector = {0};
for (int i = 0; i < 3; i++) {
vector[i] = point2[i] - point1[i];
}
return vector;
}
double getAngle(const array<double, 3> &vector1, const array<double, 3> &vector2) {
array<double, 3> tempCross = {0};
vtkMath::Cross(vector1.data(), vector2.data(), tempCross.data());
double rad = atan2(vtkMath::Norm(tempCross.data()), vtkMath::Dot(vector1.data(), vector2.data()));
double deg = vtkMath::DegreesFromRadians(rad);
return abs(deg);
}
void reverse(array<double, 3> &vector) {
for (int i = 0; i < 3; i++) {
vector[i] = -vector[i];
}
}
void regularize(array<double, 3> &vector) {
double norm = vtkMath::Norm(vector.data());
vector[0] = vector[0] / norm;
vector[1] = vector[1] / norm;
vector[2] = vector[2] / norm;
}
array<double, 3> getDifferentVector(vtkSmartPointer<vtkDataArray> normals, const array<double, 3> &vector) {
array<double, 3> diffVector = {0};
array<double, 3> normal = {0};
for (int i = static_cast<int>(normals->GetNumberOfTuples() / 2); i < normals->GetNumberOfTuples(); i++) {
normals->GetTuple(i, normal.data());
if (!VectorUtil::isEqual(normal, vector)) {
normals->GetTuple(i, diffVector.data());
}
}
return diffVector;
}
bool isEqual(const array<double, 3> &vector1, const array<double, 3> &vector2) {
double epsilon = 0.01;
double deltaX = abs(vector1[0] - vector2[0]);
double deltaY = abs(vector1[1] - vector2[1]);
double deltaZ = abs(vector1[2] - vector2[2]);
if (deltaX < epsilon && deltaY < epsilon && deltaZ < epsilon) {
return true;
} else {
return false;
}
}
vtkSmartPointer<vtkDataArray> calculateNormals(vtkSmartPointer<vtkPolyData> data) {
auto normalFilter = vtkSmartPointer<vtkPolyDataNormals>::New();
normalFilter->SetInputData(data);
normalFilter->SetComputeCellNormals(1);
normalFilter->Update();
return normalFilter->GetOutput()->GetCellData()->GetNormals();
}
array<array<double, 3>, 2> getVerVector(array<double, 3> &vector) {
array<array<double, 3>, 2> verVectors = {0};
array<double, 3> verVector1 = vector;
array<double, 3> verVector2 = vector;
verVector1[0] = vector[1] / sqrt(pow(vector[0], 2) + pow(vector[1], 2));
verVector1[1] = -vector[0] / sqrt(pow(vector[0], 2) + pow(vector[1], 2));
verVector2[0] = -vector[1] / sqrt(pow(vector[0], 2) + pow(vector[1], 2));
verVector2[1] = vector[0] / sqrt(pow(vector[0], 2) + pow(vector[1], 2));
verVectors[0] = verVector1;
verVectors[1] = verVector2;
return verVectors;
}
array<double, 3> movePoint(array<double, 3> &point, array<double, 3> &vector, double length) {
array<double, 3> nextPoint = {0};
for (int i = 0; i < 3; i++) {
nextPoint[i] = point[i] + vector[i] * length;
}
return nextPoint;
}
}
#endif //TUBE_CONNECT_VECTORUTIL_H
| [
"masterwangzx@gmail.com"
] | masterwangzx@gmail.com |
0f64dec2e1de1606500ee72a69d34898c125c595 | 2cd96b2cc99ae4a21acd5191ec71de1d5fec284c | /online-judges/spoj/ae00.cpp | 4862880896fb1b2522c93df46f70122dbffc2efc | [] | no_license | Logic21/competitive-programming | 4020d0875c4d84ad9fce4a4a6a4ec4117885bff3 | fa87caab794f13b2c06f981f861281cbef3e43d5 | refs/heads/master | 2020-05-15T05:52:02.929847 | 2018-12-12T14:38:19 | 2018-12-12T14:38:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 599 | cpp | //http://www.spoj.com/problems/AE00/
#include <iostream>
#include <cmath>
using namespace std;
unsigned long long byteman(int squares){
unsigned long long rectangles = 0;
if(squares == 1) return 1;
//count up to sqrt(n) evalute which divides evenly = +1 solution
int sqrt_n = sqrt(squares);
for(int i = 1; i <= sqrt_n; i++)
if(squares % i == 0) rectangles++;
//call for n-1
rectangles += byteman(squares-1);
return rectangles;
}
int main(){
int squares = 0;
cin >> squares;
cout << byteman(squares) << endl;
return 0;
} | [
"joaoconde_13@hotmail.com"
] | joaoconde_13@hotmail.com |
dd08ad12c2e9f8927a370135434c2c1ab56ca9b8 | 88c067ccabe72b4bbdcbec7700bb20489d45425c | /13168.cpp | 50c3ef891ff005f8a0722642599f698f0cecaad9 | [] | no_license | SiJun-Yoo/Algorithm | 5a92cb79365ca8db921fb4820ac95929a334d54e | ef89154d7ba0d1b2c85a89f23f84fdbf380baeff | refs/heads/master | 2022-11-05T17:33:59.793003 | 2022-09-19T14:16:23 | 2022-09-19T14:16:23 | 281,680,931 | 2 | 1 | null | null | null | null | UHC | C++ | false | false | 2,138 | cpp | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef queue<int> qi;
typedef queue<pair<int, int>> qii;
typedef priority_queue<int> pqi;
typedef priority_queue<ll> pql;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vii;
typedef vector<pll> vll;
const ll MOD = 1000000007;
const int MAX = 100000000;
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
int n, m, k, t;
map<string, int> m1;
string b[201];
double dist1[101][101];
double dist2[101][101];
int main() {
cin.tie(NULL); ios_base::sync_with_stdio(false);
cin >> n >> m;
for (int i = 1; i <= n; i++) {
string now;
cin >> now;
m1[now] = i;
}
cin >> k;
for (int i = 1; i <= k; i++) {
cin >> b[i];
}
cin >> t;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
dist1[i][j] = MAX;
dist2[i][j] = MAX;
}
dist1[i][i] = 0;
dist2[i][i] = 0;
}
for (int i = 1; i <= t; i++) {
string str1, str2, str3;
double num;
cin >> str1 >> str2 >> str3 >> num;
int s = m1[str2];
int e = m1[str3];
dist1[e][s] = dist1[s][e] = min(dist1[s][e], num);
if (str1 == "S-Train" || str1 == "V-Train") { num /= 2.0; }
else if (str1 == "Mugunghwa" || str1 == "ITX-Saemaeul" || str1 == "ITX-Cheongchun") { num = 0; }
dist2[e][s] = dist2[s][e] = min(dist2[s][e], num);
}
for (int l = 1; l <= n; l++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (dist1[i][j] > dist1[i][l] + dist1[l][j]) {
dist1[i][j] = dist1[i][l] + dist1[l][j];//내일로 안쓴거
}
if (dist2[i][j] > dist2[i][l] + dist2[l][j]) {
dist2[i][j] = dist2[i][l] + dist2[l][j];
}
}
}
}
double ans1 = 0;
double ans2 = m;
for (int i = 2; i <= k; i++) {
int s = m1[b[i - 1]];
int e = m1[b[i]];
ans1 += dist1[s][e];
ans2 += dist2[s][e];
}
int s = m1[b[k]];
int e = m1[b[1]];
ans1 += dist1[s][e];
ans2 += dist2[s][e];
cout << (ans2 < ans1 ? "Yes" : "No");
return 0;
}
| [
"noreply@github.com"
] | SiJun-Yoo.noreply@github.com |
5ea07ba0746c619cb464aa91a259240b977c8aa6 | 32ca6fefb239009c47ac5253fc64a15a4e1bf9f1 | /Cplusplus/WRF/WRFVisualization/Src/tcdsmModel/model.cpp | 91e73aac1a8b4cd6ed5cbe0514d88c31d770852b | [] | no_license | szmybs/PhysIKA_Cloud | aa371dc333703e7e0f963b249adbb6c90c7b41f2 | 9ad022d31e64fa48e5e1a9a2ae8e6702a3b321a1 | refs/heads/main | 2023-04-25T08:45:33.801882 | 2021-05-07T06:04:11 | 2021-05-07T06:04:11 | 312,967,199 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 151 | cpp | #include <tcdsmModel/model.h>
//#include <easylogging++.h>
using namespace TCDSM::Model;
//using namespace std;
AbstractModel::AbstractModel()
{
}
| [
"237735890@qq.com"
] | 237735890@qq.com |
8345f00b18a07272bc462147fdfc1e9a3cdd334c | dac5d10c7d53f766e496da8a9cfe06d6c20e29ae | /hdoj/1863.cpp | 32ff8875deedf812899b3fd05425a3d400dd8fda | [] | no_license | koalaink/hdoj | b2f8842cc7a1082f620f593d7480a94da6fe9b20 | b608f46736680c272e8870071c17c5ed82b50da9 | refs/heads/master | 2020-06-14T10:10:29.557015 | 2016-11-30T15:45:39 | 2016-11-30T15:45:39 | 75,200,182 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,170 | cpp | #include<algorithm>
#include<iostream>
#include<stdio.h>
using namespace std;
struct Node{
int x , y , val ;
};
const int MAX_V = 105 ;
const int MAX_E = MAX_V*(MAX_V-1)/2 ;
Node edge[MAX_E] ;
int father[MAX_V] ;
int son[MAX_V] ;
int n , m ;
int block , ans ;
bool cmp( const Node& a , const Node& b ){
return a.val < b.val ;
}
void Init(){
block = m ;
ans = 0 ;
for( int i = 1 ; i <= m ; ++i ){
father[i] = i ;
son[i] = 1 ;
}
return ;
}
int find( int x ){
if( x != father[x] )
father[x] = find(father[x]) ;
return father[x] ;
}
void Union( Node e ){
int x = find(e.x) ;
int y = find(e.y) ;
if( x != y ){
--block ;
ans += e.val ;
if( son[x] >= son[y] ){
father[y] = x ;
son[x] += son[y] ;
}
else{
father[x] = y ;
son[y] += son[x] ;
}
}
return ;
}
int main(){
while( scanf( "%d%d" , &n , &m ) , n ){
for( int i = 0 ; i < n ; ++i )
scanf( "%d%d%d" , &edge[i].x , &edge[i].y , &edge[i].val ) ;
sort( edge , edge+n , cmp );
Init() ;
for( int i = 0 ; i < n ; ++i ){
Union(edge[i]) ;
if( block == 1 )
break ;
}
if( block == 1 )
printf( "%d\n" , ans ) ;
else
printf( "?\n" );
}
return 0 ;
} | [
"Huibin Dai"
] | Huibin Dai |
5e607c29484716ee5190f7773e6c0f3e4809250d | c6bddd88916e6c8697a9e02485bd22c58d76bcec | /GeneratedPlaceholders/Mordhau/MordhauBeaconHost.h | 5bd7101aff5ea00cda93921647331ce574aedd32 | [] | no_license | GIRU-GIRU/Mordhau-Unofficial-SDK | 18d13d62d746a838820e387907d13b0a37aed654 | f831d7355cf553b81fb6e82468b3abf68f7955aa | refs/heads/master | 2020-07-06T03:36:48.908227 | 2020-04-22T13:54:00 | 2020-04-22T13:54:00 | 202,872,898 | 7 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 253 | h | #pragma once
#include "CoreMinimal.h"
#include "MordhauBeaconHost.generated.h"
UCLASS()
class AMordhauBeaconHost : public AOnlineBeaconHostObject
{
GENERATED_BODY()
public:
UPROPERTY(Replicated, EditAnywhere, BlueprintReadWrite)
int OpenSlots;
}; | [
"45307738+crypdos@users.noreply.github.com"
] | 45307738+crypdos@users.noreply.github.com |
a8be3aacc93b7adc483a0d050b190e902ae92c68 | 3a79dbfa4745da59ee29ecc880970dad4c4e412d | /shufflenetv2_final_solution/acceleartor_hls_final_solution/optimize_conv1/syn/systemc/ShuffleNetV2_8.cpp | d291a7fcf5ac38a56ed5ed8093e21e6f356bc27c | [] | no_license | loujc/shufflenetv2_hls | 90d70607e973a52fb846142fcf63ab3dcbc135d1 | db1e0901cefa4bb1b5a2d3a9c717cbd633210aa4 | refs/heads/master | 2021-10-28T04:36:11.344041 | 2019-04-22T02:10:58 | 2019-04-22T02:10:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 180,816 | cpp | #include "ShuffleNetV2.h"
#include "AESL_pkg.h"
using namespace std;
namespace ap_rtl {
void ShuffleNetV2::thread_tmp_1311_fu_17053_p3() {
tmp_1311_fu_17053_p3 = esl_concat<10,5>(tmp_514_reg_37331.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1312_fu_17064_p3() {
tmp_1312_fu_17064_p3 = esl_concat<10,3>(tmp_514_reg_37331.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1313_fu_17075_p2() {
tmp_1313_fu_17075_p2 = (!p_shl423_cast_fu_17060_p1.read().is_01() || !p_shl424_cast_fu_17071_p1.read().is_01())? sc_lv<16>(): (sc_biguint<16>(p_shl423_cast_fu_17060_p1.read()) - sc_biguint<16>(p_shl424_cast_fu_17071_p1.read()));
}
void ShuffleNetV2::thread_tmp_1314_fu_17085_p2() {
tmp_1314_fu_17085_p2 = (!tmp_504_cast_reg_37318.read().is_01() || !tmp_1501_cast_fu_17081_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(tmp_504_cast_reg_37318.read()) + sc_bigint<17>(tmp_1501_cast_fu_17081_p1.read()));
}
void ShuffleNetV2::thread_tmp_1315_fu_17022_p3() {
tmp_1315_fu_17022_p3 = esl_concat<4,6>(tmp_515_fu_17012_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1316_fu_17030_p3() {
tmp_1316_fu_17030_p3 = esl_concat<4,4>(tmp_515_fu_17012_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1317_fu_17042_p2() {
tmp_1317_fu_17042_p2 = (!tmp_1315_fu_17022_p3.read().is_01() || !p_shl422_cast_fu_17038_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1315_fu_17022_p3.read()) - sc_bigint<10>(p_shl422_cast_fu_17038_p1.read()));
}
void ShuffleNetV2::thread_tmp_1318_fu_17048_p2() {
tmp_1318_fu_17048_p2 = (!tmp_503_cast_reg_37313.read().is_01() || !tmp_1317_fu_17042_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_503_cast_reg_37313.read()) + sc_biguint<10>(tmp_1317_fu_17042_p2.read()));
}
void ShuffleNetV2::thread_tmp_1319_fu_17621_p1() {
tmp_1319_fu_17621_p1 = co82_reg_5796.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1320_cast_fu_13281_p1() {
tmp_1320_cast_fu_13281_p1 = esl_sext<16,15>(tmp_1165_fu_13275_p2.read());
}
void ShuffleNetV2::thread_tmp_1320_fu_17521_p1() {
tmp_1320_fu_17521_p1 = k22_reg_5785.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1321_cast_fu_13290_p1() {
tmp_1321_cast_fu_13290_p1 = esl_sext<33,16>(tmp_1166_fu_13285_p2.read());
}
void ShuffleNetV2::thread_tmp_1321_fu_17304_p1() {
tmp_1321_fu_17304_p1 = i70_reg_5763.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1322_fu_17365_p3() {
tmp_1322_fu_17365_p3 = esl_concat<7,2>(tmp_528_reg_37496.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1323_fu_17372_p1() {
tmp_1323_fu_17372_p1 = esl_sext<34,9>(tmp_1322_fu_17365_p3.read());
}
void ShuffleNetV2::thread_tmp_1324_fu_17380_p2() {
tmp_1324_fu_17380_p2 = (!p_shl428_cast_fu_17376_p1.read().is_01() || !tmp_529_cast_fu_17361_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl428_cast_fu_17376_p1.read()) - sc_biguint<35>(tmp_529_cast_fu_17361_p1.read()));
}
void ShuffleNetV2::thread_tmp_1325_fu_17390_p2() {
tmp_1325_fu_17390_p2 = (!tmp_1517_cast_fu_17386_p1.read().is_01() || !tmp_516_cast1_reg_37465.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_1517_cast_fu_17386_p1.read()) + sc_biguint<36>(tmp_516_cast1_reg_37465.read()));
}
void ShuffleNetV2::thread_tmp_1326_fu_17395_p1() {
tmp_1326_fu_17395_p1 = tmp_1325_fu_17390_p2.read().range(10-1, 0);
}
void ShuffleNetV2::thread_tmp_1327_cast_fu_13309_p1() {
tmp_1327_cast_fu_13309_p1 = esl_sext<64,10>(tmp_1170_reg_35975.read());
}
void ShuffleNetV2::thread_tmp_1327_fu_17399_p1() {
tmp_1327_fu_17399_p1 = tmp_1325_fu_17390_p2.read().range(8-1, 0);
}
void ShuffleNetV2::thread_tmp_1328_fu_17439_p2() {
tmp_1328_fu_17439_p2 = (!p_shl427_cast_fu_17432_p3.read().is_01() || !tmp_1326_reg_37508.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl427_cast_fu_17432_p3.read()) - sc_biguint<10>(tmp_1326_reg_37508.read()));
}
void ShuffleNetV2::thread_tmp_1329_fu_17444_p2() {
tmp_1329_fu_17444_p2 = (!tmp_1328_fu_17439_p2.read().is_01() || !tmp_523_cast1_reg_37483.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1328_fu_17439_p2.read()) + sc_biguint<10>(tmp_523_cast1_reg_37483.read()));
}
void ShuffleNetV2::thread_tmp_1330_fu_17406_p3() {
tmp_1330_fu_17406_p3 = esl_concat<9,2>(tmp_530_reg_37502.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1331_fu_17417_p2() {
tmp_1331_fu_17417_p2 = (!p_shl426_cast_fu_17413_p1.read().is_01() || !tmp_531_cast_fu_17403_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(p_shl426_cast_fu_17413_p1.read()) - sc_biguint<12>(tmp_531_cast_fu_17403_p1.read()));
}
void ShuffleNetV2::thread_tmp_1332_fu_17427_p2() {
tmp_1332_fu_17427_p2 = (!tmp_1523_cast_fu_17423_p1.read().is_01() || !tmp_516_cast_reg_37460.read().is_01())? sc_lv<13>(): (sc_bigint<13>(tmp_1523_cast_fu_17423_p1.read()) + sc_biguint<13>(tmp_516_cast_reg_37460.read()));
}
void ShuffleNetV2::thread_tmp_1333_fu_17452_p3() {
tmp_1333_fu_17452_p3 = esl_concat<13,2>(tmp_1332_reg_37518.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1334_fu_17463_p2() {
tmp_1334_fu_17463_p2 = (!p_shl231_fu_17459_p1.read().is_01() || !tmp_1524_cast_fu_17449_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl231_fu_17459_p1.read()) - sc_bigint<64>(tmp_1524_cast_fu_17449_p1.read()));
}
void ShuffleNetV2::thread_tmp_1335_fu_17469_p2() {
tmp_1335_fu_17469_p2 = (!tmp_1334_fu_17463_p2.read().is_01() || !tmp_523_reg_37478.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_1334_fu_17463_p2.read()) + sc_biguint<64>(tmp_523_reg_37478.read()));
}
void ShuffleNetV2::thread_tmp_1336_cast_fu_13586_p1() {
tmp_1336_cast_fu_13586_p1 = esl_sext<36,35>(tmp_1176_fu_13580_p2.read());
}
void ShuffleNetV2::thread_tmp_1336_fu_18049_p3() {
tmp_1336_fu_18049_p3 = esl_concat<6,3>(co84_reg_5851.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1337_fu_18061_p3() {
tmp_1337_fu_18061_p3 = esl_concat<6,1>(co84_reg_5851.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1338_fu_18073_p2() {
tmp_1338_fu_18073_p2 = (!p_shl434_cast_fu_18069_p1.read().is_01() || !p_shl433_cast_fu_18057_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl434_cast_fu_18069_p1.read()) + sc_biguint<10>(p_shl433_cast_fu_18057_p1.read()));
}
void ShuffleNetV2::thread_tmp_1339_fu_17953_p1() {
tmp_1339_fu_17953_p1 = k24_reg_5840.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1340_cast_fu_13685_p1() {
tmp_1340_cast_fu_13685_p1 = esl_zext<64,10>(tmp_1181_reg_36158.read());
}
void ShuffleNetV2::thread_tmp_1340_fu_17720_p1() {
tmp_1340_fu_17720_p1 = i72_reg_5818.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1341_fu_17754_p1() {
tmp_1341_fu_17754_p1 = tmp_537_fu_17748_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1342_cast_fu_13623_p1() {
tmp_1342_cast_fu_13623_p1 = esl_sext<12,11>(tmp_1183_fu_13617_p2.read());
}
void ShuffleNetV2::thread_tmp_1342_fu_17854_p3() {
tmp_1342_fu_17854_p3 = esl_concat<10,5>(tmp_540_reg_37631.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1343_cast_fu_13649_p1() {
tmp_1343_cast_fu_13649_p1 = esl_sext<64,12>(tmp_1184_reg_36152.read());
}
void ShuffleNetV2::thread_tmp_1343_fu_17865_p3() {
tmp_1343_fu_17865_p3 = esl_concat<10,3>(tmp_540_reg_37631.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1344_fu_17876_p2() {
tmp_1344_fu_17876_p2 = (!p_shl431_cast_fu_17861_p1.read().is_01() || !p_shl432_cast_fu_17872_p1.read().is_01())? sc_lv<16>(): (sc_biguint<16>(p_shl431_cast_fu_17861_p1.read()) - sc_biguint<16>(p_shl432_cast_fu_17872_p1.read()));
}
void ShuffleNetV2::thread_tmp_1345_fu_17886_p2() {
tmp_1345_fu_17886_p2 = (!tmp_526_cast_reg_37618.read().is_01() || !tmp_1539_cast_fu_17882_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(tmp_526_cast_reg_37618.read()) + sc_bigint<17>(tmp_1539_cast_fu_17882_p1.read()));
}
void ShuffleNetV2::thread_tmp_1346_fu_17823_p3() {
tmp_1346_fu_17823_p3 = esl_concat<4,6>(tmp_541_fu_17813_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1347_fu_17831_p3() {
tmp_1347_fu_17831_p3 = esl_concat<4,4>(tmp_541_fu_17813_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1348_fu_17843_p2() {
tmp_1348_fu_17843_p2 = (!tmp_1346_fu_17823_p3.read().is_01() || !p_shl430_cast_fu_17839_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1346_fu_17823_p3.read()) - sc_bigint<10>(p_shl430_cast_fu_17839_p1.read()));
}
void ShuffleNetV2::thread_tmp_1349_fu_17849_p2() {
tmp_1349_fu_17849_p2 = (!tmp_525_cast_reg_37613.read().is_01() || !tmp_1348_fu_17843_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_525_cast_reg_37613.read()) + sc_biguint<10>(tmp_1348_fu_17843_p2.read()));
}
void ShuffleNetV2::thread_tmp_1350_fu_18172_p3() {
tmp_1350_fu_18172_p3 = esl_concat<6,3>(co86_reg_5884.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1351_fu_18184_p3() {
tmp_1351_fu_18184_p3 = esl_concat<6,1>(co86_reg_5884.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1352_fu_18196_p2() {
tmp_1352_fu_18196_p2 = (!p_shl440_cast_fu_18192_p1.read().is_01() || !p_shl439_cast_fu_18180_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl440_cast_fu_18192_p1.read()) + sc_biguint<10>(p_shl439_cast_fu_18180_p1.read()));
}
void ShuffleNetV2::thread_tmp_1353_fu_18208_p3() {
tmp_1353_fu_18208_p3 = esl_concat<7,3>(tmp_542_fu_18202_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1354_fu_18220_p3() {
tmp_1354_fu_18220_p3 = esl_concat<7,1>(tmp_542_fu_18202_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1355_cast_fu_14082_p1() {
tmp_1355_cast_fu_14082_p1 = esl_sext<16,15>(tmp_1193_fu_14076_p2.read());
}
void ShuffleNetV2::thread_tmp_1355_fu_18232_p2() {
tmp_1355_fu_18232_p2 = (!p_shl438_cast_fu_18228_p1.read().is_01() || !p_shl437_cast_fu_18216_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl438_cast_fu_18228_p1.read()) + sc_biguint<11>(p_shl437_cast_fu_18216_p1.read()));
}
void ShuffleNetV2::thread_tmp_1356_cast_fu_14091_p1() {
tmp_1356_cast_fu_14091_p1 = esl_sext<33,16>(tmp_1194_fu_14086_p2.read());
}
void ShuffleNetV2::thread_tmp_1356_fu_18095_p2() {
tmp_1356_fu_18095_p2 = (!tmp_543_cast_fu_18091_p1.read().is_01() || !tmp_1338_reg_37742.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_543_cast_fu_18091_p1.read()) + sc_biguint<10>(tmp_1338_reg_37742.read()));
}
void ShuffleNetV2::thread_tmp_1357_fu_18100_p3() {
tmp_1357_fu_18100_p3 = esl_concat<10,3>(tmp_1356_fu_18095_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1358_fu_18112_p3() {
tmp_1358_fu_18112_p3 = esl_concat<10,1>(tmp_1356_fu_18095_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1359_fu_18124_p2() {
tmp_1359_fu_18124_p2 = (!p_shl435_cast_fu_18108_p1.read().is_01() || !p_shl436_cast_fu_18120_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl435_cast_fu_18108_p1.read()) + sc_biguint<15>(p_shl436_cast_fu_18120_p1.read()));
}
void ShuffleNetV2::thread_tmp_1360_fu_18383_p1() {
tmp_1360_fu_18383_p1 = co88_reg_5917.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1361_fu_18258_p2() {
tmp_1361_fu_18258_p2 = (!tmp_545_cast_fu_18254_p1.read().is_01() || !tmp_1355_reg_37791.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_545_cast_fu_18254_p1.read()) + sc_biguint<11>(tmp_1355_reg_37791.read()));
}
void ShuffleNetV2::thread_tmp_1362_cast_fu_14110_p1() {
tmp_1362_cast_fu_14110_p1 = esl_sext<64,10>(tmp_1198_reg_36275.read());
}
void ShuffleNetV2::thread_tmp_1362_fu_18263_p3() {
tmp_1362_fu_18263_p3 = esl_concat<11,3>(tmp_1361_fu_18258_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1363_fu_18275_p3() {
tmp_1363_fu_18275_p3 = esl_concat<11,1>(tmp_1361_fu_18258_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1364_fu_18287_p2() {
tmp_1364_fu_18287_p2 = (!p_shl443_cast_fu_18271_p1.read().is_01() || !p_shl444_cast_fu_18283_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl443_cast_fu_18271_p1.read()) + sc_biguint<15>(p_shl444_cast_fu_18283_p1.read()));
}
void ShuffleNetV2::thread_tmp_1365_fu_18293_p2() {
tmp_1365_fu_18293_p2 = (!tmp_545_cast1_fu_18250_p1.read().is_01() || !tmp_1352_reg_37786.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_545_cast1_fu_18250_p1.read()) + sc_biguint<10>(tmp_1352_reg_37786.read()));
}
void ShuffleNetV2::thread_tmp_1366_fu_18298_p3() {
tmp_1366_fu_18298_p3 = esl_concat<10,3>(tmp_1365_fu_18293_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1367_fu_18310_p3() {
tmp_1367_fu_18310_p3 = esl_concat<10,1>(tmp_1365_fu_18293_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1368_fu_18322_p2() {
tmp_1368_fu_18322_p2 = (!p_shl441_cast_fu_18306_p1.read().is_01() || !p_shl442_cast_fu_18318_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl441_cast_fu_18306_p1.read()) + sc_biguint<14>(p_shl442_cast_fu_18318_p1.read()));
}
void ShuffleNetV2::thread_tmp_1369_fu_18146_p2() {
tmp_1369_fu_18146_p2 = (!tmp_1359_reg_37755.read().is_01() || !tmp_546_cast_fu_18142_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1359_reg_37755.read()) + sc_biguint<15>(tmp_546_cast_fu_18142_p1.read()));
}
void ShuffleNetV2::thread_tmp_1370_fu_18348_p2() {
tmp_1370_fu_18348_p2 = (!tmp_1364_reg_37804.read().is_01() || !tmp_550_cast_fu_18344_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1364_reg_37804.read()) + sc_biguint<15>(tmp_550_cast_fu_18344_p1.read()));
}
void ShuffleNetV2::thread_tmp_1371_cast_fu_14391_p1() {
tmp_1371_cast_fu_14391_p1 = esl_sext<36,35>(tmp_1204_fu_14385_p2.read());
}
void ShuffleNetV2::thread_tmp_1371_fu_18358_p2() {
tmp_1371_fu_18358_p2 = (!tmp_1368_reg_37809.read().is_01() || !tmp_550_cast1_fu_18340_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_1368_reg_37809.read()) + sc_biguint<14>(tmp_550_cast1_fu_18340_p1.read()));
}
void ShuffleNetV2::thread_tmp_1372_fu_18723_p1() {
tmp_1372_fu_18723_p1 = k26_reg_5961.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1373_fu_18482_p1() {
tmp_1373_fu_18482_p1 = i76_reg_5939.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1374_fu_18516_p1() {
tmp_1374_fu_18516_p1 = tmp_556_fu_18510_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1375_cast_fu_14486_p1() {
tmp_1375_cast_fu_14486_p1 = esl_zext<64,10>(tmp_1209_reg_36458.read());
}
void ShuffleNetV2::thread_tmp_1375_fu_18616_p3() {
tmp_1375_fu_18616_p3 = esl_concat<9,5>(tmp_559_reg_37886.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1376_fu_18623_p1() {
tmp_1376_fu_18623_p1 = esl_sext<15,14>(tmp_1375_fu_18616_p3.read());
}
void ShuffleNetV2::thread_tmp_1377_fu_18631_p3() {
tmp_1377_fu_18631_p3 = esl_concat<9,3>(tmp_559_reg_37886.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1378_cast_fu_14450_p1() {
tmp_1378_cast_fu_14450_p1 = esl_sext<64,11>(tmp_1212_reg_36452.read());
}
void ShuffleNetV2::thread_tmp_1378_fu_18638_p1() {
tmp_1378_fu_18638_p1 = esl_sext<13,12>(tmp_1377_fu_18631_p3.read());
}
void ShuffleNetV2::thread_tmp_1379_fu_18646_p2() {
tmp_1379_fu_18646_p2 = (!p_shl447_cast_fu_18627_p1.read().is_01() || !p_shl448_cast_fu_18642_p1.read().is_01())? sc_lv<16>(): (sc_biguint<16>(p_shl447_cast_fu_18627_p1.read()) - sc_biguint<16>(p_shl448_cast_fu_18642_p1.read()));
}
void ShuffleNetV2::thread_tmp_1380_fu_18656_p2() {
tmp_1380_fu_18656_p2 = (!tmp_549_cast_reg_37873.read().is_01() || !tmp_1580_cast_fu_18652_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(tmp_549_cast_reg_37873.read()) + sc_bigint<17>(tmp_1580_cast_fu_18652_p1.read()));
}
void ShuffleNetV2::thread_tmp_1381_fu_18585_p3() {
tmp_1381_fu_18585_p3 = esl_concat<4,6>(tmp_560_fu_18575_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1382_fu_18593_p3() {
tmp_1382_fu_18593_p3 = esl_concat<4,4>(tmp_560_fu_18575_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1383_fu_18605_p2() {
tmp_1383_fu_18605_p2 = (!tmp_1381_fu_18585_p3.read().is_01() || !p_shl446_cast_fu_18601_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1381_fu_18585_p3.read()) - sc_bigint<10>(p_shl446_cast_fu_18601_p1.read()));
}
void ShuffleNetV2::thread_tmp_1384_fu_18611_p2() {
tmp_1384_fu_18611_p2 = (!tmp_548_cast_reg_37868.read().is_01() || !tmp_1383_fu_18605_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_548_cast_reg_37868.read()) + sc_biguint<10>(tmp_1383_fu_18605_p2.read()));
}
void ShuffleNetV2::thread_tmp_1385_fu_19192_p1() {
tmp_1385_fu_19192_p1 = co92_reg_6038.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1386_fu_19092_p1() {
tmp_1386_fu_19092_p1 = k28_reg_6027.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1387_fu_18879_p1() {
tmp_1387_fu_18879_p1 = i81_reg_6005.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1388_fu_18940_p3() {
tmp_1388_fu_18940_p3 = esl_concat<7,2>(tmp_573_reg_38051.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1389_fu_18947_p1() {
tmp_1389_fu_18947_p1 = esl_sext<34,9>(tmp_1388_fu_18940_p3.read());
}
void ShuffleNetV2::thread_tmp_1390_fu_18955_p2() {
tmp_1390_fu_18955_p2 = (!p_shl452_cast_fu_18951_p1.read().is_01() || !tmp_574_cast_fu_18936_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl452_cast_fu_18951_p1.read()) - sc_biguint<35>(tmp_574_cast_fu_18936_p1.read()));
}
void ShuffleNetV2::thread_tmp_1391_fu_18965_p2() {
tmp_1391_fu_18965_p2 = (!tmp_1596_cast_fu_18961_p1.read().is_01() || !tmp_561_cast_reg_38020.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_1596_cast_fu_18961_p1.read()) + sc_biguint<36>(tmp_561_cast_reg_38020.read()));
}
void ShuffleNetV2::thread_tmp_1392_fu_18970_p1() {
tmp_1392_fu_18970_p1 = tmp_1391_fu_18965_p2.read().range(10-1, 0);
}
void ShuffleNetV2::thread_tmp_1393_fu_18974_p1() {
tmp_1393_fu_18974_p1 = tmp_1391_fu_18965_p2.read().range(8-1, 0);
}
void ShuffleNetV2::thread_tmp_1394_fu_19010_p2() {
tmp_1394_fu_19010_p2 = (!p_shl451_cast_fu_19003_p3.read().is_01() || !tmp_1392_reg_38063.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl451_cast_fu_19003_p3.read()) - sc_biguint<10>(tmp_1392_reg_38063.read()));
}
void ShuffleNetV2::thread_tmp_1395_fu_19015_p2() {
tmp_1395_fu_19015_p2 = (!tmp_1394_fu_19010_p2.read().is_01() || !tmp_568_cast1_reg_38038.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1394_fu_19010_p2.read()) + sc_biguint<10>(tmp_568_cast1_reg_38038.read()));
}
void ShuffleNetV2::thread_tmp_1396_cast_fu_14883_p1() {
tmp_1396_cast_fu_14883_p1 = esl_sext<17,16>(tmp_1227_fu_14877_p2.read());
}
void ShuffleNetV2::thread_tmp_1396_fu_18981_p3() {
tmp_1396_fu_18981_p3 = esl_concat<9,2>(tmp_575_reg_38057.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1397_cast_fu_14892_p1() {
tmp_1397_cast_fu_14892_p1 = esl_sext<33,17>(tmp_1228_fu_14887_p2.read());
}
void ShuffleNetV2::thread_tmp_1397_fu_18992_p2() {
tmp_1397_fu_18992_p2 = (!p_shl450_cast_fu_18988_p1.read().is_01() || !tmp_576_cast_fu_18978_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(p_shl450_cast_fu_18988_p1.read()) - sc_biguint<12>(tmp_576_cast_fu_18978_p1.read()));
}
void ShuffleNetV2::thread_tmp_1398_fu_18998_p2() {
tmp_1398_fu_18998_p2 = (!tmp_1397_fu_18992_p2.read().is_01() || !tmp_561_cast1_reg_38015.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1397_fu_18992_p2.read()) + sc_biguint<12>(tmp_561_cast1_reg_38015.read()));
}
void ShuffleNetV2::thread_tmp_1399_fu_19023_p3() {
tmp_1399_fu_19023_p3 = esl_concat<12,2>(tmp_1398_reg_38073.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1400_fu_19034_p2() {
tmp_1400_fu_19034_p2 = (!p_shl237_fu_19030_p1.read().is_01() || !tmp_1603_cast_fu_19020_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl237_fu_19030_p1.read()) - sc_bigint<64>(tmp_1603_cast_fu_19020_p1.read()));
}
void ShuffleNetV2::thread_tmp_1401_fu_19040_p2() {
tmp_1401_fu_19040_p2 = (!tmp_1400_fu_19034_p2.read().is_01() || !tmp_568_reg_38033.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_1400_fu_19034_p2.read()) + sc_biguint<64>(tmp_568_reg_38033.read()));
}
void ShuffleNetV2::thread_tmp_1402_fu_19620_p3() {
tmp_1402_fu_19620_p3 = esl_concat<6,3>(co94_reg_6093.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1403_cast_fu_14911_p1() {
tmp_1403_cast_fu_14911_p1 = esl_sext<64,10>(tmp_1232_reg_36575.read());
}
void ShuffleNetV2::thread_tmp_1403_fu_19632_p3() {
tmp_1403_fu_19632_p3 = esl_concat<6,1>(co94_reg_6093.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1404_fu_19644_p2() {
tmp_1404_fu_19644_p2 = (!p_shl458_cast_fu_19640_p1.read().is_01() || !p_shl457_cast_fu_19628_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl458_cast_fu_19640_p1.read()) + sc_biguint<10>(p_shl457_cast_fu_19628_p1.read()));
}
void ShuffleNetV2::thread_tmp_1405_fu_19524_p1() {
tmp_1405_fu_19524_p1 = k30_reg_6082.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1406_fu_19291_p1() {
tmp_1406_fu_19291_p1 = i83_reg_6060.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1407_fu_19325_p1() {
tmp_1407_fu_19325_p1 = tmp_582_fu_19319_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1408_fu_19425_p3() {
tmp_1408_fu_19425_p3 = esl_concat<11,5>(tmp_585_reg_38186.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1409_fu_19436_p3() {
tmp_1409_fu_19436_p3 = esl_concat<11,3>(tmp_585_reg_38186.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1410_fu_19447_p2() {
tmp_1410_fu_19447_p2 = (!p_shl455_cast_fu_19432_p1.read().is_01() || !p_shl456_cast_fu_19443_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(p_shl455_cast_fu_19432_p1.read()) - sc_biguint<17>(p_shl456_cast_fu_19443_p1.read()));
}
void ShuffleNetV2::thread_tmp_1411_fu_19457_p2() {
tmp_1411_fu_19457_p2 = (!tmp_571_cast_reg_38173.read().is_01() || !tmp_1618_cast_fu_19453_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(tmp_571_cast_reg_38173.read()) + sc_bigint<18>(tmp_1618_cast_fu_19453_p1.read()));
}
void ShuffleNetV2::thread_tmp_1412_fu_19394_p3() {
tmp_1412_fu_19394_p3 = esl_concat<4,6>(tmp_586_fu_19384_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1413_fu_19402_p3() {
tmp_1413_fu_19402_p3 = esl_concat<4,4>(tmp_586_fu_19384_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1414_cast_fu_15231_p1() {
tmp_1414_cast_fu_15231_p1 = esl_zext<64,15>(tmp_1242_fu_15226_p2.read());
}
void ShuffleNetV2::thread_tmp_1414_fu_19414_p2() {
tmp_1414_fu_19414_p2 = (!tmp_1412_fu_19394_p3.read().is_01() || !p_shl454_cast_fu_19410_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1412_fu_19394_p3.read()) - sc_bigint<10>(p_shl454_cast_fu_19410_p1.read()));
}
void ShuffleNetV2::thread_tmp_1415_cast_fu_15241_p1() {
tmp_1415_cast_fu_15241_p1 = esl_zext<64,14>(tmp_1243_reg_36717.read());
}
void ShuffleNetV2::thread_tmp_1415_fu_19420_p2() {
tmp_1415_fu_19420_p2 = (!tmp_570_cast_reg_38168.read().is_01() || !tmp_1414_fu_19414_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_570_cast_reg_38168.read()) + sc_biguint<10>(tmp_1414_fu_19414_p2.read()));
}
void ShuffleNetV2::thread_tmp_1416_fu_19743_p3() {
tmp_1416_fu_19743_p3 = esl_concat<6,3>(co96_reg_6126.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1417_fu_19755_p3() {
tmp_1417_fu_19755_p3 = esl_concat<6,1>(co96_reg_6126.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1418_fu_19767_p2() {
tmp_1418_fu_19767_p2 = (!p_shl464_cast_fu_19763_p1.read().is_01() || !p_shl463_cast_fu_19751_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl464_cast_fu_19763_p1.read()) + sc_biguint<10>(p_shl463_cast_fu_19751_p1.read()));
}
void ShuffleNetV2::thread_tmp_1419_fu_19779_p3() {
tmp_1419_fu_19779_p3 = esl_concat<7,3>(tmp_587_fu_19773_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1420_fu_19791_p3() {
tmp_1420_fu_19791_p3 = esl_concat<7,1>(tmp_587_fu_19773_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1421_fu_19803_p2() {
tmp_1421_fu_19803_p2 = (!p_shl462_cast_fu_19799_p1.read().is_01() || !p_shl461_cast_fu_19787_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl462_cast_fu_19799_p1.read()) + sc_biguint<11>(p_shl461_cast_fu_19787_p1.read()));
}
void ShuffleNetV2::thread_tmp_1422_fu_19666_p2() {
tmp_1422_fu_19666_p2 = (!tmp_588_cast_fu_19662_p1.read().is_01() || !tmp_1404_reg_38297.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_588_cast_fu_19662_p1.read()) + sc_biguint<10>(tmp_1404_reg_38297.read()));
}
void ShuffleNetV2::thread_tmp_1423_fu_19671_p3() {
tmp_1423_fu_19671_p3 = esl_concat<10,3>(tmp_1422_fu_19666_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1424_cast_fu_15522_p1() {
tmp_1424_cast_fu_15522_p1 = esl_sext<17,16>(tmp_1249_fu_15516_p2.read());
}
void ShuffleNetV2::thread_tmp_1424_fu_19683_p3() {
tmp_1424_fu_19683_p3 = esl_concat<10,1>(tmp_1422_fu_19666_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1425_cast_fu_15531_p1() {
tmp_1425_cast_fu_15531_p1 = esl_sext<33,17>(tmp_1250_fu_15526_p2.read());
}
void ShuffleNetV2::thread_tmp_1425_fu_19695_p2() {
tmp_1425_fu_19695_p2 = (!p_shl459_cast_fu_19679_p1.read().is_01() || !p_shl460_cast_fu_19691_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl459_cast_fu_19679_p1.read()) + sc_biguint<15>(p_shl460_cast_fu_19691_p1.read()));
}
void ShuffleNetV2::thread_tmp_1426_fu_19954_p1() {
tmp_1426_fu_19954_p1 = co98_reg_6159.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1427_fu_19829_p2() {
tmp_1427_fu_19829_p2 = (!tmp_590_cast_fu_19825_p1.read().is_01() || !tmp_1421_reg_38346.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_590_cast_fu_19825_p1.read()) + sc_biguint<11>(tmp_1421_reg_38346.read()));
}
void ShuffleNetV2::thread_tmp_1428_fu_19834_p3() {
tmp_1428_fu_19834_p3 = esl_concat<11,3>(tmp_1427_fu_19829_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1429_fu_19846_p3() {
tmp_1429_fu_19846_p3 = esl_concat<11,1>(tmp_1427_fu_19829_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1430_fu_19858_p2() {
tmp_1430_fu_19858_p2 = (!p_shl467_cast_fu_19842_p1.read().is_01() || !p_shl468_cast_fu_19854_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl467_cast_fu_19842_p1.read()) + sc_biguint<15>(p_shl468_cast_fu_19854_p1.read()));
}
void ShuffleNetV2::thread_tmp_1431_cast_fu_15550_p1() {
tmp_1431_cast_fu_15550_p1 = esl_sext<64,10>(tmp_1254_reg_36786.read());
}
void ShuffleNetV2::thread_tmp_1431_fu_19864_p2() {
tmp_1431_fu_19864_p2 = (!tmp_590_cast1_fu_19821_p1.read().is_01() || !tmp_1418_reg_38341.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_590_cast1_fu_19821_p1.read()) + sc_biguint<10>(tmp_1418_reg_38341.read()));
}
void ShuffleNetV2::thread_tmp_1432_fu_19869_p3() {
tmp_1432_fu_19869_p3 = esl_concat<10,3>(tmp_1431_fu_19864_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1433_fu_19881_p3() {
tmp_1433_fu_19881_p3 = esl_concat<10,1>(tmp_1431_fu_19864_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1434_fu_19893_p2() {
tmp_1434_fu_19893_p2 = (!p_shl465_cast_fu_19877_p1.read().is_01() || !p_shl466_cast_fu_19889_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl465_cast_fu_19877_p1.read()) + sc_biguint<14>(p_shl466_cast_fu_19889_p1.read()));
}
void ShuffleNetV2::thread_tmp_1435_fu_19717_p2() {
tmp_1435_fu_19717_p2 = (!tmp_1425_reg_38310.read().is_01() || !tmp_591_cast_fu_19713_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1425_reg_38310.read()) + sc_biguint<15>(tmp_591_cast_fu_19713_p1.read()));
}
void ShuffleNetV2::thread_tmp_1436_fu_19919_p2() {
tmp_1436_fu_19919_p2 = (!tmp_1430_reg_38359.read().is_01() || !tmp_595_cast_fu_19915_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1430_reg_38359.read()) + sc_biguint<15>(tmp_595_cast_fu_19915_p1.read()));
}
void ShuffleNetV2::thread_tmp_1437_fu_19929_p2() {
tmp_1437_fu_19929_p2 = (!tmp_1434_reg_38364.read().is_01() || !tmp_595_cast1_fu_19911_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_1434_reg_38364.read()) + sc_biguint<14>(tmp_595_cast1_fu_19911_p1.read()));
}
void ShuffleNetV2::thread_tmp_1438_fu_20286_p1() {
tmp_1438_fu_20286_p1 = k32_reg_6203.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1439_fu_20053_p1() {
tmp_1439_fu_20053_p1 = i87_reg_6181.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1440_cast_fu_15831_p1() {
tmp_1440_cast_fu_15831_p1 = esl_sext<36,35>(tmp_1260_fu_15825_p2.read());
}
void ShuffleNetV2::thread_tmp_1440_fu_20087_p1() {
tmp_1440_fu_20087_p1 = tmp_601_fu_20081_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1441_fu_20187_p3() {
tmp_1441_fu_20187_p3 = esl_concat<11,5>(tmp_604_reg_38441.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1442_fu_20198_p3() {
tmp_1442_fu_20198_p3 = esl_concat<11,3>(tmp_604_reg_38441.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1443_fu_20209_p2() {
tmp_1443_fu_20209_p2 = (!p_shl471_cast_fu_20194_p1.read().is_01() || !p_shl472_cast_fu_20205_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(p_shl471_cast_fu_20194_p1.read()) - sc_biguint<17>(p_shl472_cast_fu_20205_p1.read()));
}
void ShuffleNetV2::thread_tmp_1444_cast_fu_15930_p1() {
tmp_1444_cast_fu_15930_p1 = esl_zext<64,10>(tmp_1265_reg_36969.read());
}
void ShuffleNetV2::thread_tmp_1444_fu_20219_p2() {
tmp_1444_fu_20219_p2 = (!tmp_594_cast_reg_38428.read().is_01() || !tmp_1657_cast_fu_20215_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(tmp_594_cast_reg_38428.read()) + sc_bigint<18>(tmp_1657_cast_fu_20215_p1.read()));
}
void ShuffleNetV2::thread_tmp_1445_fu_20156_p3() {
tmp_1445_fu_20156_p3 = esl_concat<4,6>(tmp_605_fu_20146_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1446_cast_fu_15868_p1() {
tmp_1446_cast_fu_15868_p1 = esl_sext<13,12>(tmp_1267_fu_15862_p2.read());
}
void ShuffleNetV2::thread_tmp_1446_fu_20164_p3() {
tmp_1446_fu_20164_p3 = esl_concat<4,4>(tmp_605_fu_20146_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1447_cast_fu_15894_p1() {
tmp_1447_cast_fu_15894_p1 = esl_sext<64,13>(tmp_1268_reg_36963.read());
}
void ShuffleNetV2::thread_tmp_1447_fu_20176_p2() {
tmp_1447_fu_20176_p2 = (!tmp_1445_fu_20156_p3.read().is_01() || !p_shl470_cast_fu_20172_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1445_fu_20156_p3.read()) - sc_bigint<10>(p_shl470_cast_fu_20172_p1.read()));
}
void ShuffleNetV2::thread_tmp_1448_fu_20182_p2() {
tmp_1448_fu_20182_p2 = (!tmp_593_cast1_reg_38423.read().is_01() || !tmp_1447_fu_20176_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_593_cast1_reg_38423.read()) + sc_biguint<10>(tmp_1447_fu_20176_p2.read()));
}
void ShuffleNetV2::thread_tmp_1449_fu_20747_p1() {
tmp_1449_fu_20747_p1 = co102_reg_6280.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1450_fu_20651_p1() {
tmp_1450_fu_20651_p1 = k34_reg_6269.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1451_fu_20438_p1() {
tmp_1451_fu_20438_p1 = i92_reg_6247.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1452_fu_20499_p3() {
tmp_1452_fu_20499_p3 = esl_concat<7,2>(tmp_618_reg_38606.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1453_fu_20506_p1() {
tmp_1453_fu_20506_p1 = esl_sext<34,9>(tmp_1452_fu_20499_p3.read());
}
void ShuffleNetV2::thread_tmp_1454_fu_20514_p2() {
tmp_1454_fu_20514_p2 = (!p_shl476_cast_fu_20510_p1.read().is_01() || !tmp_619_cast_fu_20495_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl476_cast_fu_20510_p1.read()) - sc_biguint<35>(tmp_619_cast_fu_20495_p1.read()));
}
void ShuffleNetV2::thread_tmp_1455_fu_20524_p2() {
tmp_1455_fu_20524_p2 = (!tmp_1673_cast_fu_20520_p1.read().is_01() || !tmp_606_cast_reg_38575.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_1673_cast_fu_20520_p1.read()) + sc_biguint<36>(tmp_606_cast_reg_38575.read()));
}
void ShuffleNetV2::thread_tmp_1456_fu_20529_p1() {
tmp_1456_fu_20529_p1 = tmp_1455_fu_20524_p2.read().range(10-1, 0);
}
void ShuffleNetV2::thread_tmp_1457_fu_20533_p1() {
tmp_1457_fu_20533_p1 = tmp_1455_fu_20524_p2.read().range(8-1, 0);
}
void ShuffleNetV2::thread_tmp_1458_fu_20569_p2() {
tmp_1458_fu_20569_p2 = (!p_shl475_cast_fu_20562_p3.read().is_01() || !tmp_1456_reg_38618.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl475_cast_fu_20562_p3.read()) - sc_biguint<10>(tmp_1456_reg_38618.read()));
}
void ShuffleNetV2::thread_tmp_1459_fu_20574_p2() {
tmp_1459_fu_20574_p2 = (!tmp_1458_fu_20569_p2.read().is_01() || !tmp_613_cast1_reg_38593.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1458_fu_20569_p2.read()) + sc_biguint<10>(tmp_613_cast1_reg_38593.read()));
}
void ShuffleNetV2::thread_tmp_1460_fu_20540_p3() {
tmp_1460_fu_20540_p3 = esl_concat<9,2>(tmp_620_reg_38612.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1461_fu_20551_p2() {
tmp_1461_fu_20551_p2 = (!p_shl474_cast_fu_20547_p1.read().is_01() || !tmp_621_cast_fu_20537_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(p_shl474_cast_fu_20547_p1.read()) - sc_biguint<12>(tmp_621_cast_fu_20537_p1.read()));
}
void ShuffleNetV2::thread_tmp_1462_cast_fu_16323_p1() {
tmp_1462_cast_fu_16323_p1 = esl_sext<17,16>(tmp_1280_fu_16317_p2.read());
}
void ShuffleNetV2::thread_tmp_1462_fu_20557_p2() {
tmp_1462_fu_20557_p2 = (!tmp_1461_fu_20551_p2.read().is_01() || !tmp_606_cast1_reg_38570.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1461_fu_20551_p2.read()) + sc_biguint<12>(tmp_606_cast1_reg_38570.read()));
}
void ShuffleNetV2::thread_tmp_1463_cast_fu_16332_p1() {
tmp_1463_cast_fu_16332_p1 = esl_sext<33,17>(tmp_1281_fu_16327_p2.read());
}
void ShuffleNetV2::thread_tmp_1463_fu_20582_p3() {
tmp_1463_fu_20582_p3 = esl_concat<12,2>(tmp_1462_reg_38628.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1464_fu_20593_p2() {
tmp_1464_fu_20593_p2 = (!p_shl240_fu_20589_p1.read().is_01() || !tmp_1680_cast_fu_20579_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl240_fu_20589_p1.read()) - sc_bigint<64>(tmp_1680_cast_fu_20579_p1.read()));
}
void ShuffleNetV2::thread_tmp_1465_fu_20599_p2() {
tmp_1465_fu_20599_p2 = (!tmp_1464_fu_20593_p2.read().is_01() || !tmp_613_reg_38588.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_1464_fu_20593_p2.read()) + sc_biguint<64>(tmp_613_reg_38588.read()));
}
void ShuffleNetV2::thread_tmp_1466_fu_21171_p3() {
tmp_1466_fu_21171_p3 = esl_concat<6,3>(co104_reg_6335.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1467_fu_21183_p3() {
tmp_1467_fu_21183_p3 = esl_concat<6,1>(co104_reg_6335.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1468_fu_21195_p2() {
tmp_1468_fu_21195_p2 = (!p_shl482_cast_fu_21191_p1.read().is_01() || !p_shl481_cast_fu_21179_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl482_cast_fu_21191_p1.read()) + sc_biguint<10>(p_shl481_cast_fu_21179_p1.read()));
}
void ShuffleNetV2::thread_tmp_1469_cast_fu_16351_p1() {
tmp_1469_cast_fu_16351_p1 = esl_sext<64,10>(tmp_1285_reg_37086.read());
}
void ShuffleNetV2::thread_tmp_1469_fu_21079_p1() {
tmp_1469_fu_21079_p1 = k36_reg_6324.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1470_fu_20846_p1() {
tmp_1470_fu_20846_p1 = i94_reg_6302.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1471_fu_20880_p1() {
tmp_1471_fu_20880_p1 = tmp_627_fu_20874_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1472_fu_20980_p3() {
tmp_1472_fu_20980_p3 = esl_concat<11,5>(tmp_630_reg_38741.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1473_fu_20991_p3() {
tmp_1473_fu_20991_p3 = esl_concat<11,3>(tmp_630_reg_38741.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1474_fu_21002_p2() {
tmp_1474_fu_21002_p2 = (!p_shl479_cast_fu_20987_p1.read().is_01() || !p_shl480_cast_fu_20998_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(p_shl479_cast_fu_20987_p1.read()) - sc_biguint<17>(p_shl480_cast_fu_20998_p1.read()));
}
void ShuffleNetV2::thread_tmp_1475_fu_21012_p2() {
tmp_1475_fu_21012_p2 = (!tmp_616_cast_reg_38728.read().is_01() || !tmp_1695_cast_fu_21008_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(tmp_616_cast_reg_38728.read()) + sc_bigint<18>(tmp_1695_cast_fu_21008_p1.read()));
}
void ShuffleNetV2::thread_tmp_1476_fu_20949_p3() {
tmp_1476_fu_20949_p3 = esl_concat<4,6>(tmp_631_fu_20939_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1477_fu_20957_p3() {
tmp_1477_fu_20957_p3 = esl_concat<4,4>(tmp_631_fu_20939_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1478_fu_20969_p2() {
tmp_1478_fu_20969_p2 = (!tmp_1476_fu_20949_p3.read().is_01() || !p_shl478_cast_fu_20965_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1476_fu_20949_p3.read()) - sc_bigint<10>(p_shl478_cast_fu_20965_p1.read()));
}
void ShuffleNetV2::thread_tmp_1479_fu_20975_p2() {
tmp_1479_fu_20975_p2 = (!tmp_615_cast_reg_38723.read().is_01() || !tmp_1478_fu_20969_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_615_cast_reg_38723.read()) + sc_biguint<10>(tmp_1478_fu_20969_p2.read()));
}
void ShuffleNetV2::thread_tmp_1480_fu_21294_p3() {
tmp_1480_fu_21294_p3 = esl_concat<6,3>(co106_reg_6368.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1481_fu_21306_p3() {
tmp_1481_fu_21306_p3 = esl_concat<6,1>(co106_reg_6368.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1482_fu_21318_p2() {
tmp_1482_fu_21318_p2 = (!p_shl488_cast_fu_21314_p1.read().is_01() || !p_shl487_cast_fu_21302_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl488_cast_fu_21314_p1.read()) + sc_biguint<10>(p_shl487_cast_fu_21302_p1.read()));
}
void ShuffleNetV2::thread_tmp_1483_fu_21330_p3() {
tmp_1483_fu_21330_p3 = esl_concat<7,3>(tmp_632_fu_21324_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1484_fu_21342_p3() {
tmp_1484_fu_21342_p3 = esl_concat<7,1>(tmp_632_fu_21324_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1485_fu_21354_p2() {
tmp_1485_fu_21354_p2 = (!p_shl486_cast_fu_21350_p1.read().is_01() || !p_shl485_cast_fu_21338_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl486_cast_fu_21350_p1.read()) + sc_biguint<11>(p_shl485_cast_fu_21338_p1.read()));
}
void ShuffleNetV2::thread_tmp_1486_fu_21217_p2() {
tmp_1486_fu_21217_p2 = (!tmp_633_cast_fu_21213_p1.read().is_01() || !tmp_1468_reg_38852.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_633_cast_fu_21213_p1.read()) + sc_biguint<10>(tmp_1468_reg_38852.read()));
}
void ShuffleNetV2::thread_tmp_1487_fu_21222_p3() {
tmp_1487_fu_21222_p3 = esl_concat<10,3>(tmp_1486_fu_21217_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1488_fu_21234_p3() {
tmp_1488_fu_21234_p3 = esl_concat<10,1>(tmp_1486_fu_21217_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1489_fu_21246_p2() {
tmp_1489_fu_21246_p2 = (!p_shl483_cast_fu_21230_p1.read().is_01() || !p_shl484_cast_fu_21242_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl483_cast_fu_21230_p1.read()) + sc_biguint<15>(p_shl484_cast_fu_21242_p1.read()));
}
void ShuffleNetV2::thread_tmp_1490_cast_fu_16588_p1() {
tmp_1490_cast_fu_16588_p1 = esl_zext<64,15>(tmp_1305_fu_16583_p2.read());
}
void ShuffleNetV2::thread_tmp_1490_fu_21505_p1() {
tmp_1490_fu_21505_p1 = co108_reg_6401.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1491_cast_fu_16790_p1() {
tmp_1491_cast_fu_16790_p1 = esl_zext<64,15>(tmp_1306_fu_16785_p2.read());
}
void ShuffleNetV2::thread_tmp_1491_fu_21380_p2() {
tmp_1491_fu_21380_p2 = (!tmp_635_cast_fu_21376_p1.read().is_01() || !tmp_1485_reg_38901.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_635_cast_fu_21376_p1.read()) + sc_biguint<11>(tmp_1485_reg_38901.read()));
}
void ShuffleNetV2::thread_tmp_1492_cast_fu_16800_p1() {
tmp_1492_cast_fu_16800_p1 = esl_zext<64,14>(tmp_1307_reg_37272.read());
}
void ShuffleNetV2::thread_tmp_1492_fu_21385_p3() {
tmp_1492_fu_21385_p3 = esl_concat<11,3>(tmp_1491_fu_21380_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1493_fu_21397_p3() {
tmp_1493_fu_21397_p3 = esl_concat<11,1>(tmp_1491_fu_21380_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1494_fu_21409_p2() {
tmp_1494_fu_21409_p2 = (!p_shl491_cast_fu_21393_p1.read().is_01() || !p_shl492_cast_fu_21405_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl491_cast_fu_21393_p1.read()) + sc_biguint<15>(p_shl492_cast_fu_21405_p1.read()));
}
void ShuffleNetV2::thread_tmp_1495_fu_21415_p2() {
tmp_1495_fu_21415_p2 = (!tmp_635_cast1_fu_21372_p1.read().is_01() || !tmp_1482_reg_38896.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_635_cast1_fu_21372_p1.read()) + sc_biguint<10>(tmp_1482_reg_38896.read()));
}
void ShuffleNetV2::thread_tmp_1496_fu_21420_p3() {
tmp_1496_fu_21420_p3 = esl_concat<10,3>(tmp_1495_fu_21415_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1497_fu_21432_p3() {
tmp_1497_fu_21432_p3 = esl_concat<10,1>(tmp_1495_fu_21415_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1498_fu_21444_p2() {
tmp_1498_fu_21444_p2 = (!p_shl489_cast_fu_21428_p1.read().is_01() || !p_shl490_cast_fu_21440_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl489_cast_fu_21428_p1.read()) + sc_biguint<14>(p_shl490_cast_fu_21440_p1.read()));
}
void ShuffleNetV2::thread_tmp_1499_fu_21268_p2() {
tmp_1499_fu_21268_p2 = (!tmp_1489_reg_38865.read().is_01() || !tmp_636_cast_fu_21264_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1489_reg_38865.read()) + sc_biguint<15>(tmp_636_cast_fu_21264_p1.read()));
}
void ShuffleNetV2::thread_tmp_1500_fu_21470_p2() {
tmp_1500_fu_21470_p2 = (!tmp_1494_reg_38914.read().is_01() || !tmp_640_cast_fu_21466_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1494_reg_38914.read()) + sc_biguint<15>(tmp_640_cast_fu_21466_p1.read()));
}
void ShuffleNetV2::thread_tmp_1501_cast_fu_17081_p1() {
tmp_1501_cast_fu_17081_p1 = esl_sext<17,16>(tmp_1313_fu_17075_p2.read());
}
void ShuffleNetV2::thread_tmp_1501_fu_21480_p2() {
tmp_1501_fu_21480_p2 = (!tmp_1498_reg_38919.read().is_01() || !tmp_640_cast1_fu_21462_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_1498_reg_38919.read()) + sc_biguint<14>(tmp_640_cast1_fu_21462_p1.read()));
}
void ShuffleNetV2::thread_tmp_1502_cast_fu_17090_p1() {
tmp_1502_cast_fu_17090_p1 = esl_sext<33,17>(tmp_1314_fu_17085_p2.read());
}
void ShuffleNetV2::thread_tmp_1502_fu_21837_p1() {
tmp_1502_fu_21837_p1 = k38_reg_6445.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1503_fu_21604_p1() {
tmp_1503_fu_21604_p1 = i98_reg_6423.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1504_fu_21638_p1() {
tmp_1504_fu_21638_p1 = tmp_646_fu_21632_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1505_fu_21738_p3() {
tmp_1505_fu_21738_p3 = esl_concat<11,5>(tmp_649_reg_38996.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1506_fu_21749_p3() {
tmp_1506_fu_21749_p3 = esl_concat<11,3>(tmp_649_reg_38996.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1507_fu_21760_p2() {
tmp_1507_fu_21760_p2 = (!p_shl495_cast_fu_21745_p1.read().is_01() || !p_shl496_cast_fu_21756_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(p_shl495_cast_fu_21745_p1.read()) - sc_biguint<17>(p_shl496_cast_fu_21756_p1.read()));
}
void ShuffleNetV2::thread_tmp_1508_cast_fu_17109_p1() {
tmp_1508_cast_fu_17109_p1 = esl_sext<64,10>(tmp_1318_reg_37341.read());
}
void ShuffleNetV2::thread_tmp_1508_fu_21770_p2() {
tmp_1508_fu_21770_p2 = (!tmp_639_cast_reg_38983.read().is_01() || !tmp_1734_cast_fu_21766_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(tmp_639_cast_reg_38983.read()) + sc_bigint<18>(tmp_1734_cast_fu_21766_p1.read()));
}
void ShuffleNetV2::thread_tmp_1509_fu_21707_p3() {
tmp_1509_fu_21707_p3 = esl_concat<4,6>(tmp_650_fu_21697_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1510_fu_21715_p3() {
tmp_1510_fu_21715_p3 = esl_concat<4,4>(tmp_650_fu_21697_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1511_fu_21727_p2() {
tmp_1511_fu_21727_p2 = (!tmp_1509_fu_21707_p3.read().is_01() || !p_shl494_cast_fu_21723_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1509_fu_21707_p3.read()) - sc_bigint<10>(p_shl494_cast_fu_21723_p1.read()));
}
void ShuffleNetV2::thread_tmp_1512_fu_21733_p2() {
tmp_1512_fu_21733_p2 = (!tmp_638_cast_reg_38978.read().is_01() || !tmp_1511_fu_21727_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_638_cast_reg_38978.read()) + sc_biguint<10>(tmp_1511_fu_21727_p2.read()));
}
void ShuffleNetV2::thread_tmp_1513_fu_22306_p1() {
tmp_1513_fu_22306_p1 = co112_reg_6522.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1514_fu_22210_p1() {
tmp_1514_fu_22210_p1 = k40_reg_6511.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1515_fu_21989_p1() {
tmp_1515_fu_21989_p1 = i103_reg_6489.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1516_fu_22050_p3() {
tmp_1516_fu_22050_p3 = esl_concat<7,2>(tmp_663_reg_39161.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1517_cast_fu_17386_p1() {
tmp_1517_cast_fu_17386_p1 = esl_sext<36,35>(tmp_1324_fu_17380_p2.read());
}
void ShuffleNetV2::thread_tmp_1517_fu_22057_p1() {
tmp_1517_fu_22057_p1 = esl_sext<34,9>(tmp_1516_fu_22050_p3.read());
}
void ShuffleNetV2::thread_tmp_1518_fu_22065_p2() {
tmp_1518_fu_22065_p2 = (!p_shl500_cast_fu_22061_p1.read().is_01() || !tmp_664_cast_fu_22046_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl500_cast_fu_22061_p1.read()) - sc_biguint<35>(tmp_664_cast_fu_22046_p1.read()));
}
void ShuffleNetV2::thread_tmp_1519_fu_22075_p2() {
tmp_1519_fu_22075_p2 = (!tmp_1750_cast_fu_22071_p1.read().is_01() || !tmp_651_cast2_reg_39130.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_1750_cast_fu_22071_p1.read()) + sc_biguint<36>(tmp_651_cast2_reg_39130.read()));
}
void ShuffleNetV2::thread_tmp_1520_fu_22080_p1() {
tmp_1520_fu_22080_p1 = tmp_1519_fu_22075_p2.read().range(10-1, 0);
}
void ShuffleNetV2::thread_tmp_1521_cast_fu_17485_p1() {
tmp_1521_cast_fu_17485_p1 = esl_zext<64,10>(tmp_1329_reg_37524.read());
}
void ShuffleNetV2::thread_tmp_1521_fu_22084_p1() {
tmp_1521_fu_22084_p1 = tmp_1519_fu_22075_p2.read().range(8-1, 0);
}
void ShuffleNetV2::thread_tmp_1522_fu_22128_p2() {
tmp_1522_fu_22128_p2 = (!p_shl499_cast_fu_22121_p3.read().is_01() || !tmp_1520_reg_39173.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl499_cast_fu_22121_p3.read()) - sc_biguint<10>(tmp_1520_reg_39173.read()));
}
void ShuffleNetV2::thread_tmp_1523_cast_fu_17423_p1() {
tmp_1523_cast_fu_17423_p1 = esl_sext<13,12>(tmp_1331_fu_17417_p2.read());
}
void ShuffleNetV2::thread_tmp_1523_fu_22133_p2() {
tmp_1523_fu_22133_p2 = (!tmp_1522_fu_22128_p2.read().is_01() || !tmp_658_cast_reg_39148.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1522_fu_22128_p2.read()) + sc_biguint<10>(tmp_658_cast_reg_39148.read()));
}
void ShuffleNetV2::thread_tmp_1524_cast_fu_17449_p1() {
tmp_1524_cast_fu_17449_p1 = esl_sext<64,13>(tmp_1332_reg_37518.read());
}
void ShuffleNetV2::thread_tmp_1524_fu_22095_p3() {
tmp_1524_fu_22095_p3 = esl_concat<8,2>(tmp_665_reg_39167.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1525_fu_22102_p1() {
tmp_1525_fu_22102_p1 = esl_sext<11,10>(tmp_1524_fu_22095_p3.read());
}
void ShuffleNetV2::thread_tmp_1526_fu_22110_p2() {
tmp_1526_fu_22110_p2 = (!p_shl498_cast_fu_22106_p1.read().is_01() || !tmp_666_cast_fu_22091_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(p_shl498_cast_fu_22106_p1.read()) - sc_biguint<12>(tmp_666_cast_fu_22091_p1.read()));
}
void ShuffleNetV2::thread_tmp_1527_fu_22116_p2() {
tmp_1527_fu_22116_p2 = (!tmp_1526_fu_22110_p2.read().is_01() || !tmp_651_cast1_reg_39125.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1526_fu_22110_p2.read()) + sc_biguint<12>(tmp_651_cast1_reg_39125.read()));
}
void ShuffleNetV2::thread_tmp_1528_fu_22141_p3() {
tmp_1528_fu_22141_p3 = esl_concat<12,2>(tmp_1527_reg_39183.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1529_fu_22152_p2() {
tmp_1529_fu_22152_p2 = (!p_shl244_fu_22148_p1.read().is_01() || !tmp_1758_cast_fu_22138_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl244_fu_22148_p1.read()) - sc_bigint<64>(tmp_1758_cast_fu_22138_p1.read()));
}
void ShuffleNetV2::thread_tmp_1530_fu_22158_p2() {
tmp_1530_fu_22158_p2 = (!tmp_1529_fu_22152_p2.read().is_01() || !tmp_658_reg_39143.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_1529_fu_22152_p2.read()) + sc_biguint<64>(tmp_658_reg_39143.read()));
}
void ShuffleNetV2::thread_tmp_1531_fu_22730_p3() {
tmp_1531_fu_22730_p3 = esl_concat<6,3>(co114_reg_6577.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1532_fu_22742_p3() {
tmp_1532_fu_22742_p3 = esl_concat<6,1>(co114_reg_6577.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1533_fu_22754_p2() {
tmp_1533_fu_22754_p2 = (!p_shl506_cast_fu_22750_p1.read().is_01() || !p_shl505_cast_fu_22738_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl506_cast_fu_22750_p1.read()) + sc_biguint<10>(p_shl505_cast_fu_22738_p1.read()));
}
void ShuffleNetV2::thread_tmp_1534_fu_22638_p1() {
tmp_1534_fu_22638_p1 = k42_reg_6566.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1535_fu_22405_p1() {
tmp_1535_fu_22405_p1 = i105_reg_6544.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1536_fu_22439_p1() {
tmp_1536_fu_22439_p1 = tmp_672_fu_22433_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1537_fu_22539_p3() {
tmp_1537_fu_22539_p3 = esl_concat<11,5>(tmp_675_reg_39296.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1538_fu_22550_p3() {
tmp_1538_fu_22550_p3 = esl_concat<11,3>(tmp_675_reg_39296.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1539_cast_fu_17882_p1() {
tmp_1539_cast_fu_17882_p1 = esl_sext<17,16>(tmp_1344_fu_17876_p2.read());
}
void ShuffleNetV2::thread_tmp_1539_fu_22561_p2() {
tmp_1539_fu_22561_p2 = (!p_shl503_cast_fu_22546_p1.read().is_01() || !p_shl504_cast_fu_22557_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(p_shl503_cast_fu_22546_p1.read()) - sc_biguint<17>(p_shl504_cast_fu_22557_p1.read()));
}
void ShuffleNetV2::thread_tmp_1540_cast_fu_17891_p1() {
tmp_1540_cast_fu_17891_p1 = esl_sext<33,17>(tmp_1345_fu_17886_p2.read());
}
void ShuffleNetV2::thread_tmp_1540_fu_22571_p2() {
tmp_1540_fu_22571_p2 = (!tmp_661_cast_reg_39283.read().is_01() || !tmp_1773_cast_fu_22567_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(tmp_661_cast_reg_39283.read()) + sc_bigint<18>(tmp_1773_cast_fu_22567_p1.read()));
}
void ShuffleNetV2::thread_tmp_1541_fu_22508_p3() {
tmp_1541_fu_22508_p3 = esl_concat<4,6>(tmp_676_fu_22498_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1542_fu_22516_p3() {
tmp_1542_fu_22516_p3 = esl_concat<4,4>(tmp_676_fu_22498_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1543_fu_22528_p2() {
tmp_1543_fu_22528_p2 = (!tmp_1541_fu_22508_p3.read().is_01() || !p_shl502_cast_fu_22524_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1541_fu_22508_p3.read()) - sc_bigint<10>(p_shl502_cast_fu_22524_p1.read()));
}
void ShuffleNetV2::thread_tmp_1544_fu_22534_p2() {
tmp_1544_fu_22534_p2 = (!tmp_660_cast_reg_39278.read().is_01() || !tmp_1543_fu_22528_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_660_cast_reg_39278.read()) + sc_biguint<10>(tmp_1543_fu_22528_p2.read()));
}
void ShuffleNetV2::thread_tmp_1545_fu_22853_p3() {
tmp_1545_fu_22853_p3 = esl_concat<6,3>(co116_reg_6610.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1546_cast_fu_17910_p1() {
tmp_1546_cast_fu_17910_p1 = esl_sext<64,10>(tmp_1349_reg_37641.read());
}
void ShuffleNetV2::thread_tmp_1546_fu_22865_p3() {
tmp_1546_fu_22865_p3 = esl_concat<6,1>(co116_reg_6610.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1547_fu_22877_p2() {
tmp_1547_fu_22877_p2 = (!p_shl512_cast_fu_22873_p1.read().is_01() || !p_shl511_cast_fu_22861_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl512_cast_fu_22873_p1.read()) + sc_biguint<10>(p_shl511_cast_fu_22861_p1.read()));
}
void ShuffleNetV2::thread_tmp_1548_fu_22889_p3() {
tmp_1548_fu_22889_p3 = esl_concat<7,3>(tmp_677_fu_22883_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1549_fu_22901_p3() {
tmp_1549_fu_22901_p3 = esl_concat<7,1>(tmp_677_fu_22883_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1550_fu_22913_p2() {
tmp_1550_fu_22913_p2 = (!p_shl510_cast_fu_22909_p1.read().is_01() || !p_shl509_cast_fu_22897_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl510_cast_fu_22909_p1.read()) + sc_biguint<11>(p_shl509_cast_fu_22897_p1.read()));
}
void ShuffleNetV2::thread_tmp_1551_fu_22776_p2() {
tmp_1551_fu_22776_p2 = (!tmp_678_cast_fu_22772_p1.read().is_01() || !tmp_1533_reg_39407.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_678_cast_fu_22772_p1.read()) + sc_biguint<10>(tmp_1533_reg_39407.read()));
}
void ShuffleNetV2::thread_tmp_1552_fu_22781_p3() {
tmp_1552_fu_22781_p3 = esl_concat<10,3>(tmp_1551_fu_22776_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1553_fu_22793_p3() {
tmp_1553_fu_22793_p3 = esl_concat<10,1>(tmp_1551_fu_22776_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1554_fu_22805_p2() {
tmp_1554_fu_22805_p2 = (!p_shl507_cast_fu_22789_p1.read().is_01() || !p_shl508_cast_fu_22801_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl507_cast_fu_22789_p1.read()) + sc_biguint<15>(p_shl508_cast_fu_22801_p1.read()));
}
void ShuffleNetV2::thread_tmp_1555_fu_23064_p1() {
tmp_1555_fu_23064_p1 = co118_reg_6643.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1556_fu_22939_p2() {
tmp_1556_fu_22939_p2 = (!tmp_680_cast_fu_22935_p1.read().is_01() || !tmp_1550_reg_39456.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_680_cast_fu_22935_p1.read()) + sc_biguint<11>(tmp_1550_reg_39456.read()));
}
void ShuffleNetV2::thread_tmp_1557_fu_22944_p3() {
tmp_1557_fu_22944_p3 = esl_concat<11,3>(tmp_1556_fu_22939_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1558_fu_22956_p3() {
tmp_1558_fu_22956_p3 = esl_concat<11,1>(tmp_1556_fu_22939_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1559_fu_22968_p2() {
tmp_1559_fu_22968_p2 = (!p_shl515_cast_fu_22952_p1.read().is_01() || !p_shl516_cast_fu_22964_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl515_cast_fu_22952_p1.read()) + sc_biguint<15>(p_shl516_cast_fu_22964_p1.read()));
}
void ShuffleNetV2::thread_tmp_1560_fu_22974_p2() {
tmp_1560_fu_22974_p2 = (!tmp_680_cast1_fu_22931_p1.read().is_01() || !tmp_1547_reg_39451.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_680_cast1_fu_22931_p1.read()) + sc_biguint<10>(tmp_1547_reg_39451.read()));
}
void ShuffleNetV2::thread_tmp_1561_fu_22979_p3() {
tmp_1561_fu_22979_p3 = esl_concat<10,3>(tmp_1560_fu_22974_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1562_fu_22991_p3() {
tmp_1562_fu_22991_p3 = esl_concat<10,1>(tmp_1560_fu_22974_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1563_fu_23003_p2() {
tmp_1563_fu_23003_p2 = (!p_shl513_cast_fu_22987_p1.read().is_01() || !p_shl514_cast_fu_22999_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl513_cast_fu_22987_p1.read()) + sc_biguint<14>(p_shl514_cast_fu_22999_p1.read()));
}
void ShuffleNetV2::thread_tmp_1564_fu_22827_p2() {
tmp_1564_fu_22827_p2 = (!tmp_1554_reg_39420.read().is_01() || !tmp_681_cast1_fu_22823_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1554_reg_39420.read()) + sc_biguint<15>(tmp_681_cast1_fu_22823_p1.read()));
}
void ShuffleNetV2::thread_tmp_1565_fu_23029_p2() {
tmp_1565_fu_23029_p2 = (!tmp_1559_reg_39469.read().is_01() || !tmp_685_cast2_fu_23025_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1559_reg_39469.read()) + sc_biguint<15>(tmp_685_cast2_fu_23025_p1.read()));
}
void ShuffleNetV2::thread_tmp_1566_fu_23039_p2() {
tmp_1566_fu_23039_p2 = (!tmp_1563_reg_39474.read().is_01() || !tmp_685_cast1_fu_23021_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_1563_reg_39474.read()) + sc_biguint<14>(tmp_685_cast1_fu_23021_p1.read()));
}
void ShuffleNetV2::thread_tmp_1567_cast_fu_18151_p1() {
tmp_1567_cast_fu_18151_p1 = esl_zext<64,15>(tmp_1369_fu_18146_p2.read());
}
void ShuffleNetV2::thread_tmp_1567_fu_23396_p1() {
tmp_1567_fu_23396_p1 = k44_reg_6687.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1568_cast_fu_18353_p1() {
tmp_1568_cast_fu_18353_p1 = esl_zext<64,15>(tmp_1370_fu_18348_p2.read());
}
void ShuffleNetV2::thread_tmp_1568_fu_23163_p1() {
tmp_1568_fu_23163_p1 = i109_reg_6665.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1569_cast_fu_18363_p1() {
tmp_1569_cast_fu_18363_p1 = esl_zext<64,14>(tmp_1371_reg_37827.read());
}
void ShuffleNetV2::thread_tmp_1569_fu_23197_p1() {
tmp_1569_fu_23197_p1 = tmp_691_fu_23191_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1570_fu_23297_p3() {
tmp_1570_fu_23297_p3 = esl_concat<11,5>(tmp_694_reg_39551.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1571_fu_23308_p3() {
tmp_1571_fu_23308_p3 = esl_concat<11,3>(tmp_694_reg_39551.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1572_fu_23319_p2() {
tmp_1572_fu_23319_p2 = (!p_shl519_cast_fu_23304_p1.read().is_01() || !p_shl520_cast_fu_23315_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(p_shl519_cast_fu_23304_p1.read()) - sc_biguint<17>(p_shl520_cast_fu_23315_p1.read()));
}
void ShuffleNetV2::thread_tmp_1573_fu_23329_p2() {
tmp_1573_fu_23329_p2 = (!tmp_684_cast1_reg_39538.read().is_01() || !tmp_1812_cast_fu_23325_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(tmp_684_cast1_reg_39538.read()) + sc_bigint<18>(tmp_1812_cast_fu_23325_p1.read()));
}
void ShuffleNetV2::thread_tmp_1574_fu_23266_p3() {
tmp_1574_fu_23266_p3 = esl_concat<4,6>(tmp_695_fu_23256_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1575_fu_23274_p3() {
tmp_1575_fu_23274_p3 = esl_concat<4,4>(tmp_695_fu_23256_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1576_fu_23286_p2() {
tmp_1576_fu_23286_p2 = (!tmp_1574_fu_23266_p3.read().is_01() || !p_shl518_cast_fu_23282_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1574_fu_23266_p3.read()) - sc_bigint<10>(p_shl518_cast_fu_23282_p1.read()));
}
void ShuffleNetV2::thread_tmp_1577_fu_23292_p2() {
tmp_1577_fu_23292_p2 = (!tmp_683_cast_reg_39533.read().is_01() || !tmp_1576_fu_23286_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_683_cast_reg_39533.read()) + sc_biguint<10>(tmp_1576_fu_23286_p2.read()));
}
void ShuffleNetV2::thread_tmp_1578_fu_23869_p1() {
tmp_1578_fu_23869_p1 = co122_reg_6764.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1579_fu_23773_p1() {
tmp_1579_fu_23773_p1 = k46_reg_6753.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1580_cast_fu_18652_p1() {
tmp_1580_cast_fu_18652_p1 = esl_sext<17,16>(tmp_1379_fu_18646_p2.read());
}
void ShuffleNetV2::thread_tmp_1580_fu_23548_p1() {
tmp_1580_fu_23548_p1 = i114_reg_6731.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1581_cast_fu_18661_p1() {
tmp_1581_cast_fu_18661_p1 = esl_sext<33,17>(tmp_1380_fu_18656_p2.read());
}
void ShuffleNetV2::thread_tmp_1581_fu_23609_p3() {
tmp_1581_fu_23609_p3 = esl_concat<7,2>(tmp_708_reg_39716.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1582_fu_23616_p1() {
tmp_1582_fu_23616_p1 = esl_sext<34,9>(tmp_1581_fu_23609_p3.read());
}
void ShuffleNetV2::thread_tmp_1583_fu_23624_p2() {
tmp_1583_fu_23624_p2 = (!p_shl524_cast_fu_23620_p1.read().is_01() || !tmp_709_cast1_fu_23605_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl524_cast_fu_23620_p1.read()) - sc_biguint<35>(tmp_709_cast1_fu_23605_p1.read()));
}
void ShuffleNetV2::thread_tmp_1584_fu_23634_p2() {
tmp_1584_fu_23634_p2 = (!tmp_1828_cast_fu_23630_p1.read().is_01() || !tmp_696_cast_reg_39685.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_1828_cast_fu_23630_p1.read()) + sc_biguint<36>(tmp_696_cast_reg_39685.read()));
}
void ShuffleNetV2::thread_tmp_1585_fu_23639_p1() {
tmp_1585_fu_23639_p1 = tmp_1584_fu_23634_p2.read().range(10-1, 0);
}
void ShuffleNetV2::thread_tmp_1586_fu_23643_p1() {
tmp_1586_fu_23643_p1 = tmp_1584_fu_23634_p2.read().range(8-1, 0);
}
void ShuffleNetV2::thread_tmp_1587_cast_fu_18680_p1() {
tmp_1587_cast_fu_18680_p1 = esl_sext<64,10>(tmp_1384_reg_37896.read());
}
void ShuffleNetV2::thread_tmp_1587_fu_23691_p2() {
tmp_1587_fu_23691_p2 = (!p_shl523_cast_fu_23684_p3.read().is_01() || !tmp_1585_reg_39728.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl523_cast_fu_23684_p3.read()) - sc_biguint<10>(tmp_1585_reg_39728.read()));
}
void ShuffleNetV2::thread_tmp_1588_fu_23696_p2() {
tmp_1588_fu_23696_p2 = (!tmp_1587_fu_23691_p2.read().is_01() || !tmp_703_cast_reg_39703.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1587_fu_23691_p2.read()) + sc_biguint<10>(tmp_703_cast_reg_39703.read()));
}
void ShuffleNetV2::thread_tmp_1589_fu_23654_p3() {
tmp_1589_fu_23654_p3 = esl_concat<8,2>(tmp_710_reg_39722.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1590_fu_23661_p1() {
tmp_1590_fu_23661_p1 = esl_sext<11,10>(tmp_1589_fu_23654_p3.read());
}
void ShuffleNetV2::thread_tmp_1591_fu_23669_p2() {
tmp_1591_fu_23669_p2 = (!p_shl522_cast_fu_23665_p1.read().is_01() || !tmp_711_cast1_fu_23650_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(p_shl522_cast_fu_23665_p1.read()) - sc_biguint<12>(tmp_711_cast1_fu_23650_p1.read()));
}
void ShuffleNetV2::thread_tmp_1592_fu_23679_p2() {
tmp_1592_fu_23679_p2 = (!tmp_1835_cast_fu_23675_p1.read().is_01() || !tmp_696_cast1_reg_39680.read().is_01())? sc_lv<13>(): (sc_bigint<13>(tmp_1835_cast_fu_23675_p1.read()) + sc_biguint<13>(tmp_696_cast1_reg_39680.read()));
}
void ShuffleNetV2::thread_tmp_1593_fu_23704_p3() {
tmp_1593_fu_23704_p3 = esl_concat<13,2>(tmp_1592_reg_39738.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1594_fu_23715_p2() {
tmp_1594_fu_23715_p2 = (!p_shl249_fu_23711_p1.read().is_01() || !tmp_1836_cast_fu_23701_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl249_fu_23711_p1.read()) - sc_bigint<64>(tmp_1836_cast_fu_23701_p1.read()));
}
void ShuffleNetV2::thread_tmp_1595_fu_23721_p2() {
tmp_1595_fu_23721_p2 = (!tmp_1594_fu_23715_p2.read().is_01() || !tmp_703_reg_39698.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_1594_fu_23715_p2.read()) + sc_biguint<64>(tmp_703_reg_39698.read()));
}
void ShuffleNetV2::thread_tmp_1596_cast_fu_18961_p1() {
tmp_1596_cast_fu_18961_p1 = esl_sext<36,35>(tmp_1390_fu_18955_p2.read());
}
void ShuffleNetV2::thread_tmp_1596_fu_24293_p3() {
tmp_1596_fu_24293_p3 = esl_concat<6,3>(co124_reg_6819.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1597_fu_24305_p3() {
tmp_1597_fu_24305_p3 = esl_concat<6,1>(co124_reg_6819.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1598_fu_24317_p2() {
tmp_1598_fu_24317_p2 = (!p_shl530_cast_fu_24313_p1.read().is_01() || !p_shl529_cast_fu_24301_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl530_cast_fu_24313_p1.read()) + sc_biguint<10>(p_shl529_cast_fu_24301_p1.read()));
}
void ShuffleNetV2::thread_tmp_1599_fu_24201_p1() {
tmp_1599_fu_24201_p1 = k48_reg_6808.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1600_cast_fu_19056_p1() {
tmp_1600_cast_fu_19056_p1 = esl_zext<64,10>(tmp_1395_reg_38079.read());
}
void ShuffleNetV2::thread_tmp_1600_fu_23968_p1() {
tmp_1600_fu_23968_p1 = i116_reg_6786.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1601_fu_24002_p1() {
tmp_1601_fu_24002_p1 = tmp_717_fu_23996_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1602_fu_24102_p3() {
tmp_1602_fu_24102_p3 = esl_concat<11,5>(tmp_722_reg_39851.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1603_cast_fu_19020_p1() {
tmp_1603_cast_fu_19020_p1 = esl_sext<64,12>(tmp_1398_reg_38073.read());
}
void ShuffleNetV2::thread_tmp_1603_fu_24113_p3() {
tmp_1603_fu_24113_p3 = esl_concat<11,3>(tmp_722_reg_39851.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1604_fu_24124_p2() {
tmp_1604_fu_24124_p2 = (!p_shl527_cast_fu_24109_p1.read().is_01() || !p_shl528_cast_fu_24120_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(p_shl527_cast_fu_24109_p1.read()) - sc_biguint<17>(p_shl528_cast_fu_24120_p1.read()));
}
void ShuffleNetV2::thread_tmp_1605_fu_24134_p2() {
tmp_1605_fu_24134_p2 = (!tmp_706_cast_reg_39838.read().is_01() || !tmp_1851_cast_fu_24130_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(tmp_706_cast_reg_39838.read()) + sc_bigint<18>(tmp_1851_cast_fu_24130_p1.read()));
}
void ShuffleNetV2::thread_tmp_1606_fu_24071_p3() {
tmp_1606_fu_24071_p3 = esl_concat<4,6>(tmp_724_fu_24061_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1607_fu_24079_p3() {
tmp_1607_fu_24079_p3 = esl_concat<4,4>(tmp_724_fu_24061_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1608_fu_24091_p2() {
tmp_1608_fu_24091_p2 = (!tmp_1606_fu_24071_p3.read().is_01() || !p_shl526_cast_fu_24087_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1606_fu_24071_p3.read()) - sc_bigint<10>(p_shl526_cast_fu_24087_p1.read()));
}
void ShuffleNetV2::thread_tmp_1609_fu_24097_p2() {
tmp_1609_fu_24097_p2 = (!tmp_705_cast_reg_39833.read().is_01() || !tmp_1608_fu_24091_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_705_cast_reg_39833.read()) + sc_biguint<10>(tmp_1608_fu_24091_p2.read()));
}
void ShuffleNetV2::thread_tmp_1610_fu_24416_p3() {
tmp_1610_fu_24416_p3 = esl_concat<6,3>(co126_reg_6852.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1611_fu_24428_p3() {
tmp_1611_fu_24428_p3 = esl_concat<6,1>(co126_reg_6852.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1612_fu_24440_p2() {
tmp_1612_fu_24440_p2 = (!p_shl536_cast_fu_24436_p1.read().is_01() || !p_shl535_cast_fu_24424_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl536_cast_fu_24436_p1.read()) + sc_biguint<10>(p_shl535_cast_fu_24424_p1.read()));
}
void ShuffleNetV2::thread_tmp_1613_fu_24452_p3() {
tmp_1613_fu_24452_p3 = esl_concat<7,3>(tmp_725_fu_24446_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1614_fu_24464_p3() {
tmp_1614_fu_24464_p3 = esl_concat<7,1>(tmp_725_fu_24446_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1615_fu_24476_p2() {
tmp_1615_fu_24476_p2 = (!p_shl534_cast_fu_24472_p1.read().is_01() || !p_shl533_cast_fu_24460_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl534_cast_fu_24472_p1.read()) + sc_biguint<11>(p_shl533_cast_fu_24460_p1.read()));
}
void ShuffleNetV2::thread_tmp_1616_fu_24339_p2() {
tmp_1616_fu_24339_p2 = (!tmp_726_cast_fu_24335_p1.read().is_01() || !tmp_1598_reg_39962.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_726_cast_fu_24335_p1.read()) + sc_biguint<10>(tmp_1598_reg_39962.read()));
}
void ShuffleNetV2::thread_tmp_1617_fu_24344_p3() {
tmp_1617_fu_24344_p3 = esl_concat<10,3>(tmp_1616_fu_24339_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1618_cast_fu_19453_p1() {
tmp_1618_cast_fu_19453_p1 = esl_sext<18,17>(tmp_1410_fu_19447_p2.read());
}
void ShuffleNetV2::thread_tmp_1618_fu_24356_p3() {
tmp_1618_fu_24356_p3 = esl_concat<10,1>(tmp_1616_fu_24339_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1619_cast_fu_19462_p1() {
tmp_1619_cast_fu_19462_p1 = esl_sext<33,18>(tmp_1411_fu_19457_p2.read());
}
void ShuffleNetV2::thread_tmp_1619_fu_24368_p2() {
tmp_1619_fu_24368_p2 = (!p_shl531_cast_fu_24352_p1.read().is_01() || !p_shl532_cast_fu_24364_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl531_cast_fu_24352_p1.read()) + sc_biguint<15>(p_shl532_cast_fu_24364_p1.read()));
}
void ShuffleNetV2::thread_tmp_1620_fu_24627_p1() {
tmp_1620_fu_24627_p1 = co128_reg_6885.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1621_fu_24502_p2() {
tmp_1621_fu_24502_p2 = (!tmp_728_cast_fu_24498_p1.read().is_01() || !tmp_1615_reg_40011.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_728_cast_fu_24498_p1.read()) + sc_biguint<11>(tmp_1615_reg_40011.read()));
}
void ShuffleNetV2::thread_tmp_1622_fu_24507_p3() {
tmp_1622_fu_24507_p3 = esl_concat<11,3>(tmp_1621_fu_24502_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1623_fu_24519_p3() {
tmp_1623_fu_24519_p3 = esl_concat<11,1>(tmp_1621_fu_24502_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1624_fu_24531_p2() {
tmp_1624_fu_24531_p2 = (!p_shl539_cast_fu_24515_p1.read().is_01() || !p_shl540_cast_fu_24527_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl539_cast_fu_24515_p1.read()) + sc_biguint<15>(p_shl540_cast_fu_24527_p1.read()));
}
void ShuffleNetV2::thread_tmp_1625_cast_fu_19481_p1() {
tmp_1625_cast_fu_19481_p1 = esl_sext<64,10>(tmp_1415_reg_38196.read());
}
void ShuffleNetV2::thread_tmp_1625_fu_24537_p2() {
tmp_1625_fu_24537_p2 = (!tmp_728_cast1_fu_24494_p1.read().is_01() || !tmp_1612_reg_40006.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_728_cast1_fu_24494_p1.read()) + sc_biguint<10>(tmp_1612_reg_40006.read()));
}
void ShuffleNetV2::thread_tmp_1626_fu_24542_p3() {
tmp_1626_fu_24542_p3 = esl_concat<10,3>(tmp_1625_fu_24537_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1627_fu_24554_p3() {
tmp_1627_fu_24554_p3 = esl_concat<10,1>(tmp_1625_fu_24537_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1628_fu_24566_p2() {
tmp_1628_fu_24566_p2 = (!p_shl537_cast_fu_24550_p1.read().is_01() || !p_shl538_cast_fu_24562_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl537_cast_fu_24550_p1.read()) + sc_biguint<14>(p_shl538_cast_fu_24562_p1.read()));
}
void ShuffleNetV2::thread_tmp_1629_fu_24390_p2() {
tmp_1629_fu_24390_p2 = (!tmp_1619_reg_39975.read().is_01() || !tmp_729_cast1_fu_24386_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1619_reg_39975.read()) + sc_biguint<15>(tmp_729_cast1_fu_24386_p1.read()));
}
void ShuffleNetV2::thread_tmp_1630_fu_24592_p2() {
tmp_1630_fu_24592_p2 = (!tmp_1624_reg_40024.read().is_01() || !tmp_733_cast_fu_24588_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1624_reg_40024.read()) + sc_biguint<15>(tmp_733_cast_fu_24588_p1.read()));
}
void ShuffleNetV2::thread_tmp_1631_fu_24602_p2() {
tmp_1631_fu_24602_p2 = (!tmp_1628_reg_40029.read().is_01() || !tmp_733_cast1_fu_24584_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_1628_reg_40029.read()) + sc_biguint<14>(tmp_733_cast1_fu_24584_p1.read()));
}
void ShuffleNetV2::thread_tmp_1632_fu_24967_p1() {
tmp_1632_fu_24967_p1 = k50_reg_6929.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1633_fu_24726_p1() {
tmp_1633_fu_24726_p1 = i120_reg_6907.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1634_fu_24760_p1() {
tmp_1634_fu_24760_p1 = tmp_739_fu_24754_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1635_fu_24860_p3() {
tmp_1635_fu_24860_p3 = esl_concat<10,5>(tmp_743_reg_40106.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1636_fu_24867_p1() {
tmp_1636_fu_24867_p1 = esl_sext<16,15>(tmp_1635_fu_24860_p3.read());
}
void ShuffleNetV2::thread_tmp_1637_fu_24875_p3() {
tmp_1637_fu_24875_p3 = esl_concat<10,3>(tmp_743_reg_40106.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1638_fu_24882_p1() {
tmp_1638_fu_24882_p1 = esl_sext<14,13>(tmp_1637_fu_24875_p3.read());
}
void ShuffleNetV2::thread_tmp_1639_fu_24890_p2() {
tmp_1639_fu_24890_p2 = (!p_shl543_cast_fu_24871_p1.read().is_01() || !p_shl544_cast_fu_24886_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(p_shl543_cast_fu_24871_p1.read()) - sc_biguint<17>(p_shl544_cast_fu_24886_p1.read()));
}
void ShuffleNetV2::thread_tmp_1640_fu_24900_p2() {
tmp_1640_fu_24900_p2 = (!tmp_732_cast_reg_40093.read().is_01() || !tmp_1892_cast_fu_24896_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(tmp_732_cast_reg_40093.read()) + sc_bigint<18>(tmp_1892_cast_fu_24896_p1.read()));
}
void ShuffleNetV2::thread_tmp_1641_fu_24829_p3() {
tmp_1641_fu_24829_p3 = esl_concat<4,6>(tmp_744_fu_24819_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1642_fu_24837_p3() {
tmp_1642_fu_24837_p3 = esl_concat<4,4>(tmp_744_fu_24819_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1643_fu_24849_p2() {
tmp_1643_fu_24849_p2 = (!tmp_1641_fu_24829_p3.read().is_01() || !p_shl542_cast_fu_24845_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1641_fu_24829_p3.read()) - sc_bigint<10>(p_shl542_cast_fu_24845_p1.read()));
}
void ShuffleNetV2::thread_tmp_1644_fu_24855_p2() {
tmp_1644_fu_24855_p2 = (!tmp_731_cast_reg_40088.read().is_01() || !tmp_1643_fu_24849_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_731_cast_reg_40088.read()) + sc_biguint<10>(tmp_1643_fu_24849_p2.read()));
}
void ShuffleNetV2::thread_tmp_1645_fu_25432_p1() {
tmp_1645_fu_25432_p1 = co132_reg_7006.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1646_cast_fu_19722_p1() {
tmp_1646_cast_fu_19722_p1 = esl_zext<64,15>(tmp_1435_fu_19717_p2.read());
}
void ShuffleNetV2::thread_tmp_1646_fu_25336_p1() {
tmp_1646_fu_25336_p1 = k52_reg_6995.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1647_cast_fu_19924_p1() {
tmp_1647_cast_fu_19924_p1 = esl_zext<64,15>(tmp_1436_fu_19919_p2.read());
}
void ShuffleNetV2::thread_tmp_1647_fu_25119_p1() {
tmp_1647_fu_25119_p1 = i125_reg_6973.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1648_cast_fu_19934_p1() {
tmp_1648_cast_fu_19934_p1 = esl_zext<64,14>(tmp_1437_reg_38382.read());
}
void ShuffleNetV2::thread_tmp_1648_fu_25180_p3() {
tmp_1648_fu_25180_p3 = esl_concat<7,2>(tmp_762_reg_40271.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1649_fu_25187_p1() {
tmp_1649_fu_25187_p1 = esl_sext<34,9>(tmp_1648_fu_25180_p3.read());
}
void ShuffleNetV2::thread_tmp_1650_fu_25195_p2() {
tmp_1650_fu_25195_p2 = (!p_shl548_cast_fu_25191_p1.read().is_01() || !tmp_763_cast_fu_25176_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl548_cast_fu_25191_p1.read()) - sc_biguint<35>(tmp_763_cast_fu_25176_p1.read()));
}
void ShuffleNetV2::thread_tmp_1651_fu_25205_p2() {
tmp_1651_fu_25205_p2 = (!tmp_1908_cast_fu_25201_p1.read().is_01() || !tmp_745_cast_reg_40240.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_1908_cast_fu_25201_p1.read()) + sc_biguint<36>(tmp_745_cast_reg_40240.read()));
}
void ShuffleNetV2::thread_tmp_1652_fu_25210_p1() {
tmp_1652_fu_25210_p1 = tmp_1651_fu_25205_p2.read().range(10-1, 0);
}
void ShuffleNetV2::thread_tmp_1653_fu_25214_p1() {
tmp_1653_fu_25214_p1 = tmp_1651_fu_25205_p2.read().range(8-1, 0);
}
void ShuffleNetV2::thread_tmp_1654_fu_25254_p2() {
tmp_1654_fu_25254_p2 = (!p_shl547_cast_fu_25247_p3.read().is_01() || !tmp_1652_reg_40283.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl547_cast_fu_25247_p3.read()) - sc_biguint<10>(tmp_1652_reg_40283.read()));
}
void ShuffleNetV2::thread_tmp_1655_fu_25259_p2() {
tmp_1655_fu_25259_p2 = (!tmp_1654_fu_25254_p2.read().is_01() || !tmp_757_cast_reg_40258.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1654_fu_25254_p2.read()) + sc_biguint<10>(tmp_757_cast_reg_40258.read()));
}
void ShuffleNetV2::thread_tmp_1656_fu_25221_p3() {
tmp_1656_fu_25221_p3 = esl_concat<10,2>(tmp_764_reg_40277.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1657_cast_fu_20215_p1() {
tmp_1657_cast_fu_20215_p1 = esl_sext<18,17>(tmp_1443_fu_20209_p2.read());
}
void ShuffleNetV2::thread_tmp_1657_fu_25232_p2() {
tmp_1657_fu_25232_p2 = (!p_shl546_cast_fu_25228_p1.read().is_01() || !tmp_765_cast_fu_25218_p1.read().is_01())? sc_lv<13>(): (sc_biguint<13>(p_shl546_cast_fu_25228_p1.read()) - sc_biguint<13>(tmp_765_cast_fu_25218_p1.read()));
}
void ShuffleNetV2::thread_tmp_1658_cast_fu_20224_p1() {
tmp_1658_cast_fu_20224_p1 = esl_sext<33,18>(tmp_1444_fu_20219_p2.read());
}
void ShuffleNetV2::thread_tmp_1658_fu_25242_p2() {
tmp_1658_fu_25242_p2 = (!tmp_1914_cast_fu_25238_p1.read().is_01() || !tmp_745_cast1_reg_40235.read().is_01())? sc_lv<14>(): (sc_bigint<14>(tmp_1914_cast_fu_25238_p1.read()) + sc_biguint<14>(tmp_745_cast1_reg_40235.read()));
}
void ShuffleNetV2::thread_tmp_1659_fu_25267_p3() {
tmp_1659_fu_25267_p3 = esl_concat<14,2>(tmp_1658_reg_40293.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1660_fu_25278_p2() {
tmp_1660_fu_25278_p2 = (!p_shl255_fu_25274_p1.read().is_01() || !tmp_1915_cast_fu_25264_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl255_fu_25274_p1.read()) - sc_bigint<64>(tmp_1915_cast_fu_25264_p1.read()));
}
void ShuffleNetV2::thread_tmp_1661_fu_25284_p2() {
tmp_1661_fu_25284_p2 = (!tmp_1660_fu_25278_p2.read().is_01() || !tmp_757_reg_40253.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_1660_fu_25278_p2.read()) + sc_biguint<64>(tmp_757_reg_40253.read()));
}
void ShuffleNetV2::thread_tmp_1662_fu_25868_p3() {
tmp_1662_fu_25868_p3 = esl_concat<6,3>(co134_reg_7061.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1663_fu_25880_p3() {
tmp_1663_fu_25880_p3 = esl_concat<6,1>(co134_reg_7061.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1664_cast_fu_20243_p1() {
tmp_1664_cast_fu_20243_p1 = esl_sext<64,10>(tmp_1448_reg_38451.read());
}
void ShuffleNetV2::thread_tmp_1664_fu_25892_p2() {
tmp_1664_fu_25892_p2 = (!p_shl554_cast_fu_25888_p1.read().is_01() || !p_shl553_cast_fu_25876_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl554_cast_fu_25888_p1.read()) + sc_biguint<10>(p_shl553_cast_fu_25876_p1.read()));
}
void ShuffleNetV2::thread_tmp_1665_fu_25772_p1() {
tmp_1665_fu_25772_p1 = k54_reg_7050.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1666_fu_25531_p1() {
tmp_1666_fu_25531_p1 = i127_reg_7028.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1667_fu_25565_p1() {
tmp_1667_fu_25565_p1 = tmp_771_fu_25559_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1668_fu_25665_p3() {
tmp_1668_fu_25665_p3 = esl_concat<10,5>(tmp_776_reg_40406.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1669_fu_25672_p1() {
tmp_1669_fu_25672_p1 = esl_sext<16,15>(tmp_1668_fu_25665_p3.read());
}
void ShuffleNetV2::thread_tmp_1670_fu_25680_p3() {
tmp_1670_fu_25680_p3 = esl_concat<10,3>(tmp_776_reg_40406.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1671_fu_25687_p1() {
tmp_1671_fu_25687_p1 = esl_sext<14,13>(tmp_1670_fu_25680_p3.read());
}
void ShuffleNetV2::thread_tmp_1672_fu_25695_p2() {
tmp_1672_fu_25695_p2 = (!p_shl551_cast_fu_25676_p1.read().is_01() || !p_shl552_cast_fu_25691_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(p_shl551_cast_fu_25676_p1.read()) - sc_biguint<17>(p_shl552_cast_fu_25691_p1.read()));
}
void ShuffleNetV2::thread_tmp_1673_cast_fu_20520_p1() {
tmp_1673_cast_fu_20520_p1 = esl_sext<36,35>(tmp_1454_fu_20514_p2.read());
}
void ShuffleNetV2::thread_tmp_1673_fu_25705_p2() {
tmp_1673_fu_25705_p2 = (!tmp_760_cast1_reg_40393.read().is_01() || !tmp_1932_cast_fu_25701_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(tmp_760_cast1_reg_40393.read()) + sc_bigint<18>(tmp_1932_cast_fu_25701_p1.read()));
}
void ShuffleNetV2::thread_tmp_1674_fu_25634_p3() {
tmp_1674_fu_25634_p3 = esl_concat<4,6>(tmp_778_fu_25624_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1675_fu_25642_p3() {
tmp_1675_fu_25642_p3 = esl_concat<4,4>(tmp_778_fu_25624_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1676_fu_25654_p2() {
tmp_1676_fu_25654_p2 = (!tmp_1674_fu_25634_p3.read().is_01() || !p_shl550_cast_fu_25650_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1674_fu_25634_p3.read()) - sc_bigint<10>(p_shl550_cast_fu_25650_p1.read()));
}
void ShuffleNetV2::thread_tmp_1677_cast_fu_20615_p1() {
tmp_1677_cast_fu_20615_p1 = esl_zext<64,10>(tmp_1459_reg_38634.read());
}
void ShuffleNetV2::thread_tmp_1677_fu_25660_p2() {
tmp_1677_fu_25660_p2 = (!tmp_759_cast1_reg_40388.read().is_01() || !tmp_1676_fu_25654_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_759_cast1_reg_40388.read()) + sc_biguint<10>(tmp_1676_fu_25654_p2.read()));
}
void ShuffleNetV2::thread_tmp_1678_fu_25991_p3() {
tmp_1678_fu_25991_p3 = esl_concat<6,3>(co136_reg_7094.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1679_fu_26003_p3() {
tmp_1679_fu_26003_p3 = esl_concat<6,1>(co136_reg_7094.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1680_cast_fu_20579_p1() {
tmp_1680_cast_fu_20579_p1 = esl_sext<64,12>(tmp_1462_reg_38628.read());
}
void ShuffleNetV2::thread_tmp_1680_fu_26015_p2() {
tmp_1680_fu_26015_p2 = (!p_shl560_cast_fu_26011_p1.read().is_01() || !p_shl559_cast_fu_25999_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl560_cast_fu_26011_p1.read()) + sc_biguint<10>(p_shl559_cast_fu_25999_p1.read()));
}
void ShuffleNetV2::thread_tmp_1681_fu_26027_p3() {
tmp_1681_fu_26027_p3 = esl_concat<7,3>(tmp_779_fu_26021_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1682_fu_26039_p3() {
tmp_1682_fu_26039_p3 = esl_concat<7,1>(tmp_779_fu_26021_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1683_fu_26051_p2() {
tmp_1683_fu_26051_p2 = (!p_shl558_cast_fu_26047_p1.read().is_01() || !p_shl557_cast_fu_26035_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl558_cast_fu_26047_p1.read()) + sc_biguint<11>(p_shl557_cast_fu_26035_p1.read()));
}
void ShuffleNetV2::thread_tmp_1684_fu_25914_p2() {
tmp_1684_fu_25914_p2 = (!tmp_780_cast_fu_25910_p1.read().is_01() || !tmp_1664_reg_40517.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_780_cast_fu_25910_p1.read()) + sc_biguint<10>(tmp_1664_reg_40517.read()));
}
void ShuffleNetV2::thread_tmp_1685_fu_25919_p3() {
tmp_1685_fu_25919_p3 = esl_concat<10,3>(tmp_1684_fu_25914_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1686_fu_25931_p3() {
tmp_1686_fu_25931_p3 = esl_concat<10,1>(tmp_1684_fu_25914_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1687_fu_25943_p2() {
tmp_1687_fu_25943_p2 = (!p_shl555_cast_fu_25927_p1.read().is_01() || !p_shl556_cast_fu_25939_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl555_cast_fu_25927_p1.read()) + sc_biguint<15>(p_shl556_cast_fu_25939_p1.read()));
}
void ShuffleNetV2::thread_tmp_1688_fu_26202_p1() {
tmp_1688_fu_26202_p1 = co138_reg_7127.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1689_fu_26077_p2() {
tmp_1689_fu_26077_p2 = (!tmp_782_cast2_fu_26073_p1.read().is_01() || !tmp_1683_reg_40566.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_782_cast2_fu_26073_p1.read()) + sc_biguint<11>(tmp_1683_reg_40566.read()));
}
void ShuffleNetV2::thread_tmp_1690_fu_26082_p3() {
tmp_1690_fu_26082_p3 = esl_concat<11,3>(tmp_1689_fu_26077_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1691_fu_26094_p3() {
tmp_1691_fu_26094_p3 = esl_concat<11,1>(tmp_1689_fu_26077_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1692_fu_26106_p2() {
tmp_1692_fu_26106_p2 = (!p_shl563_cast_fu_26090_p1.read().is_01() || !p_shl564_cast_fu_26102_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl563_cast_fu_26090_p1.read()) + sc_biguint<15>(p_shl564_cast_fu_26102_p1.read()));
}
void ShuffleNetV2::thread_tmp_1693_fu_26112_p2() {
tmp_1693_fu_26112_p2 = (!tmp_782_cast1_fu_26069_p1.read().is_01() || !tmp_1680_reg_40561.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_782_cast1_fu_26069_p1.read()) + sc_biguint<10>(tmp_1680_reg_40561.read()));
}
void ShuffleNetV2::thread_tmp_1694_fu_26117_p3() {
tmp_1694_fu_26117_p3 = esl_concat<10,3>(tmp_1693_fu_26112_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1695_cast_fu_21008_p1() {
tmp_1695_cast_fu_21008_p1 = esl_sext<18,17>(tmp_1474_fu_21002_p2.read());
}
void ShuffleNetV2::thread_tmp_1695_fu_26129_p3() {
tmp_1695_fu_26129_p3 = esl_concat<10,1>(tmp_1693_fu_26112_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1696_cast_fu_21017_p1() {
tmp_1696_cast_fu_21017_p1 = esl_sext<33,18>(tmp_1475_fu_21012_p2.read());
}
void ShuffleNetV2::thread_tmp_1696_fu_26141_p2() {
tmp_1696_fu_26141_p2 = (!p_shl561_cast_fu_26125_p1.read().is_01() || !p_shl562_cast_fu_26137_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl561_cast_fu_26125_p1.read()) + sc_biguint<14>(p_shl562_cast_fu_26137_p1.read()));
}
void ShuffleNetV2::thread_tmp_1697_fu_25965_p2() {
tmp_1697_fu_25965_p2 = (!tmp_1687_reg_40530.read().is_01() || !tmp_783_cast_fu_25961_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1687_reg_40530.read()) + sc_biguint<15>(tmp_783_cast_fu_25961_p1.read()));
}
void ShuffleNetV2::thread_tmp_1698_fu_26167_p2() {
tmp_1698_fu_26167_p2 = (!tmp_1692_reg_40579.read().is_01() || !tmp_787_cast2_fu_26163_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1692_reg_40579.read()) + sc_biguint<15>(tmp_787_cast2_fu_26163_p1.read()));
}
void ShuffleNetV2::thread_tmp_1699_fu_26177_p2() {
tmp_1699_fu_26177_p2 = (!tmp_1696_reg_40584.read().is_01() || !tmp_787_cast1_fu_26159_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_1696_reg_40584.read()) + sc_biguint<14>(tmp_787_cast1_fu_26159_p1.read()));
}
void ShuffleNetV2::thread_tmp_1700_fu_26542_p1() {
tmp_1700_fu_26542_p1 = k56_reg_7171.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1701_fu_26301_p1() {
tmp_1701_fu_26301_p1 = i131_reg_7149.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1702_cast_fu_21036_p1() {
tmp_1702_cast_fu_21036_p1 = esl_sext<64,10>(tmp_1479_reg_38751.read());
}
void ShuffleNetV2::thread_tmp_1702_fu_26335_p1() {
tmp_1702_fu_26335_p1 = tmp_793_fu_26329_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1703_fu_26435_p3() {
tmp_1703_fu_26435_p3 = esl_concat<9,5>(tmp_797_reg_40661.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1704_fu_26442_p1() {
tmp_1704_fu_26442_p1 = esl_sext<16,14>(tmp_1703_fu_26435_p3.read());
}
void ShuffleNetV2::thread_tmp_1705_fu_26450_p3() {
tmp_1705_fu_26450_p3 = esl_concat<9,3>(tmp_797_reg_40661.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1706_fu_26457_p1() {
tmp_1706_fu_26457_p1 = esl_sext<14,12>(tmp_1705_fu_26450_p3.read());
}
void ShuffleNetV2::thread_tmp_1707_fu_26465_p2() {
tmp_1707_fu_26465_p2 = (!p_shl567_cast_fu_26446_p1.read().is_01() || !p_shl568_cast_fu_26461_p1.read().is_01())? sc_lv<17>(): (sc_biguint<17>(p_shl567_cast_fu_26446_p1.read()) - sc_biguint<17>(p_shl568_cast_fu_26461_p1.read()));
}
void ShuffleNetV2::thread_tmp_1708_fu_26475_p2() {
tmp_1708_fu_26475_p2 = (!tmp_786_cast_reg_40648.read().is_01() || !tmp_1973_cast_fu_26471_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(tmp_786_cast_reg_40648.read()) + sc_bigint<18>(tmp_1973_cast_fu_26471_p1.read()));
}
void ShuffleNetV2::thread_tmp_1709_fu_26404_p3() {
tmp_1709_fu_26404_p3 = esl_concat<4,6>(tmp_798_fu_26394_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1710_fu_26412_p3() {
tmp_1710_fu_26412_p3 = esl_concat<4,4>(tmp_798_fu_26394_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1711_fu_26424_p2() {
tmp_1711_fu_26424_p2 = (!tmp_1709_fu_26404_p3.read().is_01() || !p_shl566_cast_fu_26420_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1709_fu_26404_p3.read()) - sc_bigint<10>(p_shl566_cast_fu_26420_p1.read()));
}
void ShuffleNetV2::thread_tmp_1712_fu_26430_p2() {
tmp_1712_fu_26430_p2 = (!tmp_785_cast_reg_40643.read().is_01() || !tmp_1711_fu_26424_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_785_cast_reg_40643.read()) + sc_biguint<10>(tmp_1711_fu_26424_p2.read()));
}
void ShuffleNetV2::thread_tmp_1713_fu_27011_p1() {
tmp_1713_fu_27011_p1 = co142_reg_7248.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1714_fu_26911_p1() {
tmp_1714_fu_26911_p1 = k58_reg_7237.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1715_fu_26698_p1() {
tmp_1715_fu_26698_p1 = i136_reg_7215.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1716_fu_26759_p3() {
tmp_1716_fu_26759_p3 = esl_concat<7,2>(tmp_816_reg_40826.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1717_fu_26766_p1() {
tmp_1717_fu_26766_p1 = esl_sext<34,9>(tmp_1716_fu_26759_p3.read());
}
void ShuffleNetV2::thread_tmp_1718_fu_26774_p2() {
tmp_1718_fu_26774_p2 = (!p_shl572_cast_fu_26770_p1.read().is_01() || !tmp_817_cast1_fu_26755_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl572_cast_fu_26770_p1.read()) - sc_biguint<35>(tmp_817_cast1_fu_26755_p1.read()));
}
void ShuffleNetV2::thread_tmp_1719_fu_26784_p2() {
tmp_1719_fu_26784_p2 = (!tmp_1989_cast_fu_26780_p1.read().is_01() || !tmp_799_cast_reg_40795.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_1989_cast_fu_26780_p1.read()) + sc_biguint<36>(tmp_799_cast_reg_40795.read()));
}
void ShuffleNetV2::thread_tmp_1720_fu_26789_p1() {
tmp_1720_fu_26789_p1 = tmp_1719_fu_26784_p2.read().range(10-1, 0);
}
void ShuffleNetV2::thread_tmp_1721_fu_26793_p1() {
tmp_1721_fu_26793_p1 = tmp_1719_fu_26784_p2.read().range(8-1, 0);
}
void ShuffleNetV2::thread_tmp_1722_fu_26829_p2() {
tmp_1722_fu_26829_p2 = (!p_shl571_cast_fu_26822_p3.read().is_01() || !tmp_1720_reg_40838.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl571_cast_fu_26822_p3.read()) - sc_biguint<10>(tmp_1720_reg_40838.read()));
}
void ShuffleNetV2::thread_tmp_1723_cast_fu_21273_p1() {
tmp_1723_cast_fu_21273_p1 = esl_zext<64,15>(tmp_1499_fu_21268_p2.read());
}
void ShuffleNetV2::thread_tmp_1723_fu_26834_p2() {
tmp_1723_fu_26834_p2 = (!tmp_1722_fu_26829_p2.read().is_01() || !tmp_811_cast_reg_40813.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1722_fu_26829_p2.read()) + sc_biguint<10>(tmp_811_cast_reg_40813.read()));
}
void ShuffleNetV2::thread_tmp_1724_cast_fu_21475_p1() {
tmp_1724_cast_fu_21475_p1 = esl_zext<64,15>(tmp_1500_fu_21470_p2.read());
}
void ShuffleNetV2::thread_tmp_1724_fu_26800_p3() {
tmp_1724_fu_26800_p3 = esl_concat<10,2>(tmp_818_reg_40832.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1725_cast_fu_21485_p1() {
tmp_1725_cast_fu_21485_p1 = esl_zext<64,14>(tmp_1501_reg_38937.read());
}
void ShuffleNetV2::thread_tmp_1725_fu_26811_p2() {
tmp_1725_fu_26811_p2 = (!p_shl570_cast_fu_26807_p1.read().is_01() || !tmp_819_cast_fu_26797_p1.read().is_01())? sc_lv<13>(): (sc_biguint<13>(p_shl570_cast_fu_26807_p1.read()) - sc_biguint<13>(tmp_819_cast_fu_26797_p1.read()));
}
void ShuffleNetV2::thread_tmp_1726_fu_26817_p2() {
tmp_1726_fu_26817_p2 = (!tmp_1725_fu_26811_p2.read().is_01() || !tmp_799_cast1_reg_40790.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_1725_fu_26811_p2.read()) + sc_biguint<13>(tmp_799_cast1_reg_40790.read()));
}
void ShuffleNetV2::thread_tmp_1727_fu_26842_p3() {
tmp_1727_fu_26842_p3 = esl_concat<13,2>(tmp_1726_reg_40848.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1728_fu_26853_p2() {
tmp_1728_fu_26853_p2 = (!p_shl258_fu_26849_p1.read().is_01() || !tmp_1996_cast_fu_26839_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl258_fu_26849_p1.read()) - sc_bigint<64>(tmp_1996_cast_fu_26839_p1.read()));
}
void ShuffleNetV2::thread_tmp_1729_fu_26859_p2() {
tmp_1729_fu_26859_p2 = (!tmp_1728_fu_26853_p2.read().is_01() || !tmp_811_reg_40808.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_1728_fu_26853_p2.read()) + sc_biguint<64>(tmp_811_reg_40808.read()));
}
void ShuffleNetV2::thread_tmp_1730_fu_27447_p3() {
tmp_1730_fu_27447_p3 = esl_concat<6,3>(co144_reg_7303.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1731_fu_27459_p3() {
tmp_1731_fu_27459_p3 = esl_concat<6,1>(co144_reg_7303.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1732_fu_27471_p2() {
tmp_1732_fu_27471_p2 = (!p_shl578_cast_fu_27467_p1.read().is_01() || !p_shl577_cast_fu_27455_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(p_shl578_cast_fu_27467_p1.read()) + sc_biguint<10>(p_shl577_cast_fu_27455_p1.read()));
}
void ShuffleNetV2::thread_tmp_1733_fu_27351_p1() {
tmp_1733_fu_27351_p1 = k60_reg_7292.read().range(1-1, 0);
}
void ShuffleNetV2::thread_tmp_1734_cast_fu_21766_p1() {
tmp_1734_cast_fu_21766_p1 = esl_sext<18,17>(tmp_1507_fu_21760_p2.read());
}
void ShuffleNetV2::thread_tmp_1734_fu_27110_p1() {
tmp_1734_fu_27110_p1 = i138_reg_7270.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1735_cast_fu_21775_p1() {
tmp_1735_cast_fu_21775_p1 = esl_sext<33,18>(tmp_1508_fu_21770_p2.read());
}
void ShuffleNetV2::thread_tmp_1735_fu_27144_p1() {
tmp_1735_fu_27144_p1 = tmp_825_fu_27138_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1736_fu_27252_p3() {
tmp_1736_fu_27252_p3 = esl_concat<12,5>(tmp_830_reg_40961.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1737_fu_27263_p3() {
tmp_1737_fu_27263_p3 = esl_concat<12,3>(tmp_830_reg_40961.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1738_fu_27274_p2() {
tmp_1738_fu_27274_p2 = (!p_shl575_cast_fu_27259_p1.read().is_01() || !p_shl576_cast_fu_27270_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(p_shl575_cast_fu_27259_p1.read()) - sc_biguint<18>(p_shl576_cast_fu_27270_p1.read()));
}
void ShuffleNetV2::thread_tmp_1739_fu_27284_p2() {
tmp_1739_fu_27284_p2 = (!tmp_814_cast_reg_40948.read().is_01() || !tmp_2011_cast_fu_27280_p1.read().is_01())? sc_lv<19>(): (sc_biguint<19>(tmp_814_cast_reg_40948.read()) + sc_bigint<19>(tmp_2011_cast_fu_27280_p1.read()));
}
void ShuffleNetV2::thread_tmp_1740_fu_27221_p3() {
tmp_1740_fu_27221_p3 = esl_concat<4,6>(tmp_832_fu_27211_p4.read(), ap_const_lv6_0);
}
void ShuffleNetV2::thread_tmp_1741_cast_fu_21794_p1() {
tmp_1741_cast_fu_21794_p1 = esl_sext<64,10>(tmp_1512_reg_39006.read());
}
void ShuffleNetV2::thread_tmp_1741_fu_27229_p3() {
tmp_1741_fu_27229_p3 = esl_concat<4,4>(tmp_832_fu_27211_p4.read(), ap_const_lv4_0);
}
void ShuffleNetV2::thread_tmp_1742_fu_27241_p2() {
tmp_1742_fu_27241_p2 = (!tmp_1740_fu_27221_p3.read().is_01() || !p_shl574_cast_fu_27237_p1.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_1740_fu_27221_p3.read()) - sc_bigint<10>(p_shl574_cast_fu_27237_p1.read()));
}
void ShuffleNetV2::thread_tmp_1743_fu_27247_p2() {
tmp_1743_fu_27247_p2 = (!tmp_813_cast1_reg_40943.read().is_01() || !tmp_1742_fu_27241_p2.read().is_01())? sc_lv<10>(): (sc_bigint<10>(tmp_813_cast1_reg_40943.read()) + sc_biguint<10>(tmp_1742_fu_27241_p2.read()));
}
void ShuffleNetV2::thread_tmp_1744_fu_27570_p1() {
tmp_1744_fu_27570_p1 = co146_reg_7336.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1745_fu_27586_p2() {
tmp_1745_fu_27586_p2 = (!ap_const_lv5_3.is_01())? sc_lv<5>(): co146_reg_7336.read() << (unsigned short)ap_const_lv5_3.to_uint();
}
void ShuffleNetV2::thread_tmp_1746_fu_27493_p2() {
tmp_1746_fu_27493_p2 = (!tmp_834_cast_fu_27489_p1.read().is_01() || !tmp_1732_reg_41072.read().is_01())? sc_lv<10>(): (sc_biguint<10>(tmp_834_cast_fu_27489_p1.read()) + sc_biguint<10>(tmp_1732_reg_41072.read()));
}
void ShuffleNetV2::thread_tmp_1747_fu_27498_p3() {
tmp_1747_fu_27498_p3 = esl_concat<10,3>(tmp_1746_fu_27493_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1748_fu_27510_p3() {
tmp_1748_fu_27510_p3 = esl_concat<10,1>(tmp_1746_fu_27493_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1749_fu_27522_p2() {
tmp_1749_fu_27522_p2 = (!p_shl579_cast_fu_27506_p1.read().is_01() || !p_shl580_cast_fu_27518_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(p_shl579_cast_fu_27506_p1.read()) + sc_biguint<15>(p_shl580_cast_fu_27518_p1.read()));
}
void ShuffleNetV2::thread_tmp_1750_cast_fu_22071_p1() {
tmp_1750_cast_fu_22071_p1 = esl_sext<36,35>(tmp_1518_fu_22065_p2.read());
}
void ShuffleNetV2::thread_tmp_1750_fu_27544_p2() {
tmp_1750_fu_27544_p2 = (!tmp_1749_reg_41085.read().is_01() || !tmp_838_cast_fu_27540_p1.read().is_01())? sc_lv<15>(): (sc_biguint<15>(tmp_1749_reg_41085.read()) + sc_biguint<15>(tmp_838_cast_fu_27540_p1.read()));
}
void ShuffleNetV2::thread_tmp_1751_fu_27880_p1() {
tmp_1751_fu_27880_p1 = k62_reg_7380.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1752_fu_27657_p1() {
tmp_1752_fu_27657_p1 = i142_reg_7358.read().range(4-1, 0);
}
void ShuffleNetV2::thread_tmp_1753_fu_27677_p2() {
tmp_1753_fu_27677_p2 = (!ap_const_lv5_1.is_01())? sc_lv<5>(): i142_reg_7358.read() << (unsigned short)ap_const_lv5_1.to_uint();
}
void ShuffleNetV2::thread_tmp_1754_cast_fu_22174_p1() {
tmp_1754_cast_fu_22174_p1 = esl_zext<64,10>(tmp_1523_reg_39189.read());
}
void ShuffleNetV2::thread_tmp_1754_fu_27693_p1() {
tmp_1754_fu_27693_p1 = tmp_844_fu_27687_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1755_fu_27781_p3() {
tmp_1755_fu_27781_p3 = esl_concat<12,5>(tmp_847_reg_41162.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1756_fu_27792_p3() {
tmp_1756_fu_27792_p3 = esl_concat<12,3>(tmp_847_reg_41162.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1757_fu_27803_p2() {
tmp_1757_fu_27803_p2 = (!p_shl583_cast_fu_27788_p1.read().is_01() || !p_shl584_cast_fu_27799_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(p_shl583_cast_fu_27788_p1.read()) - sc_biguint<18>(p_shl584_cast_fu_27799_p1.read()));
}
void ShuffleNetV2::thread_tmp_1758_cast_fu_22138_p1() {
tmp_1758_cast_fu_22138_p1 = esl_sext<64,12>(tmp_1527_reg_39183.read());
}
void ShuffleNetV2::thread_tmp_1758_fu_27813_p2() {
tmp_1758_fu_27813_p2 = (!tmp_837_cast1_reg_41149.read().is_01() || !tmp_2033_cast_fu_27809_p1.read().is_01())? sc_lv<19>(): (sc_biguint<19>(tmp_837_cast1_reg_41149.read()) + sc_bigint<19>(tmp_2033_cast_fu_27809_p1.read()));
}
void ShuffleNetV2::thread_tmp_1759_fu_27750_p3() {
tmp_1759_fu_27750_p3 = esl_concat<5,7>(tmp_849_fu_27740_p4.read(), ap_const_lv7_0);
}
void ShuffleNetV2::thread_tmp_1760_fu_27758_p3() {
tmp_1760_fu_27758_p3 = esl_concat<5,5>(tmp_849_fu_27740_p4.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1761_fu_27770_p2() {
tmp_1761_fu_27770_p2 = (!tmp_1759_fu_27750_p3.read().is_01() || !p_shl582_cast_fu_27766_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1759_fu_27750_p3.read()) - sc_bigint<12>(p_shl582_cast_fu_27766_p1.read()));
}
void ShuffleNetV2::thread_tmp_1762_fu_27776_p2() {
tmp_1762_fu_27776_p2 = (!tmp_836_cast_reg_41144.read().is_01() || !tmp_1761_fu_27770_p2.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_836_cast_reg_41144.read()) + sc_biguint<12>(tmp_1761_fu_27770_p2.read()));
}
void ShuffleNetV2::thread_tmp_1763_fu_28349_p1() {
tmp_1763_fu_28349_p1 = co150_reg_7457.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1764_fu_28365_p2() {
tmp_1764_fu_28365_p2 = (!ap_const_lv5_3.is_01())? sc_lv<5>(): co150_reg_7457.read() << (unsigned short)ap_const_lv5_3.to_uint();
}
void ShuffleNetV2::thread_tmp_1765_fu_28249_p1() {
tmp_1765_fu_28249_p1 = k64_reg_7446.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1766_fu_28036_p1() {
tmp_1766_fu_28036_p1 = i147_reg_7424.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1767_fu_28097_p3() {
tmp_1767_fu_28097_p3 = esl_concat<8,2>(tmp_867_reg_41327.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1768_fu_28104_p1() {
tmp_1768_fu_28104_p1 = esl_sext<34,10>(tmp_1767_fu_28097_p3.read());
}
void ShuffleNetV2::thread_tmp_1769_fu_28112_p2() {
tmp_1769_fu_28112_p2 = (!p_shl588_cast_fu_28108_p1.read().is_01() || !tmp_868_cast_fu_28093_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl588_cast_fu_28108_p1.read()) - sc_biguint<35>(tmp_868_cast_fu_28093_p1.read()));
}
void ShuffleNetV2::thread_tmp_1770_fu_28122_p2() {
tmp_1770_fu_28122_p2 = (!tmp_2049_cast_fu_28118_p1.read().is_01() || !tmp_850_cast_reg_41296.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_2049_cast_fu_28118_p1.read()) + sc_biguint<36>(tmp_850_cast_reg_41296.read()));
}
void ShuffleNetV2::thread_tmp_1771_fu_28127_p1() {
tmp_1771_fu_28127_p1 = tmp_1770_fu_28122_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_1772_fu_28131_p1() {
tmp_1772_fu_28131_p1 = tmp_1770_fu_28122_p2.read().range(9-1, 0);
}
void ShuffleNetV2::thread_tmp_1773_cast_fu_22567_p1() {
tmp_1773_cast_fu_22567_p1 = esl_sext<18,17>(tmp_1539_fu_22561_p2.read());
}
void ShuffleNetV2::thread_tmp_1773_fu_28167_p2() {
tmp_1773_fu_28167_p2 = (!p_shl587_cast_fu_28160_p3.read().is_01() || !tmp_1771_reg_41339.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl587_cast_fu_28160_p3.read()) - sc_biguint<11>(tmp_1771_reg_41339.read()));
}
void ShuffleNetV2::thread_tmp_1774_cast_fu_22576_p1() {
tmp_1774_cast_fu_22576_p1 = esl_sext<33,18>(tmp_1540_fu_22571_p2.read());
}
void ShuffleNetV2::thread_tmp_1774_fu_28172_p2() {
tmp_1774_fu_28172_p2 = (!tmp_1773_fu_28167_p2.read().is_01() || !tmp_857_cast_reg_41314.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_1773_fu_28167_p2.read()) + sc_biguint<11>(tmp_857_cast_reg_41314.read()));
}
void ShuffleNetV2::thread_tmp_1775_fu_28138_p3() {
tmp_1775_fu_28138_p3 = esl_concat<10,2>(tmp_869_reg_41333.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1776_fu_28149_p2() {
tmp_1776_fu_28149_p2 = (!p_shl586_cast_fu_28145_p1.read().is_01() || !tmp_870_cast_fu_28135_p1.read().is_01())? sc_lv<13>(): (sc_biguint<13>(p_shl586_cast_fu_28145_p1.read()) - sc_biguint<13>(tmp_870_cast_fu_28135_p1.read()));
}
void ShuffleNetV2::thread_tmp_1777_fu_28155_p2() {
tmp_1777_fu_28155_p2 = (!tmp_1776_fu_28149_p2.read().is_01() || !tmp_850_cast1_reg_41291.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_1776_fu_28149_p2.read()) + sc_biguint<13>(tmp_850_cast1_reg_41291.read()));
}
void ShuffleNetV2::thread_tmp_1778_fu_28180_p3() {
tmp_1778_fu_28180_p3 = esl_concat<13,2>(tmp_1777_reg_41349.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1779_fu_28191_p2() {
tmp_1779_fu_28191_p2 = (!p_shl262_fu_28187_p1.read().is_01() || !tmp_2056_cast_fu_28177_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl262_fu_28187_p1.read()) - sc_bigint<64>(tmp_2056_cast_fu_28177_p1.read()));
}
void ShuffleNetV2::thread_tmp_1780_cast_fu_22595_p1() {
tmp_1780_cast_fu_22595_p1 = esl_sext<64,10>(tmp_1544_reg_39306.read());
}
void ShuffleNetV2::thread_tmp_1780_fu_28197_p2() {
tmp_1780_fu_28197_p2 = (!tmp_1779_fu_28191_p2.read().is_01() || !tmp_857_reg_41309.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_1779_fu_28191_p2.read()) + sc_biguint<64>(tmp_857_reg_41309.read()));
}
void ShuffleNetV2::thread_tmp_1781_fu_28659_p1() {
tmp_1781_fu_28659_p1 = k66_reg_7501.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1782_fu_28436_p1() {
tmp_1782_fu_28436_p1 = i149_reg_7479.read().range(4-1, 0);
}
void ShuffleNetV2::thread_tmp_1783_fu_28456_p2() {
tmp_1783_fu_28456_p2 = (!ap_const_lv5_1.is_01())? sc_lv<5>(): i149_reg_7479.read() << (unsigned short)ap_const_lv5_1.to_uint();
}
void ShuffleNetV2::thread_tmp_1784_fu_28472_p1() {
tmp_1784_fu_28472_p1 = tmp_876_fu_28466_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1785_fu_28560_p3() {
tmp_1785_fu_28560_p3 = esl_concat<12,5>(tmp_879_reg_41462.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1786_fu_28571_p3() {
tmp_1786_fu_28571_p3 = esl_concat<12,3>(tmp_879_reg_41462.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1787_fu_28582_p2() {
tmp_1787_fu_28582_p2 = (!p_shl591_cast_fu_28567_p1.read().is_01() || !p_shl592_cast_fu_28578_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(p_shl591_cast_fu_28567_p1.read()) - sc_biguint<18>(p_shl592_cast_fu_28578_p1.read()));
}
void ShuffleNetV2::thread_tmp_1788_fu_28592_p2() {
tmp_1788_fu_28592_p2 = (!tmp_865_cast_reg_41449.read().is_01() || !tmp_2067_cast_fu_28588_p1.read().is_01())? sc_lv<19>(): (sc_biguint<19>(tmp_865_cast_reg_41449.read()) + sc_bigint<19>(tmp_2067_cast_fu_28588_p1.read()));
}
void ShuffleNetV2::thread_tmp_1789_fu_28529_p3() {
tmp_1789_fu_28529_p3 = esl_concat<5,7>(tmp_880_fu_28519_p4.read(), ap_const_lv7_0);
}
void ShuffleNetV2::thread_tmp_1790_fu_28537_p3() {
tmp_1790_fu_28537_p3 = esl_concat<5,5>(tmp_880_fu_28519_p4.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1791_fu_28549_p2() {
tmp_1791_fu_28549_p2 = (!tmp_1789_fu_28529_p3.read().is_01() || !p_shl590_cast_fu_28545_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1789_fu_28529_p3.read()) - sc_bigint<12>(p_shl590_cast_fu_28545_p1.read()));
}
void ShuffleNetV2::thread_tmp_1792_fu_28555_p2() {
tmp_1792_fu_28555_p2 = (!tmp_863_cast_reg_41444.read().is_01() || !tmp_1791_fu_28549_p2.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_863_cast_reg_41444.read()) + sc_biguint<12>(tmp_1791_fu_28549_p2.read()));
}
void ShuffleNetV2::thread_tmp_1793_fu_29128_p1() {
tmp_1793_fu_29128_p1 = co154_reg_7578.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1794_fu_29144_p2() {
tmp_1794_fu_29144_p2 = (!ap_const_lv5_3.is_01())? sc_lv<5>(): co154_reg_7578.read() << (unsigned short)ap_const_lv5_3.to_uint();
}
void ShuffleNetV2::thread_tmp_1795_fu_29032_p1() {
tmp_1795_fu_29032_p1 = k68_reg_7567.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1796_fu_28819_p1() {
tmp_1796_fu_28819_p1 = i154_reg_7545.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1797_fu_28880_p3() {
tmp_1797_fu_28880_p3 = esl_concat<8,2>(tmp_896_reg_41627.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1798_fu_28887_p1() {
tmp_1798_fu_28887_p1 = esl_sext<34,10>(tmp_1797_fu_28880_p3.read());
}
void ShuffleNetV2::thread_tmp_1799_fu_28895_p2() {
tmp_1799_fu_28895_p2 = (!p_shl596_cast_fu_28891_p1.read().is_01() || !tmp_897_cast_fu_28876_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl596_cast_fu_28891_p1.read()) - sc_biguint<35>(tmp_897_cast_fu_28876_p1.read()));
}
void ShuffleNetV2::thread_tmp_1800_fu_28905_p2() {
tmp_1800_fu_28905_p2 = (!tmp_2083_cast_fu_28901_p1.read().is_01() || !tmp_881_cast_reg_41596.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_2083_cast_fu_28901_p1.read()) + sc_biguint<36>(tmp_881_cast_reg_41596.read()));
}
void ShuffleNetV2::thread_tmp_1801_cast_fu_22832_p1() {
tmp_1801_cast_fu_22832_p1 = esl_zext<64,15>(tmp_1564_fu_22827_p2.read());
}
void ShuffleNetV2::thread_tmp_1801_fu_28910_p1() {
tmp_1801_fu_28910_p1 = tmp_1800_fu_28905_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_1802_cast_fu_23034_p1() {
tmp_1802_cast_fu_23034_p1 = esl_zext<64,15>(tmp_1565_fu_23029_p2.read());
}
void ShuffleNetV2::thread_tmp_1802_fu_28914_p1() {
tmp_1802_fu_28914_p1 = tmp_1800_fu_28905_p2.read().range(9-1, 0);
}
void ShuffleNetV2::thread_tmp_1803_cast_fu_23044_p1() {
tmp_1803_cast_fu_23044_p1 = esl_zext<64,14>(tmp_1566_reg_39492.read());
}
void ShuffleNetV2::thread_tmp_1803_fu_28950_p2() {
tmp_1803_fu_28950_p2 = (!p_shl595_cast_fu_28943_p3.read().is_01() || !tmp_1801_reg_41639.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl595_cast_fu_28943_p3.read()) - sc_biguint<11>(tmp_1801_reg_41639.read()));
}
void ShuffleNetV2::thread_tmp_1804_fu_28955_p2() {
tmp_1804_fu_28955_p2 = (!tmp_1803_fu_28950_p2.read().is_01() || !tmp_891_cast_reg_41614.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_1803_fu_28950_p2.read()) + sc_biguint<11>(tmp_891_cast_reg_41614.read()));
}
void ShuffleNetV2::thread_tmp_1805_fu_28921_p3() {
tmp_1805_fu_28921_p3 = esl_concat<10,2>(tmp_898_reg_41633.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1806_fu_28932_p2() {
tmp_1806_fu_28932_p2 = (!p_shl594_cast_fu_28928_p1.read().is_01() || !tmp_899_cast_fu_28918_p1.read().is_01())? sc_lv<13>(): (sc_biguint<13>(p_shl594_cast_fu_28928_p1.read()) - sc_biguint<13>(tmp_899_cast_fu_28918_p1.read()));
}
void ShuffleNetV2::thread_tmp_1807_fu_28938_p2() {
tmp_1807_fu_28938_p2 = (!tmp_1806_fu_28932_p2.read().is_01() || !tmp_881_cast1_reg_41591.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_1806_fu_28932_p2.read()) + sc_biguint<13>(tmp_881_cast1_reg_41591.read()));
}
void ShuffleNetV2::thread_tmp_1808_fu_28963_p3() {
tmp_1808_fu_28963_p3 = esl_concat<13,2>(tmp_1807_reg_41649.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1809_fu_28974_p2() {
tmp_1809_fu_28974_p2 = (!p_shl267_fu_28970_p1.read().is_01() || !tmp_2090_cast_fu_28960_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl267_fu_28970_p1.read()) - sc_bigint<64>(tmp_2090_cast_fu_28960_p1.read()));
}
void ShuffleNetV2::thread_tmp_1810_fu_28980_p2() {
tmp_1810_fu_28980_p2 = (!tmp_1809_fu_28974_p2.read().is_01() || !tmp_891_reg_41609.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_1809_fu_28974_p2.read()) + sc_biguint<64>(tmp_891_reg_41609.read()));
}
void ShuffleNetV2::thread_tmp_1811_fu_29534_p3() {
tmp_1811_fu_29534_p3 = esl_concat<7,3>(co156_reg_7633.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1812_cast_fu_23325_p1() {
tmp_1812_cast_fu_23325_p1 = esl_sext<18,17>(tmp_1572_fu_23319_p2.read());
}
void ShuffleNetV2::thread_tmp_1812_fu_29546_p3() {
tmp_1812_fu_29546_p3 = esl_concat<7,1>(co156_reg_7633.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1813_cast_fu_23334_p1() {
tmp_1813_cast_fu_23334_p1 = esl_sext<33,18>(tmp_1573_fu_23329_p2.read());
}
void ShuffleNetV2::thread_tmp_1813_fu_29558_p2() {
tmp_1813_fu_29558_p2 = (!p_shl603_cast_fu_29542_p1.read().is_01() || !p_shl604_cast_fu_29554_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl603_cast_fu_29542_p1.read()) - sc_biguint<11>(p_shl604_cast_fu_29554_p1.read()));
}
void ShuffleNetV2::thread_tmp_1814_fu_29574_p3() {
tmp_1814_fu_29574_p3 = esl_concat<8,3>(tmp_900_fu_29568_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1815_fu_29586_p3() {
tmp_1815_fu_29586_p3 = esl_concat<8,1>(tmp_900_fu_29568_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1816_fu_29598_p2() {
tmp_1816_fu_29598_p2 = (!p_shl601_cast_fu_29582_p1.read().is_01() || !p_shl602_cast_fu_29594_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(p_shl601_cast_fu_29582_p1.read()) - sc_biguint<12>(p_shl602_cast_fu_29594_p1.read()));
}
void ShuffleNetV2::thread_tmp_1817_fu_29438_p1() {
tmp_1817_fu_29438_p1 = k70_reg_7622.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1818_fu_29215_p1() {
tmp_1818_fu_29215_p1 = i156_reg_7600.read().range(4-1, 0);
}
void ShuffleNetV2::thread_tmp_1819_cast_fu_23353_p1() {
tmp_1819_cast_fu_23353_p1 = esl_sext<64,10>(tmp_1577_reg_39561.read());
}
void ShuffleNetV2::thread_tmp_1819_fu_29235_p2() {
tmp_1819_fu_29235_p2 = (!ap_const_lv5_1.is_01())? sc_lv<5>(): i156_reg_7600.read() << (unsigned short)ap_const_lv5_1.to_uint();
}
void ShuffleNetV2::thread_tmp_1820_fu_29251_p1() {
tmp_1820_fu_29251_p1 = tmp_907_fu_29245_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1821_fu_29339_p3() {
tmp_1821_fu_29339_p3 = esl_concat<12,5>(tmp_910_reg_41762.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1822_fu_29350_p3() {
tmp_1822_fu_29350_p3 = esl_concat<12,3>(tmp_910_reg_41762.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1823_fu_29361_p2() {
tmp_1823_fu_29361_p2 = (!p_shl599_cast_fu_29346_p1.read().is_01() || !p_shl600_cast_fu_29357_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(p_shl599_cast_fu_29346_p1.read()) - sc_biguint<18>(p_shl600_cast_fu_29357_p1.read()));
}
void ShuffleNetV2::thread_tmp_1824_fu_29371_p2() {
tmp_1824_fu_29371_p2 = (!tmp_894_cast1_reg_41749.read().is_01() || !tmp_2107_cast_fu_29367_p1.read().is_01())? sc_lv<19>(): (sc_biguint<19>(tmp_894_cast1_reg_41749.read()) + sc_bigint<19>(tmp_2107_cast_fu_29367_p1.read()));
}
void ShuffleNetV2::thread_tmp_1825_fu_29308_p3() {
tmp_1825_fu_29308_p3 = esl_concat<5,7>(tmp_911_fu_29298_p4.read(), ap_const_lv7_0);
}
void ShuffleNetV2::thread_tmp_1826_fu_29316_p3() {
tmp_1826_fu_29316_p3 = esl_concat<5,5>(tmp_911_fu_29298_p4.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1827_fu_29328_p2() {
tmp_1827_fu_29328_p2 = (!tmp_1825_fu_29308_p3.read().is_01() || !p_shl598_cast_fu_29324_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1825_fu_29308_p3.read()) - sc_bigint<12>(p_shl598_cast_fu_29324_p1.read()));
}
void ShuffleNetV2::thread_tmp_1828_cast_fu_23630_p1() {
tmp_1828_cast_fu_23630_p1 = esl_sext<36,35>(tmp_1583_fu_23624_p2.read());
}
void ShuffleNetV2::thread_tmp_1828_fu_29334_p2() {
tmp_1828_fu_29334_p2 = (!tmp_893_cast_reg_41744.read().is_01() || !tmp_1827_fu_29328_p2.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_893_cast_reg_41744.read()) + sc_biguint<12>(tmp_1827_fu_29328_p2.read()));
}
void ShuffleNetV2::thread_tmp_1829_fu_29745_p1() {
tmp_1829_fu_29745_p1 = co158_reg_7666.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1830_fu_29761_p2() {
tmp_1830_fu_29761_p2 = (!ap_const_lv5_3.is_01())? sc_lv<5>(): co158_reg_7666.read() << (unsigned short)ap_const_lv5_3.to_uint();
}
void ShuffleNetV2::thread_tmp_1831_fu_29628_p2() {
tmp_1831_fu_29628_p2 = (!tmp_916_cast_fu_29624_p1.read().is_01() || !tmp_2099_cast_reg_41878.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_916_cast_fu_29624_p1.read()) + sc_bigint<13>(tmp_2099_cast_reg_41878.read()));
}
void ShuffleNetV2::thread_tmp_1832_cast_fu_23737_p1() {
tmp_1832_cast_fu_23737_p1 = esl_zext<64,10>(tmp_1588_reg_39744.read());
}
void ShuffleNetV2::thread_tmp_1832_fu_29633_p1() {
tmp_1832_fu_29633_p1 = tmp_1831_fu_29628_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_1833_fu_29653_p2() {
tmp_1833_fu_29653_p2 = (!p_shl607_cast_fu_29637_p3.read().is_01() || !p_shl608_cast_fu_29645_p3.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl607_cast_fu_29637_p3.read()) - sc_biguint<14>(p_shl608_cast_fu_29645_p3.read()));
}
void ShuffleNetV2::thread_tmp_1834_fu_29659_p2() {
tmp_1834_fu_29659_p2 = (!tmp_916_cast1_fu_29620_p1.read().is_01() || !tmp_2096_cast_reg_41873.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_916_cast1_fu_29620_p1.read()) + sc_bigint<12>(tmp_2096_cast_reg_41873.read()));
}
void ShuffleNetV2::thread_tmp_1835_cast_fu_23675_p1() {
tmp_1835_cast_fu_23675_p1 = esl_sext<13,12>(tmp_1591_fu_23669_p2.read());
}
void ShuffleNetV2::thread_tmp_1835_fu_29664_p1() {
tmp_1835_fu_29664_p1 = tmp_1834_fu_29659_p2.read().range(10-1, 0);
}
void ShuffleNetV2::thread_tmp_1836_cast_fu_23701_p1() {
tmp_1836_cast_fu_23701_p1 = esl_sext<64,13>(tmp_1592_reg_39738.read());
}
void ShuffleNetV2::thread_tmp_1836_fu_29684_p2() {
tmp_1836_fu_29684_p2 = (!p_shl605_cast_fu_29668_p3.read().is_01() || !p_shl606_cast_fu_29676_p3.read().is_01())? sc_lv<13>(): (sc_biguint<13>(p_shl605_cast_fu_29668_p3.read()) - sc_biguint<13>(p_shl606_cast_fu_29676_p3.read()));
}
void ShuffleNetV2::thread_tmp_1837_fu_29710_p2() {
tmp_1837_fu_29710_p2 = (!tmp_1833_reg_41891.read().is_01() || !tmp_920_cast2_fu_29706_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_1833_reg_41891.read()) + sc_biguint<14>(tmp_920_cast2_fu_29706_p1.read()));
}
void ShuffleNetV2::thread_tmp_1838_fu_29720_p2() {
tmp_1838_fu_29720_p2 = (!tmp_1836_reg_41896.read().is_01() || !tmp_920_cast1_fu_29702_p1.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_1836_reg_41896.read()) + sc_biguint<13>(tmp_920_cast1_fu_29702_p1.read()));
}
void ShuffleNetV2::thread_tmp_1839_fu_30055_p1() {
tmp_1839_fu_30055_p1 = k72_reg_7710.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1840_fu_29832_p1() {
tmp_1840_fu_29832_p1 = i160_reg_7688.read().range(4-1, 0);
}
void ShuffleNetV2::thread_tmp_1841_fu_29852_p2() {
tmp_1841_fu_29852_p2 = (!ap_const_lv5_1.is_01())? sc_lv<5>(): i160_reg_7688.read() << (unsigned short)ap_const_lv5_1.to_uint();
}
void ShuffleNetV2::thread_tmp_1842_fu_29868_p1() {
tmp_1842_fu_29868_p1 = tmp_926_fu_29862_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1843_fu_29956_p3() {
tmp_1843_fu_29956_p3 = esl_concat<12,5>(tmp_929_reg_41973.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1844_fu_29967_p3() {
tmp_1844_fu_29967_p3 = esl_concat<12,3>(tmp_929_reg_41973.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1845_fu_29978_p2() {
tmp_1845_fu_29978_p2 = (!p_shl611_cast_fu_29963_p1.read().is_01() || !p_shl612_cast_fu_29974_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(p_shl611_cast_fu_29963_p1.read()) - sc_biguint<18>(p_shl612_cast_fu_29974_p1.read()));
}
void ShuffleNetV2::thread_tmp_1846_fu_29988_p2() {
tmp_1846_fu_29988_p2 = (!tmp_919_cast_reg_41960.read().is_01() || !tmp_2134_cast_fu_29984_p1.read().is_01())? sc_lv<19>(): (sc_biguint<19>(tmp_919_cast_reg_41960.read()) + sc_bigint<19>(tmp_2134_cast_fu_29984_p1.read()));
}
void ShuffleNetV2::thread_tmp_1847_fu_29925_p3() {
tmp_1847_fu_29925_p3 = esl_concat<5,7>(tmp_930_fu_29915_p4.read(), ap_const_lv7_0);
}
void ShuffleNetV2::thread_tmp_1848_fu_29933_p3() {
tmp_1848_fu_29933_p3 = esl_concat<5,5>(tmp_930_fu_29915_p4.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1849_fu_29945_p2() {
tmp_1849_fu_29945_p2 = (!tmp_1847_fu_29925_p3.read().is_01() || !p_shl610_cast_fu_29941_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1847_fu_29925_p3.read()) - sc_bigint<12>(p_shl610_cast_fu_29941_p1.read()));
}
void ShuffleNetV2::thread_tmp_1850_fu_29951_p2() {
tmp_1850_fu_29951_p2 = (!tmp_918_cast_reg_41955.read().is_01() || !tmp_1849_fu_29945_p2.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_918_cast_reg_41955.read()) + sc_biguint<12>(tmp_1849_fu_29945_p2.read()));
}
void ShuffleNetV2::thread_tmp_1851_cast_fu_24130_p1() {
tmp_1851_cast_fu_24130_p1 = esl_sext<18,17>(tmp_1604_fu_24124_p2.read());
}
void ShuffleNetV2::thread_tmp_1851_fu_30516_p1() {
tmp_1851_fu_30516_p1 = co162_reg_7787.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1852_cast_fu_24139_p1() {
tmp_1852_cast_fu_24139_p1 = esl_sext<33,18>(tmp_1605_fu_24134_p2.read());
}
void ShuffleNetV2::thread_tmp_1852_fu_30532_p2() {
tmp_1852_fu_30532_p2 = (!ap_const_lv5_3.is_01())? sc_lv<5>(): co162_reg_7787.read() << (unsigned short)ap_const_lv5_3.to_uint();
}
void ShuffleNetV2::thread_tmp_1853_fu_30420_p1() {
tmp_1853_fu_30420_p1 = k74_reg_7776.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1854_fu_30207_p1() {
tmp_1854_fu_30207_p1 = i165_reg_7754.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1855_fu_30268_p3() {
tmp_1855_fu_30268_p3 = esl_concat<8,2>(tmp_946_reg_42138.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1856_fu_30275_p1() {
tmp_1856_fu_30275_p1 = esl_sext<34,10>(tmp_1855_fu_30268_p3.read());
}
void ShuffleNetV2::thread_tmp_1857_fu_30283_p2() {
tmp_1857_fu_30283_p2 = (!p_shl616_cast_fu_30279_p1.read().is_01() || !tmp_947_cast1_fu_30264_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl616_cast_fu_30279_p1.read()) - sc_biguint<35>(tmp_947_cast1_fu_30264_p1.read()));
}
void ShuffleNetV2::thread_tmp_1858_cast_fu_24158_p1() {
tmp_1858_cast_fu_24158_p1 = esl_sext<64,10>(tmp_1609_reg_39861.read());
}
void ShuffleNetV2::thread_tmp_1858_fu_30293_p2() {
tmp_1858_fu_30293_p2 = (!tmp_2150_cast_fu_30289_p1.read().is_01() || !tmp_933_cast_reg_42107.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_2150_cast_fu_30289_p1.read()) + sc_biguint<36>(tmp_933_cast_reg_42107.read()));
}
void ShuffleNetV2::thread_tmp_1859_fu_30298_p1() {
tmp_1859_fu_30298_p1 = tmp_1858_fu_30293_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_1860_fu_30302_p1() {
tmp_1860_fu_30302_p1 = tmp_1858_fu_30293_p2.read().range(9-1, 0);
}
void ShuffleNetV2::thread_tmp_1861_fu_30338_p2() {
tmp_1861_fu_30338_p2 = (!p_shl615_cast_fu_30331_p3.read().is_01() || !tmp_1859_reg_42150.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl615_cast_fu_30331_p3.read()) - sc_biguint<11>(tmp_1859_reg_42150.read()));
}
void ShuffleNetV2::thread_tmp_1862_fu_30343_p2() {
tmp_1862_fu_30343_p2 = (!tmp_1861_fu_30338_p2.read().is_01() || !tmp_941_cast1_reg_42125.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_1861_fu_30338_p2.read()) + sc_biguint<11>(tmp_941_cast1_reg_42125.read()));
}
void ShuffleNetV2::thread_tmp_1863_fu_30309_p3() {
tmp_1863_fu_30309_p3 = esl_concat<10,2>(tmp_948_reg_42144.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1864_fu_30320_p2() {
tmp_1864_fu_30320_p2 = (!p_shl614_cast_fu_30316_p1.read().is_01() || !tmp_949_cast_fu_30306_p1.read().is_01())? sc_lv<13>(): (sc_biguint<13>(p_shl614_cast_fu_30316_p1.read()) - sc_biguint<13>(tmp_949_cast_fu_30306_p1.read()));
}
void ShuffleNetV2::thread_tmp_1865_fu_30326_p2() {
tmp_1865_fu_30326_p2 = (!tmp_1864_fu_30320_p2.read().is_01() || !tmp_933_cast1_reg_42102.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_1864_fu_30320_p2.read()) + sc_biguint<13>(tmp_933_cast1_reg_42102.read()));
}
void ShuffleNetV2::thread_tmp_1866_fu_30351_p3() {
tmp_1866_fu_30351_p3 = esl_concat<13,2>(tmp_1865_reg_42160.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1867_fu_30362_p2() {
tmp_1867_fu_30362_p2 = (!p_shl273_fu_30358_p1.read().is_01() || !tmp_2157_cast_fu_30348_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl273_fu_30358_p1.read()) - sc_bigint<64>(tmp_2157_cast_fu_30348_p1.read()));
}
void ShuffleNetV2::thread_tmp_1868_fu_30368_p2() {
tmp_1868_fu_30368_p2 = (!tmp_1867_fu_30362_p2.read().is_01() || !tmp_941_reg_42120.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_1867_fu_30362_p2.read()) + sc_biguint<64>(tmp_941_reg_42120.read()));
}
void ShuffleNetV2::thread_tmp_1869_fu_30926_p3() {
tmp_1869_fu_30926_p3 = esl_concat<7,3>(co164_reg_7842.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1870_fu_30938_p3() {
tmp_1870_fu_30938_p3 = esl_concat<7,1>(co164_reg_7842.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1871_fu_30950_p2() {
tmp_1871_fu_30950_p2 = (!p_shl621_cast_fu_30934_p1.read().is_01() || !p_shl622_cast_fu_30946_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl621_cast_fu_30934_p1.read()) - sc_biguint<11>(p_shl622_cast_fu_30946_p1.read()));
}
void ShuffleNetV2::thread_tmp_1872_fu_30834_p1() {
tmp_1872_fu_30834_p1 = k76_reg_7831.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1873_fu_30603_p1() {
tmp_1873_fu_30603_p1 = i167_reg_7809.read().range(4-1, 0);
}
void ShuffleNetV2::thread_tmp_1874_fu_30623_p2() {
tmp_1874_fu_30623_p2 = (!ap_const_lv5_1.is_01())? sc_lv<5>(): i167_reg_7809.read() << (unsigned short)ap_const_lv5_1.to_uint();
}
void ShuffleNetV2::thread_tmp_1875_fu_30639_p1() {
tmp_1875_fu_30639_p1 = tmp_955_fu_30633_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1876_fu_30727_p3() {
tmp_1876_fu_30727_p3 = esl_concat<11,5>(tmp_958_reg_42273.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1877_fu_30734_p1() {
tmp_1877_fu_30734_p1 = esl_sext<17,16>(tmp_1876_fu_30727_p3.read());
}
void ShuffleNetV2::thread_tmp_1878_fu_30742_p3() {
tmp_1878_fu_30742_p3 = esl_concat<11,3>(tmp_958_reg_42273.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1879_cast_fu_24395_p1() {
tmp_1879_cast_fu_24395_p1 = esl_zext<64,15>(tmp_1629_fu_24390_p2.read());
}
void ShuffleNetV2::thread_tmp_1879_fu_30749_p1() {
tmp_1879_fu_30749_p1 = esl_sext<15,14>(tmp_1878_fu_30742_p3.read());
}
void ShuffleNetV2::thread_tmp_1880_cast_fu_24597_p1() {
tmp_1880_cast_fu_24597_p1 = esl_zext<64,15>(tmp_1630_fu_24592_p2.read());
}
void ShuffleNetV2::thread_tmp_1880_fu_30757_p2() {
tmp_1880_fu_30757_p2 = (!p_shl619_cast_fu_30738_p1.read().is_01() || !p_shl620_cast_fu_30753_p1.read().is_01())? sc_lv<18>(): (sc_biguint<18>(p_shl619_cast_fu_30738_p1.read()) - sc_biguint<18>(p_shl620_cast_fu_30753_p1.read()));
}
void ShuffleNetV2::thread_tmp_1881_cast_fu_24607_p1() {
tmp_1881_cast_fu_24607_p1 = esl_zext<64,14>(tmp_1631_reg_40047.read());
}
void ShuffleNetV2::thread_tmp_1881_fu_30767_p2() {
tmp_1881_fu_30767_p2 = (!tmp_944_cast1_reg_42260.read().is_01() || !tmp_2173_cast_fu_30763_p1.read().is_01())? sc_lv<19>(): (sc_biguint<19>(tmp_944_cast1_reg_42260.read()) + sc_bigint<19>(tmp_2173_cast_fu_30763_p1.read()));
}
void ShuffleNetV2::thread_tmp_1882_fu_30696_p3() {
tmp_1882_fu_30696_p3 = esl_concat<5,7>(tmp_959_fu_30686_p4.read(), ap_const_lv7_0);
}
void ShuffleNetV2::thread_tmp_1883_fu_30704_p3() {
tmp_1883_fu_30704_p3 = esl_concat<5,5>(tmp_959_fu_30686_p4.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1884_fu_30716_p2() {
tmp_1884_fu_30716_p2 = (!tmp_1882_fu_30696_p3.read().is_01() || !p_shl618_cast_fu_30712_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1882_fu_30696_p3.read()) - sc_bigint<12>(p_shl618_cast_fu_30712_p1.read()));
}
void ShuffleNetV2::thread_tmp_1885_fu_30722_p2() {
tmp_1885_fu_30722_p2 = (!tmp_943_cast_reg_42255.read().is_01() || !tmp_1884_fu_30716_p2.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_943_cast_reg_42255.read()) + sc_biguint<12>(tmp_1884_fu_30716_p2.read()));
}
void ShuffleNetV2::thread_tmp_1886_fu_31053_p3() {
tmp_1886_fu_31053_p3 = esl_concat<7,3>(co166_reg_7875.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1887_fu_31065_p3() {
tmp_1887_fu_31065_p3 = esl_concat<7,1>(co166_reg_7875.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1888_fu_31077_p2() {
tmp_1888_fu_31077_p2 = (!p_shl627_cast_fu_31061_p1.read().is_01() || !p_shl628_cast_fu_31073_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl627_cast_fu_31061_p1.read()) - sc_biguint<11>(p_shl628_cast_fu_31073_p1.read()));
}
void ShuffleNetV2::thread_tmp_1889_fu_31093_p3() {
tmp_1889_fu_31093_p3 = esl_concat<8,3>(tmp_962_fu_31087_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1890_fu_31105_p3() {
tmp_1890_fu_31105_p3 = esl_concat<8,1>(tmp_962_fu_31087_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1891_fu_31117_p2() {
tmp_1891_fu_31117_p2 = (!p_shl625_cast_fu_31101_p1.read().is_01() || !p_shl626_cast_fu_31113_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(p_shl625_cast_fu_31101_p1.read()) - sc_biguint<12>(p_shl626_cast_fu_31113_p1.read()));
}
void ShuffleNetV2::thread_tmp_1892_cast_fu_24896_p1() {
tmp_1892_cast_fu_24896_p1 = esl_sext<18,17>(tmp_1639_fu_24890_p2.read());
}
void ShuffleNetV2::thread_tmp_1892_fu_30976_p2() {
tmp_1892_fu_30976_p2 = (!tmp_2163_cast_reg_42384.read().is_01() || !tmp_964_cast_fu_30972_p1.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_2163_cast_reg_42384.read()) + sc_biguint<12>(tmp_964_cast_fu_30972_p1.read()));
}
void ShuffleNetV2::thread_tmp_1893_cast_fu_24905_p1() {
tmp_1893_cast_fu_24905_p1 = esl_sext<33,18>(tmp_1640_fu_24900_p2.read());
}
void ShuffleNetV2::thread_tmp_1893_fu_30981_p1() {
tmp_1893_fu_30981_p1 = tmp_1892_fu_30976_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_1894_fu_30993_p3() {
tmp_1894_fu_30993_p3 = esl_concat<12,1>(tmp_1892_fu_30976_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1895_fu_31005_p2() {
tmp_1895_fu_31005_p2 = (!p_shl623_cast_fu_30985_p3.read().is_01() || !p_shl624_cast_fu_31001_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl623_cast_fu_30985_p3.read()) - sc_bigint<14>(p_shl624_cast_fu_31001_p1.read()));
}
void ShuffleNetV2::thread_tmp_1896_fu_31264_p1() {
tmp_1896_fu_31264_p1 = co168_reg_7908.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1897_fu_31280_p2() {
tmp_1897_fu_31280_p2 = (!ap_const_lv5_3.is_01())? sc_lv<5>(): co168_reg_7908.read() << (unsigned short)ap_const_lv5_3.to_uint();
}
void ShuffleNetV2::thread_tmp_1898_fu_31147_p2() {
tmp_1898_fu_31147_p2 = (!tmp_966_cast_fu_31143_p1.read().is_01() || !tmp_2183_cast_reg_42428.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_966_cast_fu_31143_p1.read()) + sc_bigint<12>(tmp_2183_cast_reg_42428.read()));
}
void ShuffleNetV2::thread_tmp_1899_cast_fu_24924_p1() {
tmp_1899_cast_fu_24924_p1 = esl_sext<64,10>(tmp_1644_reg_40116.read());
}
void ShuffleNetV2::thread_tmp_1899_fu_31152_p1() {
tmp_1899_fu_31152_p1 = tmp_1898_fu_31147_p2.read().range(10-1, 0);
}
void ShuffleNetV2::thread_tmp_1900_fu_31172_p2() {
tmp_1900_fu_31172_p2 = (!p_shl631_cast_fu_31156_p3.read().is_01() || !p_shl632_cast_fu_31164_p3.read().is_01())? sc_lv<13>(): (sc_biguint<13>(p_shl631_cast_fu_31156_p3.read()) - sc_biguint<13>(p_shl632_cast_fu_31164_p3.read()));
}
void ShuffleNetV2::thread_tmp_1901_fu_31178_p2() {
tmp_1901_fu_31178_p2 = (!tmp_966_cast1_fu_31139_p1.read().is_01() || !tmp_2186_cast_reg_42433.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_966_cast1_fu_31139_p1.read()) + sc_bigint<13>(tmp_2186_cast_reg_42433.read()));
}
void ShuffleNetV2::thread_tmp_1902_fu_31183_p1() {
tmp_1902_fu_31183_p1 = tmp_1901_fu_31178_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_1903_fu_31203_p2() {
tmp_1903_fu_31203_p2 = (!p_shl629_cast_fu_31187_p3.read().is_01() || !p_shl630_cast_fu_31195_p3.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl629_cast_fu_31187_p3.read()) - sc_biguint<14>(p_shl630_cast_fu_31195_p3.read()));
}
void ShuffleNetV2::thread_tmp_1904_fu_31027_p2() {
tmp_1904_fu_31027_p2 = (!tmp_1895_reg_42397.read().is_01() || !tmp_967_cast1_fu_31023_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_1895_reg_42397.read()) + sc_biguint<14>(tmp_967_cast1_fu_31023_p1.read()));
}
void ShuffleNetV2::thread_tmp_1905_fu_31229_p2() {
tmp_1905_fu_31229_p2 = (!tmp_1900_reg_42446.read().is_01() || !tmp_971_cast_fu_31225_p1.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_1900_reg_42446.read()) + sc_biguint<13>(tmp_971_cast_fu_31225_p1.read()));
}
void ShuffleNetV2::thread_tmp_1906_fu_31234_p2() {
tmp_1906_fu_31234_p2 = (!tmp_1903_reg_42451.read().is_01() || !tmp_971_cast1_fu_31221_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_1903_reg_42451.read()) + sc_biguint<14>(tmp_971_cast1_fu_31221_p1.read()));
}
void ShuffleNetV2::thread_tmp_1907_fu_31574_p1() {
tmp_1907_fu_31574_p1 = k78_reg_7952.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1908_cast_fu_25201_p1() {
tmp_1908_cast_fu_25201_p1 = esl_sext<36,35>(tmp_1650_fu_25195_p2.read());
}
void ShuffleNetV2::thread_tmp_1908_fu_31351_p1() {
tmp_1908_fu_31351_p1 = i171_reg_7930.read().range(4-1, 0);
}
void ShuffleNetV2::thread_tmp_1909_fu_31371_p2() {
tmp_1909_fu_31371_p2 = (!ap_const_lv5_1.is_01())? sc_lv<5>(): i171_reg_7930.read() << (unsigned short)ap_const_lv5_1.to_uint();
}
void ShuffleNetV2::thread_tmp_1910_fu_31387_p1() {
tmp_1910_fu_31387_p1 = tmp_977_fu_31381_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1911_fu_31475_p3() {
tmp_1911_fu_31475_p3 = esl_concat<13,5>(tmp_981_reg_42528.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1912_cast_fu_25300_p1() {
tmp_1912_cast_fu_25300_p1 = esl_zext<64,10>(tmp_1655_reg_40299.read());
}
void ShuffleNetV2::thread_tmp_1912_fu_31486_p3() {
tmp_1912_fu_31486_p3 = esl_concat<13,3>(tmp_981_reg_42528.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1913_fu_31497_p2() {
tmp_1913_fu_31497_p2 = (!p_shl635_cast_fu_31482_p1.read().is_01() || !p_shl636_cast_fu_31493_p1.read().is_01())? sc_lv<19>(): (sc_biguint<19>(p_shl635_cast_fu_31482_p1.read()) - sc_biguint<19>(p_shl636_cast_fu_31493_p1.read()));
}
void ShuffleNetV2::thread_tmp_1914_cast_fu_25238_p1() {
tmp_1914_cast_fu_25238_p1 = esl_sext<14,13>(tmp_1657_fu_25232_p2.read());
}
void ShuffleNetV2::thread_tmp_1914_fu_31507_p2() {
tmp_1914_fu_31507_p2 = (!tmp_970_cast1_reg_42515.read().is_01() || !tmp_2211_cast_fu_31503_p1.read().is_01())? sc_lv<20>(): (sc_biguint<20>(tmp_970_cast1_reg_42515.read()) + sc_bigint<20>(tmp_2211_cast_fu_31503_p1.read()));
}
void ShuffleNetV2::thread_tmp_1915_cast_fu_25264_p1() {
tmp_1915_cast_fu_25264_p1 = esl_sext<64,14>(tmp_1658_reg_40293.read());
}
void ShuffleNetV2::thread_tmp_1915_fu_31444_p3() {
tmp_1915_fu_31444_p3 = esl_concat<5,7>(tmp_983_fu_31434_p4.read(), ap_const_lv7_0);
}
void ShuffleNetV2::thread_tmp_1916_fu_31452_p3() {
tmp_1916_fu_31452_p3 = esl_concat<5,5>(tmp_983_fu_31434_p4.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1917_fu_31464_p2() {
tmp_1917_fu_31464_p2 = (!tmp_1915_fu_31444_p3.read().is_01() || !p_shl634_cast_fu_31460_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1915_fu_31444_p3.read()) - sc_bigint<12>(p_shl634_cast_fu_31460_p1.read()));
}
void ShuffleNetV2::thread_tmp_1918_fu_31470_p2() {
tmp_1918_fu_31470_p2 = (!tmp_969_cast_reg_42510.read().is_01() || !tmp_1917_fu_31464_p2.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_969_cast_reg_42510.read()) + sc_biguint<12>(tmp_1917_fu_31464_p2.read()));
}
void ShuffleNetV2::thread_tmp_1919_fu_32047_p1() {
tmp_1919_fu_32047_p1 = co172_reg_8029.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1920_fu_32063_p2() {
tmp_1920_fu_32063_p2 = (!ap_const_lv5_3.is_01())? sc_lv<5>(): co172_reg_8029.read() << (unsigned short)ap_const_lv5_3.to_uint();
}
void ShuffleNetV2::thread_tmp_1921_fu_31951_p1() {
tmp_1921_fu_31951_p1 = k80_reg_8018.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1922_fu_31726_p1() {
tmp_1922_fu_31726_p1 = i176_reg_7996.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1923_fu_31787_p3() {
tmp_1923_fu_31787_p3 = esl_concat<8,2>(tmp_999_reg_42693.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1924_fu_31794_p1() {
tmp_1924_fu_31794_p1 = esl_sext<34,10>(tmp_1923_fu_31787_p3.read());
}
void ShuffleNetV2::thread_tmp_1925_fu_31802_p2() {
tmp_1925_fu_31802_p2 = (!p_shl640_cast_fu_31798_p1.read().is_01() || !tmp_1000_cast_fu_31783_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl640_cast_fu_31798_p1.read()) - sc_biguint<35>(tmp_1000_cast_fu_31783_p1.read()));
}
void ShuffleNetV2::thread_tmp_1926_fu_31812_p2() {
tmp_1926_fu_31812_p2 = (!tmp_2227_cast_fu_31808_p1.read().is_01() || !tmp_984_cast_reg_42662.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_2227_cast_fu_31808_p1.read()) + sc_biguint<36>(tmp_984_cast_reg_42662.read()));
}
void ShuffleNetV2::thread_tmp_1927_fu_31817_p1() {
tmp_1927_fu_31817_p1 = tmp_1926_fu_31812_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_1928_fu_31821_p1() {
tmp_1928_fu_31821_p1 = tmp_1926_fu_31812_p2.read().range(9-1, 0);
}
void ShuffleNetV2::thread_tmp_1929_fu_31869_p2() {
tmp_1929_fu_31869_p2 = (!p_shl639_cast_fu_31862_p3.read().is_01() || !tmp_1927_reg_42705.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl639_cast_fu_31862_p3.read()) - sc_biguint<11>(tmp_1927_reg_42705.read()));
}
void ShuffleNetV2::thread_tmp_1930_fu_31874_p2() {
tmp_1930_fu_31874_p2 = (!tmp_1929_fu_31869_p2.read().is_01() || !tmp_991_cast_reg_42680.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_1929_fu_31869_p2.read()) + sc_biguint<11>(tmp_991_cast_reg_42680.read()));
}
void ShuffleNetV2::thread_tmp_1931_fu_31832_p3() {
tmp_1931_fu_31832_p3 = esl_concat<9,2>(tmp_1001_reg_42699.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1932_cast_fu_25701_p1() {
tmp_1932_cast_fu_25701_p1 = esl_sext<18,17>(tmp_1672_fu_25695_p2.read());
}
void ShuffleNetV2::thread_tmp_1932_fu_31839_p1() {
tmp_1932_fu_31839_p1 = esl_sext<12,11>(tmp_1931_fu_31832_p3.read());
}
void ShuffleNetV2::thread_tmp_1933_cast_fu_25710_p1() {
tmp_1933_cast_fu_25710_p1 = esl_sext<33,18>(tmp_1673_fu_25705_p2.read());
}
void ShuffleNetV2::thread_tmp_1933_fu_31847_p2() {
tmp_1933_fu_31847_p2 = (!p_shl638_cast_fu_31843_p1.read().is_01() || !tmp_1002_cast_fu_31828_p1.read().is_01())? sc_lv<13>(): (sc_biguint<13>(p_shl638_cast_fu_31843_p1.read()) - sc_biguint<13>(tmp_1002_cast_fu_31828_p1.read()));
}
void ShuffleNetV2::thread_tmp_1934_fu_31857_p2() {
tmp_1934_fu_31857_p2 = (!tmp_2234_cast_fu_31853_p1.read().is_01() || !tmp_984_cast1_reg_42657.read().is_01())? sc_lv<14>(): (sc_bigint<14>(tmp_2234_cast_fu_31853_p1.read()) + sc_biguint<14>(tmp_984_cast1_reg_42657.read()));
}
void ShuffleNetV2::thread_tmp_1935_fu_31882_p3() {
tmp_1935_fu_31882_p3 = esl_concat<14,2>(tmp_1934_reg_42715.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1936_fu_31893_p2() {
tmp_1936_fu_31893_p2 = (!p_shl275_fu_31889_p1.read().is_01() || !tmp_2235_cast_fu_31879_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl275_fu_31889_p1.read()) - sc_bigint<64>(tmp_2235_cast_fu_31879_p1.read()));
}
void ShuffleNetV2::thread_tmp_1937_fu_31899_p2() {
tmp_1937_fu_31899_p2 = (!tmp_1936_fu_31893_p2.read().is_01() || !tmp_991_reg_42675.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_1936_fu_31893_p2.read()) + sc_biguint<64>(tmp_991_reg_42675.read()));
}
void ShuffleNetV2::thread_tmp_1938_fu_32449_p3() {
tmp_1938_fu_32449_p3 = esl_concat<7,3>(co174_reg_8084.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1939_cast_fu_25729_p1() {
tmp_1939_cast_fu_25729_p1 = esl_sext<64,10>(tmp_1677_reg_40416.read());
}
void ShuffleNetV2::thread_tmp_1939_fu_32461_p3() {
tmp_1939_fu_32461_p3 = esl_concat<7,1>(co174_reg_8084.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1940_fu_32473_p2() {
tmp_1940_fu_32473_p2 = (!p_shl645_cast_fu_32457_p1.read().is_01() || !p_shl646_cast_fu_32469_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl645_cast_fu_32457_p1.read()) - sc_biguint<11>(p_shl646_cast_fu_32469_p1.read()));
}
void ShuffleNetV2::thread_tmp_1941_fu_32357_p1() {
tmp_1941_fu_32357_p1 = k82_reg_8073.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1942_fu_32134_p1() {
tmp_1942_fu_32134_p1 = i178_reg_8051.read().range(4-1, 0);
}
void ShuffleNetV2::thread_tmp_1943_fu_32154_p2() {
tmp_1943_fu_32154_p2 = (!ap_const_lv5_1.is_01())? sc_lv<5>(): i178_reg_8051.read() << (unsigned short)ap_const_lv5_1.to_uint();
}
void ShuffleNetV2::thread_tmp_1944_fu_32170_p1() {
tmp_1944_fu_32170_p1 = tmp_1008_fu_32164_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1945_fu_32258_p3() {
tmp_1945_fu_32258_p3 = esl_concat<13,5>(tmp_1013_reg_42828.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1946_fu_32269_p3() {
tmp_1946_fu_32269_p3 = esl_concat<13,3>(tmp_1013_reg_42828.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1947_fu_32280_p2() {
tmp_1947_fu_32280_p2 = (!p_shl643_cast_fu_32265_p1.read().is_01() || !p_shl644_cast_fu_32276_p1.read().is_01())? sc_lv<19>(): (sc_biguint<19>(p_shl643_cast_fu_32265_p1.read()) - sc_biguint<19>(p_shl644_cast_fu_32276_p1.read()));
}
void ShuffleNetV2::thread_tmp_1948_fu_32290_p2() {
tmp_1948_fu_32290_p2 = (!tmp_997_cast1_reg_42815.read().is_01() || !tmp_2249_cast_fu_32286_p1.read().is_01())? sc_lv<20>(): (sc_biguint<20>(tmp_997_cast1_reg_42815.read()) + sc_bigint<20>(tmp_2249_cast_fu_32286_p1.read()));
}
void ShuffleNetV2::thread_tmp_1949_fu_32227_p3() {
tmp_1949_fu_32227_p3 = esl_concat<5,7>(tmp_1015_fu_32217_p4.read(), ap_const_lv7_0);
}
void ShuffleNetV2::thread_tmp_1950_fu_32235_p3() {
tmp_1950_fu_32235_p3 = esl_concat<5,5>(tmp_1015_fu_32217_p4.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1951_fu_32247_p2() {
tmp_1951_fu_32247_p2 = (!tmp_1949_fu_32227_p3.read().is_01() || !p_shl642_cast_fu_32243_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1949_fu_32227_p3.read()) - sc_bigint<12>(p_shl642_cast_fu_32243_p1.read()));
}
void ShuffleNetV2::thread_tmp_1952_fu_32253_p2() {
tmp_1952_fu_32253_p2 = (!tmp_996_cast_reg_42810.read().is_01() || !tmp_1951_fu_32247_p2.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_996_cast_reg_42810.read()) + sc_biguint<12>(tmp_1951_fu_32247_p2.read()));
}
void ShuffleNetV2::thread_tmp_1953_fu_32576_p3() {
tmp_1953_fu_32576_p3 = esl_concat<7,3>(co176_reg_8117.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1954_fu_32588_p3() {
tmp_1954_fu_32588_p3 = esl_concat<7,1>(co176_reg_8117.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1955_fu_32600_p2() {
tmp_1955_fu_32600_p2 = (!p_shl651_cast_fu_32584_p1.read().is_01() || !p_shl652_cast_fu_32596_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl651_cast_fu_32584_p1.read()) - sc_biguint<11>(p_shl652_cast_fu_32596_p1.read()));
}
void ShuffleNetV2::thread_tmp_1956_fu_32616_p3() {
tmp_1956_fu_32616_p3 = esl_concat<8,3>(tmp_1016_fu_32610_p2.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1957_fu_32628_p3() {
tmp_1957_fu_32628_p3 = esl_concat<8,1>(tmp_1016_fu_32610_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1958_fu_32640_p2() {
tmp_1958_fu_32640_p2 = (!p_shl649_cast_fu_32624_p1.read().is_01() || !p_shl650_cast_fu_32636_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(p_shl649_cast_fu_32624_p1.read()) - sc_biguint<12>(p_shl650_cast_fu_32636_p1.read()));
}
void ShuffleNetV2::thread_tmp_1959_fu_32499_p2() {
tmp_1959_fu_32499_p2 = (!tmp_2241_cast_reg_42939.read().is_01() || !tmp_1017_cast_fu_32495_p1.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_2241_cast_reg_42939.read()) + sc_biguint<12>(tmp_1017_cast_fu_32495_p1.read()));
}
void ShuffleNetV2::thread_tmp_1960_cast_fu_25970_p1() {
tmp_1960_cast_fu_25970_p1 = esl_zext<64,15>(tmp_1697_fu_25965_p2.read());
}
void ShuffleNetV2::thread_tmp_1960_fu_32504_p1() {
tmp_1960_fu_32504_p1 = tmp_1959_fu_32499_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_1961_cast_fu_26172_p1() {
tmp_1961_cast_fu_26172_p1 = esl_zext<64,15>(tmp_1698_fu_26167_p2.read());
}
void ShuffleNetV2::thread_tmp_1961_fu_32516_p3() {
tmp_1961_fu_32516_p3 = esl_concat<12,1>(tmp_1959_fu_32499_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_1962_cast_fu_26182_p1() {
tmp_1962_cast_fu_26182_p1 = esl_zext<64,14>(tmp_1699_reg_40602.read());
}
void ShuffleNetV2::thread_tmp_1962_fu_32528_p2() {
tmp_1962_fu_32528_p2 = (!p_shl647_cast_fu_32508_p3.read().is_01() || !p_shl648_cast_fu_32524_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl647_cast_fu_32508_p3.read()) - sc_bigint<14>(p_shl648_cast_fu_32524_p1.read()));
}
void ShuffleNetV2::thread_tmp_1963_fu_32787_p1() {
tmp_1963_fu_32787_p1 = co178_reg_8150.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1964_fu_32803_p2() {
tmp_1964_fu_32803_p2 = (!ap_const_lv5_3.is_01())? sc_lv<5>(): co178_reg_8150.read() << (unsigned short)ap_const_lv5_3.to_uint();
}
void ShuffleNetV2::thread_tmp_1965_fu_32670_p2() {
tmp_1965_fu_32670_p2 = (!tmp_1019_cast2_fu_32666_p1.read().is_01() || !tmp_2262_cast_reg_42988.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_1019_cast2_fu_32666_p1.read()) + sc_bigint<13>(tmp_2262_cast_reg_42988.read()));
}
void ShuffleNetV2::thread_tmp_1966_fu_32675_p1() {
tmp_1966_fu_32675_p1 = tmp_1965_fu_32670_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_1967_fu_32695_p2() {
tmp_1967_fu_32695_p2 = (!p_shl655_cast_fu_32679_p3.read().is_01() || !p_shl656_cast_fu_32687_p3.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl655_cast_fu_32679_p3.read()) - sc_biguint<14>(p_shl656_cast_fu_32687_p3.read()));
}
void ShuffleNetV2::thread_tmp_1968_fu_32701_p2() {
tmp_1968_fu_32701_p2 = (!tmp_1019_cast1_fu_32662_p1.read().is_01() || !tmp_2259_cast_reg_42983.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1019_cast1_fu_32662_p1.read()) + sc_bigint<12>(tmp_2259_cast_reg_42983.read()));
}
void ShuffleNetV2::thread_tmp_1969_fu_32706_p1() {
tmp_1969_fu_32706_p1 = tmp_1968_fu_32701_p2.read().range(10-1, 0);
}
void ShuffleNetV2::thread_tmp_1970_fu_32726_p2() {
tmp_1970_fu_32726_p2 = (!p_shl653_cast_fu_32710_p3.read().is_01() || !p_shl654_cast_fu_32718_p3.read().is_01())? sc_lv<13>(): (sc_biguint<13>(p_shl653_cast_fu_32710_p3.read()) - sc_biguint<13>(p_shl654_cast_fu_32718_p3.read()));
}
void ShuffleNetV2::thread_tmp_1971_fu_32550_p2() {
tmp_1971_fu_32550_p2 = (!tmp_1962_reg_42952.read().is_01() || !tmp_1020_cast_fu_32546_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_1962_reg_42952.read()) + sc_biguint<14>(tmp_1020_cast_fu_32546_p1.read()));
}
void ShuffleNetV2::thread_tmp_1972_fu_32752_p2() {
tmp_1972_fu_32752_p2 = (!tmp_1967_reg_43001.read().is_01() || !tmp_1024_cast_fu_32748_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_1967_reg_43001.read()) + sc_biguint<14>(tmp_1024_cast_fu_32748_p1.read()));
}
void ShuffleNetV2::thread_tmp_1973_cast_fu_26471_p1() {
tmp_1973_cast_fu_26471_p1 = esl_sext<18,17>(tmp_1707_fu_26465_p2.read());
}
void ShuffleNetV2::thread_tmp_1973_fu_32762_p2() {
tmp_1973_fu_32762_p2 = (!tmp_1970_reg_43006.read().is_01() || !tmp_1024_cast1_fu_32744_p1.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_1970_reg_43006.read()) + sc_biguint<13>(tmp_1024_cast1_fu_32744_p1.read()));
}
void ShuffleNetV2::thread_tmp_1974_cast_fu_26480_p1() {
tmp_1974_cast_fu_26480_p1 = esl_sext<33,18>(tmp_1708_fu_26475_p2.read());
}
void ShuffleNetV2::thread_tmp_1974_fu_33097_p1() {
tmp_1974_fu_33097_p1 = k84_reg_8194.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1975_fu_32874_p1() {
tmp_1975_fu_32874_p1 = i182_reg_8172.read().range(4-1, 0);
}
void ShuffleNetV2::thread_tmp_1976_fu_32894_p2() {
tmp_1976_fu_32894_p2 = (!ap_const_lv5_1.is_01())? sc_lv<5>(): i182_reg_8172.read() << (unsigned short)ap_const_lv5_1.to_uint();
}
void ShuffleNetV2::thread_tmp_1977_fu_32910_p1() {
tmp_1977_fu_32910_p1 = tmp_1030_fu_32904_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_1978_fu_32998_p3() {
tmp_1978_fu_32998_p3 = esl_concat<13,5>(tmp_1034_reg_43083.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1979_fu_33009_p3() {
tmp_1979_fu_33009_p3 = esl_concat<13,3>(tmp_1034_reg_43083.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_1980_cast_fu_26499_p1() {
tmp_1980_cast_fu_26499_p1 = esl_sext<64,10>(tmp_1712_reg_40671.read());
}
void ShuffleNetV2::thread_tmp_1980_fu_33020_p2() {
tmp_1980_fu_33020_p2 = (!p_shl659_cast_fu_33005_p1.read().is_01() || !p_shl660_cast_fu_33016_p1.read().is_01())? sc_lv<19>(): (sc_biguint<19>(p_shl659_cast_fu_33005_p1.read()) - sc_biguint<19>(p_shl660_cast_fu_33016_p1.read()));
}
void ShuffleNetV2::thread_tmp_1981_fu_33030_p2() {
tmp_1981_fu_33030_p2 = (!tmp_1023_cast_reg_43070.read().is_01() || !tmp_2287_cast_fu_33026_p1.read().is_01())? sc_lv<20>(): (sc_biguint<20>(tmp_1023_cast_reg_43070.read()) + sc_bigint<20>(tmp_2287_cast_fu_33026_p1.read()));
}
void ShuffleNetV2::thread_tmp_1982_fu_32967_p3() {
tmp_1982_fu_32967_p3 = esl_concat<5,7>(tmp_1035_fu_32957_p4.read(), ap_const_lv7_0);
}
void ShuffleNetV2::thread_tmp_1983_fu_32975_p3() {
tmp_1983_fu_32975_p3 = esl_concat<5,5>(tmp_1035_fu_32957_p4.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_1984_fu_32987_p2() {
tmp_1984_fu_32987_p2 = (!tmp_1982_fu_32967_p3.read().is_01() || !p_shl658_cast_fu_32983_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_1982_fu_32967_p3.read()) - sc_bigint<12>(p_shl658_cast_fu_32983_p1.read()));
}
void ShuffleNetV2::thread_tmp_1985_fu_32993_p2() {
tmp_1985_fu_32993_p2 = (!tmp_1022_cast_reg_43065.read().is_01() || !tmp_1984_fu_32987_p2.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_1022_cast_reg_43065.read()) + sc_biguint<12>(tmp_1984_fu_32987_p2.read()));
}
void ShuffleNetV2::thread_tmp_1986_fu_33562_p1() {
tmp_1986_fu_33562_p1 = co182_reg_8271.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1987_fu_33578_p2() {
tmp_1987_fu_33578_p2 = (!ap_const_lv5_3.is_01())? sc_lv<5>(): co182_reg_8271.read() << (unsigned short)ap_const_lv5_3.to_uint();
}
void ShuffleNetV2::thread_tmp_1988_fu_33466_p1() {
tmp_1988_fu_33466_p1 = k86_reg_8260.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1989_cast_fu_26780_p1() {
tmp_1989_cast_fu_26780_p1 = esl_sext<36,35>(tmp_1718_fu_26774_p2.read());
}
void ShuffleNetV2::thread_tmp_1989_fu_33249_p1() {
tmp_1989_fu_33249_p1 = i187_reg_8238.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_1990_fu_33310_p3() {
tmp_1990_fu_33310_p3 = esl_concat<8,2>(tmp_1053_reg_43248.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1991_fu_33317_p1() {
tmp_1991_fu_33317_p1 = esl_sext<34,10>(tmp_1990_fu_33310_p3.read());
}
void ShuffleNetV2::thread_tmp_1992_fu_33325_p2() {
tmp_1992_fu_33325_p2 = (!p_shl664_cast_fu_33321_p1.read().is_01() || !tmp_1054_cast_fu_33306_p1.read().is_01())? sc_lv<35>(): (sc_biguint<35>(p_shl664_cast_fu_33321_p1.read()) - sc_biguint<35>(tmp_1054_cast_fu_33306_p1.read()));
}
void ShuffleNetV2::thread_tmp_1993_cast_fu_26875_p1() {
tmp_1993_cast_fu_26875_p1 = esl_zext<64,10>(tmp_1723_reg_40854.read());
}
void ShuffleNetV2::thread_tmp_1993_fu_33335_p2() {
tmp_1993_fu_33335_p2 = (!tmp_2303_cast_fu_33331_p1.read().is_01() || !tmp_1036_cast_reg_43217.read().is_01())? sc_lv<36>(): (sc_bigint<36>(tmp_2303_cast_fu_33331_p1.read()) + sc_biguint<36>(tmp_1036_cast_reg_43217.read()));
}
void ShuffleNetV2::thread_tmp_1994_fu_33340_p1() {
tmp_1994_fu_33340_p1 = tmp_1993_fu_33335_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_1995_fu_33344_p1() {
tmp_1995_fu_33344_p1 = tmp_1993_fu_33335_p2.read().range(9-1, 0);
}
void ShuffleNetV2::thread_tmp_1996_cast_fu_26839_p1() {
tmp_1996_cast_fu_26839_p1 = esl_sext<64,13>(tmp_1726_reg_40848.read());
}
void ShuffleNetV2::thread_tmp_1996_fu_33384_p2() {
tmp_1996_fu_33384_p2 = (!p_shl663_cast_fu_33377_p3.read().is_01() || !tmp_1994_reg_43260.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl663_cast_fu_33377_p3.read()) - sc_biguint<11>(tmp_1994_reg_43260.read()));
}
void ShuffleNetV2::thread_tmp_1997_fu_33389_p2() {
tmp_1997_fu_33389_p2 = (!tmp_1996_fu_33384_p2.read().is_01() || !tmp_1048_cast1_reg_43235.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_1996_fu_33384_p2.read()) + sc_biguint<11>(tmp_1048_cast1_reg_43235.read()));
}
void ShuffleNetV2::thread_tmp_1998_fu_33351_p3() {
tmp_1998_fu_33351_p3 = esl_concat<11,2>(tmp_1055_reg_43254.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_1999_fu_33362_p2() {
tmp_1999_fu_33362_p2 = (!p_shl662_cast_fu_33358_p1.read().is_01() || !tmp_1056_cast1_fu_33348_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl662_cast_fu_33358_p1.read()) - sc_biguint<14>(tmp_1056_cast1_fu_33348_p1.read()));
}
void ShuffleNetV2::thread_tmp_2000_fu_33372_p2() {
tmp_2000_fu_33372_p2 = (!tmp_2309_cast_fu_33368_p1.read().is_01() || !tmp_1036_cast1_reg_43212.read().is_01())? sc_lv<15>(): (sc_bigint<15>(tmp_2309_cast_fu_33368_p1.read()) + sc_biguint<15>(tmp_1036_cast1_reg_43212.read()));
}
void ShuffleNetV2::thread_tmp_2001_fu_33397_p3() {
tmp_2001_fu_33397_p3 = esl_concat<15,2>(tmp_2000_reg_43270.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_2002_fu_33408_p2() {
tmp_2002_fu_33408_p2 = (!p_shl276_fu_33404_p1.read().is_01() || !tmp_2310_cast_fu_33394_p1.read().is_01())? sc_lv<64>(): (sc_bigint<64>(p_shl276_fu_33404_p1.read()) - sc_bigint<64>(tmp_2310_cast_fu_33394_p1.read()));
}
void ShuffleNetV2::thread_tmp_2003_fu_33414_p2() {
tmp_2003_fu_33414_p2 = (!tmp_2002_fu_33408_p2.read().is_01() || !tmp_1048_reg_43230.read().is_01())? sc_lv<64>(): (sc_biguint<64>(tmp_2002_fu_33408_p2.read()) + sc_biguint<64>(tmp_1048_reg_43230.read()));
}
void ShuffleNetV2::thread_tmp_2004_fu_33964_p3() {
tmp_2004_fu_33964_p3 = esl_concat<7,3>(co184_reg_8326.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_2005_fu_33976_p3() {
tmp_2005_fu_33976_p3 = esl_concat<7,1>(co184_reg_8326.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_2006_fu_33988_p2() {
tmp_2006_fu_33988_p2 = (!p_shl669_cast_fu_33972_p1.read().is_01() || !p_shl670_cast_fu_33984_p1.read().is_01())? sc_lv<11>(): (sc_biguint<11>(p_shl669_cast_fu_33972_p1.read()) - sc_biguint<11>(p_shl670_cast_fu_33984_p1.read()));
}
void ShuffleNetV2::thread_tmp_2007_fu_33872_p1() {
tmp_2007_fu_33872_p1 = k88_reg_8315.read().range(2-1, 0);
}
void ShuffleNetV2::thread_tmp_2008_fu_33649_p1() {
tmp_2008_fu_33649_p1 = i189_reg_8293.read().range(4-1, 0);
}
void ShuffleNetV2::thread_tmp_2009_fu_33669_p2() {
tmp_2009_fu_33669_p2 = (!ap_const_lv5_1.is_01())? sc_lv<5>(): i189_reg_8293.read() << (unsigned short)ap_const_lv5_1.to_uint();
}
void ShuffleNetV2::thread_tmp_2010_fu_33685_p1() {
tmp_2010_fu_33685_p1 = tmp_1062_fu_33679_p2.read().range(3-1, 0);
}
void ShuffleNetV2::thread_tmp_2011_cast_fu_27280_p1() {
tmp_2011_cast_fu_27280_p1 = esl_sext<19,18>(tmp_1738_fu_27274_p2.read());
}
void ShuffleNetV2::thread_tmp_2011_fu_33773_p3() {
tmp_2011_fu_33773_p3 = esl_concat<13,5>(tmp_1067_reg_43383.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_2012_cast_fu_27289_p1() {
tmp_2012_cast_fu_27289_p1 = esl_sext<33,19>(tmp_1739_fu_27284_p2.read());
}
void ShuffleNetV2::thread_tmp_2012_fu_33784_p3() {
tmp_2012_fu_33784_p3 = esl_concat<13,3>(tmp_1067_reg_43383.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_2013_fu_33795_p2() {
tmp_2013_fu_33795_p2 = (!p_shl667_cast_fu_33780_p1.read().is_01() || !p_shl668_cast_fu_33791_p1.read().is_01())? sc_lv<19>(): (sc_biguint<19>(p_shl667_cast_fu_33780_p1.read()) - sc_biguint<19>(p_shl668_cast_fu_33791_p1.read()));
}
void ShuffleNetV2::thread_tmp_2014_fu_33805_p2() {
tmp_2014_fu_33805_p2 = (!tmp_1051_cast1_reg_43370.read().is_01() || !tmp_2324_cast_fu_33801_p1.read().is_01())? sc_lv<20>(): (sc_biguint<20>(tmp_1051_cast1_reg_43370.read()) + sc_bigint<20>(tmp_2324_cast_fu_33801_p1.read()));
}
void ShuffleNetV2::thread_tmp_2015_fu_33742_p3() {
tmp_2015_fu_33742_p3 = esl_concat<5,7>(tmp_1069_fu_33732_p4.read(), ap_const_lv7_0);
}
void ShuffleNetV2::thread_tmp_2016_fu_33750_p3() {
tmp_2016_fu_33750_p3 = esl_concat<5,5>(tmp_1069_fu_33732_p4.read(), ap_const_lv5_0);
}
void ShuffleNetV2::thread_tmp_2017_fu_33762_p2() {
tmp_2017_fu_33762_p2 = (!tmp_2015_fu_33742_p3.read().is_01() || !p_shl666_cast_fu_33758_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(tmp_2015_fu_33742_p3.read()) - sc_bigint<12>(p_shl666_cast_fu_33758_p1.read()));
}
void ShuffleNetV2::thread_tmp_2018_cast_fu_27308_p1() {
tmp_2018_cast_fu_27308_p1 = esl_sext<64,10>(tmp_1743_reg_40971.read());
}
void ShuffleNetV2::thread_tmp_2018_fu_33768_p2() {
tmp_2018_fu_33768_p2 = (!tmp_1050_cast_reg_43365.read().is_01() || !tmp_2017_fu_33762_p2.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_1050_cast_reg_43365.read()) + sc_biguint<12>(tmp_2017_fu_33762_p2.read()));
}
void ShuffleNetV2::thread_tmp_2019_fu_34087_p3() {
tmp_2019_fu_34087_p3 = esl_concat<8,2>(ci82_reg_8359.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_2020_fu_34099_p3() {
tmp_2020_fu_34099_p3 = esl_concat<8,3>(ci82_reg_8359.read(), ap_const_lv3_0);
}
void ShuffleNetV2::thread_tmp_2021_fu_34111_p3() {
tmp_2021_fu_34111_p3 = esl_concat<8,1>(ci82_reg_8359.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_2022_fu_34123_p2() {
tmp_2022_fu_34123_p2 = (!p_shl673_cast_fu_34107_p1.read().is_01() || !p_shl674_cast_fu_34119_p1.read().is_01())? sc_lv<12>(): (sc_biguint<12>(p_shl673_cast_fu_34107_p1.read()) - sc_biguint<12>(p_shl674_cast_fu_34119_p1.read()));
}
void ShuffleNetV2::thread_tmp_2023_fu_34014_p2() {
tmp_2023_fu_34014_p2 = (!tmp_2316_cast_reg_43494.read().is_01() || !tmp_1070_cast_fu_34010_p1.read().is_01())? sc_lv<12>(): (sc_bigint<12>(tmp_2316_cast_reg_43494.read()) + sc_biguint<12>(tmp_1070_cast_fu_34010_p1.read()));
}
void ShuffleNetV2::thread_tmp_2024_fu_34019_p1() {
tmp_2024_fu_34019_p1 = tmp_2023_fu_34014_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_2025_cast_fu_27549_p1() {
tmp_2025_cast_fu_27549_p1 = esl_zext<64,15>(tmp_1750_fu_27544_p2.read());
}
void ShuffleNetV2::thread_tmp_2025_fu_34031_p3() {
tmp_2025_fu_34031_p3 = esl_concat<12,1>(tmp_2023_fu_34014_p2.read(), ap_const_lv1_0);
}
void ShuffleNetV2::thread_tmp_2026_fu_34043_p2() {
tmp_2026_fu_34043_p2 = (!p_shl671_cast_fu_34023_p3.read().is_01() || !p_shl672_cast_fu_34039_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl671_cast_fu_34023_p3.read()) - sc_bigint<14>(p_shl672_cast_fu_34039_p1.read()));
}
void ShuffleNetV2::thread_tmp_2027_fu_34149_p2() {
tmp_2027_fu_34149_p2 = (!tmp_1071_cast_fu_34145_p1.read().is_01() || !tmp_2333_cast_reg_43538.read().is_01())? sc_lv<11>(): (sc_biguint<11>(tmp_1071_cast_fu_34145_p1.read()) + sc_biguint<11>(tmp_2333_cast_reg_43538.read()));
}
void ShuffleNetV2::thread_tmp_2028_fu_34166_p2() {
tmp_2028_fu_34166_p2 = (!tmp_1072_cast_fu_34162_p1.read().is_01() || !tmp_2336_cast_reg_43543.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_1072_cast_fu_34162_p1.read()) + sc_bigint<13>(tmp_2336_cast_reg_43543.read()));
}
void ShuffleNetV2::thread_tmp_2029_fu_34171_p1() {
tmp_2029_fu_34171_p1 = tmp_2028_fu_34166_p2.read().range(11-1, 0);
}
void ShuffleNetV2::thread_tmp_2030_fu_34191_p2() {
tmp_2030_fu_34191_p2 = (!p_shl675_cast_fu_34175_p3.read().is_01() || !p_shl676_cast_fu_34183_p3.read().is_01())? sc_lv<14>(): (sc_biguint<14>(p_shl675_cast_fu_34175_p3.read()) - sc_biguint<14>(p_shl676_cast_fu_34183_p3.read()));
}
void ShuffleNetV2::thread_tmp_2031_fu_34065_p2() {
tmp_2031_fu_34065_p2 = (!tmp_2026_reg_43507.read().is_01() || !tmp_1073_cast1_fu_34061_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_2026_reg_43507.read()) + sc_biguint<14>(tmp_1073_cast1_fu_34061_p1.read()));
}
void ShuffleNetV2::thread_tmp_2032_fu_34213_p2() {
tmp_2032_fu_34213_p2 = (!tmp_2343_cast_reg_43556.read().is_01() || !tmp_1074_cast1_fu_34209_p1.read().is_01())? sc_lv<13>(): (sc_biguint<13>(tmp_2343_cast_reg_43556.read()) + sc_biguint<13>(tmp_1074_cast1_fu_34209_p1.read()));
}
void ShuffleNetV2::thread_tmp_2033_cast_fu_27809_p1() {
tmp_2033_cast_fu_27809_p1 = esl_sext<19,18>(tmp_1757_fu_27803_p2.read());
}
void ShuffleNetV2::thread_tmp_2033_fu_34222_p2() {
tmp_2033_fu_34222_p2 = (!tmp_2030_reg_43561.read().is_01() || !tmp_1075_cast_fu_34218_p1.read().is_01())? sc_lv<14>(): (sc_biguint<14>(tmp_2030_reg_43561.read()) + sc_biguint<14>(tmp_1075_cast_fu_34218_p1.read()));
}
void ShuffleNetV2::thread_tmp_2034_cast_fu_27818_p1() {
tmp_2034_cast_fu_27818_p1 = esl_sext<33,19>(tmp_1758_fu_27813_p2.read());
}
void ShuffleNetV2::thread_tmp_2040_cast_fu_27837_p1() {
tmp_2040_cast_fu_27837_p1 = esl_sext<64,12>(tmp_1762_reg_41172.read());
}
void ShuffleNetV2::thread_tmp_2049_cast_fu_28118_p1() {
tmp_2049_cast_fu_28118_p1 = esl_sext<36,35>(tmp_1769_fu_28112_p2.read());
}
void ShuffleNetV2::thread_tmp_2053_cast_fu_28213_p1() {
tmp_2053_cast_fu_28213_p1 = esl_zext<64,11>(tmp_1774_reg_41355.read());
}
void ShuffleNetV2::thread_tmp_2056_cast_fu_28177_p1() {
tmp_2056_cast_fu_28177_p1 = esl_sext<64,13>(tmp_1777_reg_41349.read());
}
void ShuffleNetV2::thread_tmp_2067_cast_fu_28588_p1() {
tmp_2067_cast_fu_28588_p1 = esl_sext<19,18>(tmp_1787_fu_28582_p2.read());
}
void ShuffleNetV2::thread_tmp_2068_cast_fu_28597_p1() {
tmp_2068_cast_fu_28597_p1 = esl_sext<33,19>(tmp_1788_fu_28592_p2.read());
}
void ShuffleNetV2::thread_tmp_2074_cast_fu_28616_p1() {
tmp_2074_cast_fu_28616_p1 = esl_sext<64,12>(tmp_1792_reg_41472.read());
}
void ShuffleNetV2::thread_tmp_2083_cast_fu_28901_p1() {
tmp_2083_cast_fu_28901_p1 = esl_sext<36,35>(tmp_1799_fu_28895_p2.read());
}
void ShuffleNetV2::thread_tmp_2087_cast_fu_28996_p1() {
tmp_2087_cast_fu_28996_p1 = esl_zext<64,11>(tmp_1804_reg_41655.read());
}
void ShuffleNetV2::thread_tmp_2090_cast_fu_28960_p1() {
tmp_2090_cast_fu_28960_p1 = esl_sext<64,13>(tmp_1807_reg_41649.read());
}
void ShuffleNetV2::thread_tmp_2096_cast_fu_29564_p1() {
tmp_2096_cast_fu_29564_p1 = esl_sext<12,11>(tmp_1813_fu_29558_p2.read());
}
void ShuffleNetV2::thread_tmp_2099_cast_fu_29604_p1() {
tmp_2099_cast_fu_29604_p1 = esl_sext<13,12>(tmp_1816_fu_29598_p2.read());
}
void ShuffleNetV2::thread_tmp_2107_cast_fu_29367_p1() {
tmp_2107_cast_fu_29367_p1 = esl_sext<19,18>(tmp_1823_fu_29361_p2.read());
}
void ShuffleNetV2::thread_tmp_2108_cast_fu_29376_p1() {
tmp_2108_cast_fu_29376_p1 = esl_sext<33,19>(tmp_1824_fu_29371_p2.read());
}
void ShuffleNetV2::thread_tmp_2114_cast_fu_29395_p1() {
tmp_2114_cast_fu_29395_p1 = esl_sext<64,12>(tmp_1828_reg_41772.read());
}
void ShuffleNetV2::thread_tmp_2125_cast_fu_29715_p1() {
tmp_2125_cast_fu_29715_p1 = esl_zext<64,14>(tmp_1837_fu_29710_p2.read());
}
void ShuffleNetV2::thread_tmp_2126_cast_fu_29725_p1() {
tmp_2126_cast_fu_29725_p1 = esl_zext<64,13>(tmp_1838_reg_41914.read());
}
void ShuffleNetV2::thread_tmp_2134_cast_fu_29984_p1() {
tmp_2134_cast_fu_29984_p1 = esl_sext<19,18>(tmp_1845_fu_29978_p2.read());
}
void ShuffleNetV2::thread_tmp_2135_cast_fu_29993_p1() {
tmp_2135_cast_fu_29993_p1 = esl_sext<33,19>(tmp_1846_fu_29988_p2.read());
}
void ShuffleNetV2::thread_tmp_2141_cast_fu_30012_p1() {
tmp_2141_cast_fu_30012_p1 = esl_sext<64,12>(tmp_1850_reg_41983.read());
}
void ShuffleNetV2::thread_tmp_2150_cast_fu_30289_p1() {
tmp_2150_cast_fu_30289_p1 = esl_sext<36,35>(tmp_1857_fu_30283_p2.read());
}
void ShuffleNetV2::thread_tmp_2154_cast_fu_30384_p1() {
tmp_2154_cast_fu_30384_p1 = esl_zext<64,11>(tmp_1862_reg_42166.read());
}
void ShuffleNetV2::thread_tmp_2157_cast_fu_30348_p1() {
tmp_2157_cast_fu_30348_p1 = esl_sext<64,13>(tmp_1865_reg_42160.read());
}
void ShuffleNetV2::thread_tmp_2163_cast_fu_30956_p1() {
tmp_2163_cast_fu_30956_p1 = esl_sext<12,11>(tmp_1871_fu_30950_p2.read());
}
void ShuffleNetV2::thread_tmp_2173_cast_fu_30763_p1() {
tmp_2173_cast_fu_30763_p1 = esl_sext<19,18>(tmp_1880_fu_30757_p2.read());
}
void ShuffleNetV2::thread_tmp_2174_cast_fu_30772_p1() {
tmp_2174_cast_fu_30772_p1 = esl_sext<33,19>(tmp_1881_fu_30767_p2.read());
}
void ShuffleNetV2::thread_tmp_2180_cast_fu_30791_p1() {
tmp_2180_cast_fu_30791_p1 = esl_sext<64,12>(tmp_1885_reg_42283.read());
}
void ShuffleNetV2::thread_tmp_2183_cast_fu_31083_p1() {
tmp_2183_cast_fu_31083_p1 = esl_sext<12,11>(tmp_1888_fu_31077_p2.read());
}
void ShuffleNetV2::thread_tmp_2186_cast_fu_31123_p1() {
tmp_2186_cast_fu_31123_p1 = esl_sext<13,12>(tmp_1891_fu_31117_p2.read());
}
void ShuffleNetV2::thread_tmp_2201_cast_fu_31032_p1() {
tmp_2201_cast_fu_31032_p1 = esl_zext<64,14>(tmp_1904_fu_31027_p2.read());
}
void ShuffleNetV2::thread_tmp_2202_cast_fu_31244_p1() {
tmp_2202_cast_fu_31244_p1 = esl_zext<64,13>(tmp_1905_reg_42464.read());
}
void ShuffleNetV2::thread_tmp_2203_cast_fu_31239_p1() {
tmp_2203_cast_fu_31239_p1 = esl_zext<64,14>(tmp_1906_fu_31234_p2.read());
}
void ShuffleNetV2::thread_tmp_2211_cast_fu_31503_p1() {
tmp_2211_cast_fu_31503_p1 = esl_sext<20,19>(tmp_1913_fu_31497_p2.read());
}
void ShuffleNetV2::thread_tmp_2212_cast_fu_31512_p1() {
tmp_2212_cast_fu_31512_p1 = esl_sext<33,20>(tmp_1914_fu_31507_p2.read());
}
void ShuffleNetV2::thread_tmp_2218_cast_fu_31531_p1() {
tmp_2218_cast_fu_31531_p1 = esl_sext<64,12>(tmp_1918_reg_42538.read());
}
void ShuffleNetV2::thread_tmp_2227_cast_fu_31808_p1() {
tmp_2227_cast_fu_31808_p1 = esl_sext<36,35>(tmp_1925_fu_31802_p2.read());
}
void ShuffleNetV2::thread_tmp_2231_cast_fu_31915_p1() {
tmp_2231_cast_fu_31915_p1 = esl_zext<64,11>(tmp_1930_reg_42721.read());
}
void ShuffleNetV2::thread_tmp_2234_cast_fu_31853_p1() {
tmp_2234_cast_fu_31853_p1 = esl_sext<14,13>(tmp_1933_fu_31847_p2.read());
}
void ShuffleNetV2::thread_tmp_2235_cast_fu_31879_p1() {
tmp_2235_cast_fu_31879_p1 = esl_sext<64,14>(tmp_1934_reg_42715.read());
}
void ShuffleNetV2::thread_tmp_2241_cast_fu_32479_p1() {
tmp_2241_cast_fu_32479_p1 = esl_sext<12,11>(tmp_1940_fu_32473_p2.read());
}
void ShuffleNetV2::thread_tmp_2249_cast_fu_32286_p1() {
tmp_2249_cast_fu_32286_p1 = esl_sext<20,19>(tmp_1947_fu_32280_p2.read());
}
void ShuffleNetV2::thread_tmp_2250_cast_fu_32295_p1() {
tmp_2250_cast_fu_32295_p1 = esl_sext<33,20>(tmp_1948_fu_32290_p2.read());
}
void ShuffleNetV2::thread_tmp_2256_cast_fu_32314_p1() {
tmp_2256_cast_fu_32314_p1 = esl_sext<64,12>(tmp_1952_reg_42838.read());
}
void ShuffleNetV2::thread_tmp_2259_cast_fu_32606_p1() {
tmp_2259_cast_fu_32606_p1 = esl_sext<12,11>(tmp_1955_fu_32600_p2.read());
}
void ShuffleNetV2::thread_tmp_2262_cast_fu_32646_p1() {
tmp_2262_cast_fu_32646_p1 = esl_sext<13,12>(tmp_1958_fu_32640_p2.read());
}
void ShuffleNetV2::thread_tmp_2277_cast_fu_32555_p1() {
tmp_2277_cast_fu_32555_p1 = esl_zext<64,14>(tmp_1971_fu_32550_p2.read());
}
void ShuffleNetV2::thread_tmp_2278_cast_fu_32757_p1() {
tmp_2278_cast_fu_32757_p1 = esl_zext<64,14>(tmp_1972_fu_32752_p2.read());
}
void ShuffleNetV2::thread_tmp_2279_cast_fu_32767_p1() {
tmp_2279_cast_fu_32767_p1 = esl_zext<64,13>(tmp_1973_reg_43024.read());
}
void ShuffleNetV2::thread_tmp_2287_cast_fu_33026_p1() {
tmp_2287_cast_fu_33026_p1 = esl_sext<20,19>(tmp_1980_fu_33020_p2.read());
}
void ShuffleNetV2::thread_tmp_2288_cast_fu_33035_p1() {
tmp_2288_cast_fu_33035_p1 = esl_sext<33,20>(tmp_1981_fu_33030_p2.read());
}
void ShuffleNetV2::thread_tmp_2294_cast_fu_33054_p1() {
tmp_2294_cast_fu_33054_p1 = esl_sext<64,12>(tmp_1985_reg_43093.read());
}
void ShuffleNetV2::thread_tmp_2303_cast_fu_33331_p1() {
tmp_2303_cast_fu_33331_p1 = esl_sext<36,35>(tmp_1992_fu_33325_p2.read());
}
void ShuffleNetV2::thread_tmp_2307_cast_fu_33430_p1() {
tmp_2307_cast_fu_33430_p1 = esl_zext<64,11>(tmp_1997_reg_43276.read());
}
void ShuffleNetV2::thread_tmp_2309_cast_fu_33368_p1() {
tmp_2309_cast_fu_33368_p1 = esl_sext<15,14>(tmp_1999_fu_33362_p2.read());
}
void ShuffleNetV2::thread_tmp_2310_cast_fu_33394_p1() {
tmp_2310_cast_fu_33394_p1 = esl_sext<64,15>(tmp_2000_reg_43270.read());
}
void ShuffleNetV2::thread_tmp_2316_cast_fu_33994_p1() {
tmp_2316_cast_fu_33994_p1 = esl_sext<12,11>(tmp_2006_fu_33988_p2.read());
}
void ShuffleNetV2::thread_tmp_2324_cast_fu_33801_p1() {
tmp_2324_cast_fu_33801_p1 = esl_sext<20,19>(tmp_2013_fu_33795_p2.read());
}
void ShuffleNetV2::thread_tmp_2325_cast_fu_33810_p1() {
tmp_2325_cast_fu_33810_p1 = esl_sext<33,20>(tmp_2014_fu_33805_p2.read());
}
void ShuffleNetV2::thread_tmp_2331_cast_fu_33829_p1() {
tmp_2331_cast_fu_33829_p1 = esl_sext<64,12>(tmp_2018_reg_43393.read());
}
void ShuffleNetV2::thread_tmp_2333_cast_fu_34095_p1() {
tmp_2333_cast_fu_34095_p1 = esl_zext<11,10>(tmp_2019_fu_34087_p3.read());
}
void ShuffleNetV2::thread_tmp_2336_cast_fu_34129_p1() {
tmp_2336_cast_fu_34129_p1 = esl_sext<13,12>(tmp_2022_fu_34123_p2.read());
}
void ShuffleNetV2::thread_tmp_2343_cast_fu_34154_p3() {
tmp_2343_cast_fu_34154_p3 = esl_concat<11,2>(tmp_2027_fu_34149_p2.read(), ap_const_lv2_0);
}
void ShuffleNetV2::thread_tmp_2348_cast_fu_34070_p1() {
tmp_2348_cast_fu_34070_p1 = esl_zext<64,14>(tmp_2031_fu_34065_p2.read());
}
void ShuffleNetV2::thread_tmp_2349_cast_fu_34232_p1() {
tmp_2349_cast_fu_34232_p1 = esl_zext<64,13>(tmp_2032_reg_43574.read());
}
void ShuffleNetV2::thread_tmp_2350_cast_fu_34227_p1() {
tmp_2350_cast_fu_34227_p1 = esl_zext<64,14>(tmp_2033_fu_34222_p2.read());
}
void ShuffleNetV2::thread_tmp_286_fu_9278_p1() {
tmp_286_fu_9278_p1 = esl_zext<64,4>(i2_reg_4320.read());
}
void ShuffleNetV2::thread_tmp_289_cast_fu_9337_p1() {
tmp_289_cast_fu_9337_p1 = esl_zext<8,6>(w_37_fu_9331_p2.read());
}
void ShuffleNetV2::thread_tmp_290_cast_fu_9346_p1() {
tmp_290_cast_fu_9346_p1 = esl_zext<8,6>(w_reg_4343.read());
}
void ShuffleNetV2::thread_tmp_291_fu_9592_p1() {
tmp_291_fu_9592_p1 = esl_zext<64,5>(i4_reg_4388.read());
}
void ShuffleNetV2::thread_tmp_294_cast_fu_9559_p1() {
tmp_294_cast_fu_9559_p1 = esl_zext<8,5>(ci3_reg_4377.read());
}
void ShuffleNetV2::thread_tmp_295_cast_fu_9414_p1() {
tmp_295_cast_fu_9414_p1 = esl_zext<13,6>(h_32_fu_9408_p2.read());
}
void ShuffleNetV2::thread_tmp_297_cast_fu_9609_p1() {
tmp_297_cast_fu_9609_p1 = esl_zext<8,5>(co5_reg_4400.read());
}
void ShuffleNetV2::thread_tmp_298_fu_9737_p1() {
tmp_298_fu_9737_p1 = esl_zext<64,5>(i8_reg_4433.read());
}
void ShuffleNetV2::thread_tmp_301_cast_fu_9662_p1() {
tmp_301_cast_fu_9662_p1 = esl_zext<9,2>(w6_reg_4411.read());
}
void ShuffleNetV2::thread_tmp_302_fu_9758_p2() {
tmp_302_fu_9758_p2 = (!ap_const_lv6_18.is_01() || !co9_cast_fu_9742_p1.read().is_01())? sc_lv<6>(): (sc_biguint<6>(ap_const_lv6_18) + sc_biguint<6>(co9_cast_fu_9742_p1.read()));
}
void ShuffleNetV2::thread_tmp_303_fu_9716_p1() {
tmp_303_fu_9716_p1 = esl_zext<64,2>(h7_reg_4422.read());
}
void ShuffleNetV2::thread_tmp_304_fu_9917_p1() {
tmp_304_fu_9917_p1 = esl_zext<64,5>(i11_reg_4468.read());
}
void ShuffleNetV2::thread_tmp_307_cast_fu_9884_p1() {
tmp_307_cast_fu_9884_p1 = esl_zext<8,5>(ci10_reg_4457.read());
}
void ShuffleNetV2::thread_tmp_308_cast_fu_9938_p1() {
tmp_308_cast_fu_9938_p1 = esl_zext<8,5>(co12_reg_4480.read());
}
void ShuffleNetV2::thread_tmp_309_fu_9964_p2() {
tmp_309_fu_9964_p2 = (!co12_cast_fu_9922_p1.read().is_01() || !ap_const_lv6_18.is_01())? sc_lv<6>(): (sc_biguint<6>(co12_cast_fu_9922_p1.read()) + sc_biguint<6>(ap_const_lv6_18));
}
void ShuffleNetV2::thread_tmp_310_cast_fu_9970_p1() {
tmp_310_cast_fu_9970_p1 = esl_zext<9,6>(tmp_309_fu_9964_p2.read());
}
void ShuffleNetV2::thread_tmp_311_fu_10129_p1() {
tmp_311_fu_10129_p1 = esl_zext<64,5>(tmp_740_reg_4513.read());
}
void ShuffleNetV2::thread_tmp_314_cast_fu_10004_p1() {
tmp_314_cast_fu_10004_p1 = esl_zext<9,2>(w13_reg_4491.read());
}
void ShuffleNetV2::thread_tmp_315_fu_10150_p2() {
tmp_315_fu_10150_p2 = (!ap_const_lv7_30.is_01() || !co16_cast_fu_10134_p1.read().is_01())? sc_lv<7>(): (sc_biguint<7>(ap_const_lv7_30) + sc_biguint<7>(co16_cast_fu_10134_p1.read()));
}
void ShuffleNetV2::thread_tmp_316_cast_fu_10073_p1() {
tmp_316_cast_fu_10073_p1 = esl_zext<9,2>(h14_reg_4502.read());
}
void ShuffleNetV2::thread_tmp_317_fu_10309_p1() {
tmp_317_fu_10309_p1 = esl_zext<64,5>(i16_reg_4548.read());
}
void ShuffleNetV2::thread_tmp_320_cast_fu_10276_p1() {
tmp_320_cast_fu_10276_p1 = esl_zext<8,5>(ci13_reg_4537.read());
}
void ShuffleNetV2::thread_tmp_321_fu_10360_p2() {
tmp_321_fu_10360_p2 = (!co19_cast_fu_10314_p1.read().is_01() || !ap_const_lv6_18.is_01())? sc_lv<6>(): (sc_biguint<6>(co19_cast_fu_10314_p1.read()) + sc_biguint<6>(ap_const_lv6_18));
}
void ShuffleNetV2::thread_tmp_322_fu_10533_p2() {
tmp_322_fu_10533_p2 = (!ap_const_lv7_48.is_01() || !co22_cast_fu_10517_p1.read().is_01())? sc_lv<7>(): (sc_bigint<7>(ap_const_lv7_48) + sc_biguint<7>(co22_cast_fu_10517_p1.read()));
}
void ShuffleNetV2::thread_tmp_323_cast1_fu_10408_p1() {
tmp_323_cast1_fu_10408_p1 = esl_zext<11,5>(h_35_fu_10402_p2.read());
}
void ShuffleNetV2::thread_tmp_323_cast_fu_10412_p1() {
tmp_323_cast_fu_10412_p1 = esl_zext<10,5>(h_35_fu_10402_p2.read());
}
void ShuffleNetV2::thread_tmp_324_fu_10692_p1() {
tmp_324_fu_10692_p1 = esl_zext<64,5>(i18_reg_4616.read());
}
void ShuffleNetV2::thread_tmp_327_cast_fu_10659_p1() {
tmp_327_cast_fu_10659_p1 = esl_zext<8,5>(ci15_reg_4605.read());
}
void ShuffleNetV2::thread_tmp_328_cast1_fu_10490_p1() {
tmp_328_cast1_fu_10490_p1 = esl_zext<15,5>(w_40_fu_10484_p2.read());
}
void ShuffleNetV2::thread_tmp_328_cast_fu_10494_p1() {
tmp_328_cast_fu_10494_p1 = esl_zext<14,5>(w_40_fu_10484_p2.read());
}
void ShuffleNetV2::thread_tmp_329_cast_fu_10713_p1() {
tmp_329_cast_fu_10713_p1 = esl_zext<8,5>(co25_reg_4628.read());
}
void ShuffleNetV2::thread_tmp_330_fu_10739_p2() {
tmp_330_fu_10739_p2 = (!co25_cast_fu_10697_p1.read().is_01() || !ap_const_lv7_30.is_01())? sc_lv<7>(): (sc_biguint<7>(co25_cast_fu_10697_p1.read()) + sc_biguint<7>(ap_const_lv7_30));
}
void ShuffleNetV2::thread_tmp_331_cast_fu_10745_p1() {
tmp_331_cast_fu_10745_p1 = esl_zext<10,7>(tmp_330_fu_10739_p2.read());
}
void ShuffleNetV2::thread_tmp_332_fu_10892_p1() {
tmp_332_fu_10892_p1 = esl_zext<64,5>(i20_reg_4661.read());
}
void ShuffleNetV2::thread_tmp_335_cast1_fu_10794_p1() {
tmp_335_cast1_fu_10794_p1 = esl_zext<9,2>(w26_reg_4639.read());
}
void ShuffleNetV2::thread_tmp_335_cast_fu_10798_p1() {
tmp_335_cast_fu_10798_p1 = esl_zext<10,2>(w26_reg_4639.read());
}
void ShuffleNetV2::thread_tmp_336_cast_fu_10867_p1() {
tmp_336_cast_fu_10867_p1 = esl_zext<9,2>(h27_reg_4650.read());
}
void ShuffleNetV2::thread_tmp_337_fu_11090_p1() {
tmp_337_fu_11090_p1 = esl_zext<64,5>(tmp_933_reg_4696.read());
}
void ShuffleNetV2::thread_tmp_340_cast_fu_11026_p1() {
tmp_340_cast_fu_11026_p1 = esl_zext<8,5>(ci17_reg_4685.read());
}
void ShuffleNetV2::thread_tmp_341_fu_11260_p2() {
tmp_341_fu_11260_p2 = (!co35_cast_fu_11214_p1.read().is_01() || !ap_const_lv6_18.is_01())? sc_lv<6>(): (sc_biguint<6>(co35_cast_fu_11214_p1.read()) + sc_biguint<6>(ap_const_lv6_18));
}
void ShuffleNetV2::thread_tmp_342_cast_fu_11149_p1() {
tmp_342_cast_fu_11149_p1 = esl_zext<10,5>(h_37_fu_11143_p2.read());
}
void ShuffleNetV2::thread_tmp_343_fu_11433_p2() {
tmp_343_fu_11433_p2 = (!ap_const_lv8_78.is_01() || !co38_cast_fu_11417_p1.read().is_01())? sc_lv<8>(): (sc_biguint<8>(ap_const_lv8_78) + sc_biguint<8>(co38_cast_fu_11417_p1.read()));
}
void ShuffleNetV2::thread_tmp_344_cast1_fu_11308_p1() {
tmp_344_cast1_fu_11308_p1 = esl_zext<11,5>(h_38_fu_11302_p2.read());
}
void ShuffleNetV2::thread_tmp_344_cast_fu_11312_p1() {
tmp_344_cast_fu_11312_p1 = esl_zext<10,5>(h_38_fu_11302_p2.read());
}
void ShuffleNetV2::thread_tmp_345_cast_fu_11200_p1() {
tmp_345_cast_fu_11200_p1 = esl_zext<15,5>(w_42_fu_11194_p2.read());
}
void ShuffleNetV2::thread_tmp_346_fu_11592_p1() {
tmp_346_fu_11592_p1 = esl_zext<64,5>(i23_reg_4797.read());
}
void ShuffleNetV2::thread_tmp_349_cast_fu_11559_p1() {
tmp_349_cast_fu_11559_p1 = esl_zext<8,5>(ci19_reg_4786.read());
}
void ShuffleNetV2::thread_tmp_350_cast1_fu_11390_p1() {
tmp_350_cast1_fu_11390_p1 = esl_zext<15,5>(w_43_fu_11384_p2.read());
}
void ShuffleNetV2::thread_tmp_350_cast_fu_11394_p1() {
tmp_350_cast_fu_11394_p1 = esl_zext<14,5>(w_43_fu_11384_p2.read());
}
void ShuffleNetV2::thread_tmp_351_cast_fu_11613_p1() {
tmp_351_cast_fu_11613_p1 = esl_zext<8,5>(co41_reg_4809.read());
}
void ShuffleNetV2::thread_tmp_352_fu_11639_p2() {
tmp_352_fu_11639_p2 = (!co41_cast_fu_11597_p1.read().is_01() || !ap_const_lv7_48.is_01())? sc_lv<7>(): (sc_biguint<7>(co41_cast_fu_11597_p1.read()) + sc_bigint<7>(ap_const_lv7_48));
}
void ShuffleNetV2::thread_tmp_353_cast_fu_11645_p1() {
tmp_353_cast_fu_11645_p1 = esl_zext<10,7>(tmp_352_fu_11639_p2.read());
}
void ShuffleNetV2::thread_tmp_354_fu_11792_p1() {
tmp_354_fu_11792_p1 = esl_zext<64,5>(i25_reg_4842.read());
}
void ShuffleNetV2::thread_tmp_357_cast1_fu_11694_p1() {
tmp_357_cast1_fu_11694_p1 = esl_zext<9,2>(w42_reg_4820.read());
}
void ShuffleNetV2::thread_tmp_357_cast_fu_11698_p1() {
tmp_357_cast_fu_11698_p1 = esl_zext<10,2>(w42_reg_4820.read());
}
void ShuffleNetV2::thread_tmp_358_fu_11813_p2() {
tmp_358_fu_11813_p2 = (!ap_const_lv8_90.is_01() || !co43_cast_fu_11797_p1.read().is_01())? sc_lv<8>(): (sc_bigint<8>(ap_const_lv8_90) + sc_biguint<8>(co43_cast_fu_11797_p1.read()));
}
void ShuffleNetV2::thread_tmp_359_cast_fu_11767_p1() {
tmp_359_cast_fu_11767_p1 = esl_zext<9,2>(h39_reg_4831.read());
}
void ShuffleNetV2::thread_tmp_360_fu_11972_p1() {
tmp_360_fu_11972_p1 = esl_zext<64,5>(i27_reg_4877.read());
}
void ShuffleNetV2::thread_tmp_363_cast_fu_11939_p1() {
tmp_363_cast_fu_11939_p1 = esl_zext<8,5>(ci21_reg_4866.read());
}
void ShuffleNetV2::thread_tmp_364_fu_12142_p2() {
tmp_364_fu_12142_p2 = (!co46_cast_fu_12096_p1.read().is_01() || !ap_const_lv6_18.is_01())? sc_lv<6>(): (sc_biguint<6>(co46_cast_fu_12096_p1.read()) + sc_biguint<6>(ap_const_lv6_18));
}
void ShuffleNetV2::thread_tmp_365_cast_fu_12031_p1() {
tmp_365_cast_fu_12031_p1 = esl_zext<10,5>(h_42_fu_12025_p2.read());
}
void ShuffleNetV2::thread_tmp_366_fu_12315_p2() {
tmp_366_fu_12315_p2 = (!ap_const_lv8_A8.is_01() || !co48_cast_fu_12299_p1.read().is_01())? sc_lv<8>(): (sc_bigint<8>(ap_const_lv8_A8) + sc_biguint<8>(co48_cast_fu_12299_p1.read()));
}
void ShuffleNetV2::thread_tmp_367_cast1_fu_12190_p1() {
tmp_367_cast1_fu_12190_p1 = esl_zext<10,5>(h_44_fu_12184_p2.read());
}
void ShuffleNetV2::thread_tmp_367_cast_fu_12194_p1() {
tmp_367_cast_fu_12194_p1 = esl_zext<11,5>(h_44_fu_12184_p2.read());
}
void ShuffleNetV2::thread_tmp_368_cast_fu_12082_p1() {
tmp_368_cast_fu_12082_p1 = esl_zext<15,5>(w_46_fu_12076_p2.read());
}
void ShuffleNetV2::thread_tmp_369_fu_12486_p1() {
tmp_369_fu_12486_p1 = esl_zext<64,5>(tmp_1113_reg_4978.read());
}
void ShuffleNetV2::thread_tmp_372_cast_fu_12426_p1() {
tmp_372_cast_fu_12426_p1 = esl_zext<8,5>(ci23_reg_4967.read());
}
void ShuffleNetV2::thread_tmp_373_cast1_fu_12272_p1() {
tmp_373_cast1_fu_12272_p1 = esl_zext<14,5>(w_48_fu_12266_p2.read());
}
void ShuffleNetV2::thread_tmp_373_cast_fu_12276_p1() {
tmp_373_cast_fu_12276_p1 = esl_zext<15,5>(w_48_fu_12266_p2.read());
}
void ShuffleNetV2::thread_tmp_374_cast_fu_12503_p1() {
tmp_374_cast_fu_12503_p1 = esl_zext<8,5>(co51_reg_4990.read());
}
void ShuffleNetV2::thread_tmp_375_fu_12529_p3() {
tmp_375_fu_12529_p3 = esl_concat<1,5>(ap_const_lv1_1, co51_reg_4990.read());
}
void ShuffleNetV2::thread_tmp_376_cast_fu_12541_p1() {
tmp_376_cast_fu_12541_p1 = esl_zext<10,7>(tmp_404_cast_fu_12537_p1.read());
}
void ShuffleNetV2::thread_tmp_377_fu_12698_p1() {
tmp_377_fu_12698_p1 = esl_zext<64,5>(i30_reg_5023.read());
}
void ShuffleNetV2::thread_tmp_380_cast1_fu_12600_p1() {
tmp_380_cast1_fu_12600_p1 = esl_zext<9,2>(w49_reg_5001.read());
}
void ShuffleNetV2::thread_tmp_380_cast_fu_12604_p1() {
tmp_380_cast_fu_12604_p1 = esl_zext<11,2>(w49_reg_5001.read());
}
void ShuffleNetV2::thread_tmp_381_cast_fu_12673_p1() {
tmp_381_cast_fu_12673_p1 = esl_zext<9,2>(h45_reg_5012.read());
}
void ShuffleNetV2::thread_tmp_382_fu_12880_p1() {
tmp_382_fu_12880_p1 = esl_zext<64,5>(i32_reg_5058.read());
}
void ShuffleNetV2::thread_tmp_385_cast_fu_12847_p1() {
tmp_385_cast_fu_12847_p1 = esl_zext<8,5>(ci25_reg_5047.read());
}
void ShuffleNetV2::thread_tmp_386_fu_13048_p2() {
tmp_386_fu_13048_p2 = (!p_shl_cast_fu_13032_p1.read().is_01() || !p_shl1_cast_fu_13044_p1.read().is_01())? sc_lv<7>(): (sc_biguint<7>(p_shl_cast_fu_13032_p1.read()) - sc_biguint<7>(p_shl1_cast_fu_13044_p1.read()));
}
void ShuffleNetV2::thread_tmp_387_cast_fu_12939_p1() {
tmp_387_cast_fu_12939_p1 = esl_zext<10,5>(h_48_fu_12933_p2.read());
}
void ShuffleNetV2::thread_tmp_388_fu_13094_p2() {
tmp_388_fu_13094_p2 = (!tmp_386_reg_35924.read().is_01() || !ci27_cast_fu_13078_p1.read().is_01())? sc_lv<7>(): (sc_biguint<7>(tmp_386_reg_35924.read()) + sc_biguint<7>(ci27_cast_fu_13078_p1.read()));
}
void ShuffleNetV2::thread_tmp_389_cast_fu_13099_p1() {
tmp_389_cast_fu_13099_p1 = esl_sext<10,7>(tmp_388_fu_13094_p2.read());
}
void ShuffleNetV2::thread_tmp_390_cast_fu_13103_p1() {
tmp_390_cast_fu_13103_p1 = esl_zext<16,5>(ci27_reg_5114.read());
}
void ShuffleNetV2::thread_tmp_391_cast_fu_12990_p1() {
tmp_391_cast_fu_12990_p1 = esl_zext<15,5>(w_52_fu_12984_p2.read());
}
void ShuffleNetV2::thread_tmp_392_fu_13380_p2() {
tmp_392_fu_13380_p2 = (!p_shl2_cast_fu_13364_p1.read().is_01() || !p_shl3_cast_fu_13376_p1.read().is_01())? sc_lv<7>(): (sc_biguint<7>(p_shl2_cast_fu_13364_p1.read()) - sc_biguint<7>(p_shl3_cast_fu_13376_p1.read()));
}
void ShuffleNetV2::thread_tmp_393_fu_13390_p2() {
tmp_393_fu_13390_p2 = (!i37_cast1_reg_36031.read().is_01() || !tmp_392_fu_13380_p2.read().is_01())? sc_lv<7>(): (sc_biguint<7>(i37_cast1_reg_36031.read()) + sc_biguint<7>(tmp_392_fu_13380_p2.read()));
}
void ShuffleNetV2::thread_tmp_394_fu_13427_p1() {
tmp_394_fu_13427_p1 = esl_zext<64,32>(tmp_424_cast_fu_13424_p1.read());
}
void ShuffleNetV2::thread_tmp_395_fu_13401_p2() {
tmp_395_fu_13401_p2 = (!tmp2_fu_13395_p2.read().is_01() || !i37_cast_reg_36026.read().is_01())? sc_lv<9>(): (sc_biguint<9>(tmp2_fu_13395_p2.read()) + sc_biguint<9>(i37_cast_reg_36026.read()));
}
void ShuffleNetV2::thread_tmp_396_cast_fu_13406_p1() {
tmp_396_cast_fu_13406_p1 = esl_zext<33,9>(tmp_395_reg_36057.read());
}
void ShuffleNetV2::thread_tmp_397_fu_13147_p2() {
tmp_397_fu_13147_p2 = (!p_shl4_cast_fu_13131_p1.read().is_01() || !p_shl5_cast_fu_13143_p1.read().is_01())? sc_lv<7>(): (sc_biguint<7>(p_shl4_cast_fu_13131_p1.read()) - sc_biguint<7>(p_shl5_cast_fu_13143_p1.read()));
}
void ShuffleNetV2::thread_tmp_398_fu_13157_p2() {
tmp_398_fu_13157_p2 = (!tmp_397_fu_13147_p2.read().is_01() || !tmp_421_cast_reg_35929.read().is_01())? sc_lv<7>(): (sc_biguint<7>(tmp_397_fu_13147_p2.read()) + sc_biguint<7>(tmp_421_cast_reg_35929.read()));
}
void ShuffleNetV2::thread_tmp_399_fu_13186_p2() {
tmp_399_fu_13186_p2 = (!p_shl6_cast_fu_13170_p1.read().is_01() || !p_shl7_cast_fu_13182_p1.read().is_01())? sc_lv<8>(): (sc_biguint<8>(p_shl6_cast_fu_13170_p1.read()) - sc_biguint<8>(p_shl7_cast_fu_13182_p1.read()));
}
void ShuffleNetV2::thread_tmp_400_fu_13202_p2() {
tmp_400_fu_13202_p2 = (!tmp1_fu_13196_p2.read().is_01() || !co56_cast_reg_35911.read().is_01())? sc_lv<9>(): (sc_biguint<9>(tmp1_fu_13196_p2.read()) + sc_biguint<9>(co56_cast_reg_35911.read()));
}
void ShuffleNetV2::thread_tmp_401_fu_13212_p4() {
tmp_401_fu_13212_p4 = tmp_398_fu_13157_p2.read().range(6, 3);
}
}
| [
"jzfengziyan@gmail.com"
] | jzfengziyan@gmail.com |
cae12f57b522fa21a9cec6f959393ba6dbb514f1 | 5ec06dab1409d790496ce082dacb321392b32fe9 | /clients/cpp-restsdk/generated/model/ComAdobeGraniteBundlesHcImplJobsHealthCheckProperties.h | 0dc84fbbd7fe81e9249dc70ee71833011e2085ca | [
"Apache-2.0"
] | permissive | shinesolutions/swagger-aem-osgi | e9d2385f44bee70e5bbdc0d577e99a9f2525266f | c2f6e076971d2592c1cbd3f70695c679e807396b | refs/heads/master | 2022-10-29T13:07:40.422092 | 2021-04-09T07:46:03 | 2021-04-09T07:46:03 | 190,217,155 | 3 | 3 | Apache-2.0 | 2022-10-05T03:26:20 | 2019-06-04T14:23:28 | null | UTF-8 | C++ | false | false | 2,475 | h | /**
* Adobe Experience Manager OSGI config (AEM) API
* Swagger AEM OSGI is an OpenAPI specification for Adobe Experience Manager (AEM) OSGI Configurations API
*
* OpenAPI spec version: 1.0.0-pre.0
* Contact: opensource@shinesolutions.com
*
* NOTE: This class is auto generated by OpenAPI-Generator 3.2.1-SNAPSHOT.
* https://openapi-generator.tech
* Do not edit the class manually.
*/
/*
* ComAdobeGraniteBundlesHcImplJobsHealthCheckProperties.h
*
*
*/
#ifndef ORG_OPENAPITOOLS_CLIENT_MODEL_ComAdobeGraniteBundlesHcImplJobsHealthCheckProperties_H_
#define ORG_OPENAPITOOLS_CLIENT_MODEL_ComAdobeGraniteBundlesHcImplJobsHealthCheckProperties_H_
#include "../ModelBase.h"
#include "ConfigNodePropertyInteger.h"
#include "ConfigNodePropertyArray.h"
namespace org {
namespace openapitools {
namespace client {
namespace model {
/// <summary>
///
/// </summary>
class ComAdobeGraniteBundlesHcImplJobsHealthCheckProperties
: public ModelBase
{
public:
ComAdobeGraniteBundlesHcImplJobsHealthCheckProperties();
virtual ~ComAdobeGraniteBundlesHcImplJobsHealthCheckProperties();
/////////////////////////////////////////////
/// ModelBase overrides
void validate() override;
web::json::value toJson() const override;
void fromJson(web::json::value& json) override;
void toMultipart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& namePrefix) const override;
void fromMultiPart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& namePrefix) override;
/////////////////////////////////////////////
/// ComAdobeGraniteBundlesHcImplJobsHealthCheckProperties members
/// <summary>
///
/// </summary>
std::shared_ptr<ConfigNodePropertyArray> getHcTags() const;
bool hcTagsIsSet() const;
void unsetHc_tags();
void setHcTags(std::shared_ptr<ConfigNodePropertyArray> value);
/// <summary>
///
/// </summary>
std::shared_ptr<ConfigNodePropertyInteger> getMaxQueuedJobs() const;
bool maxQueuedJobsIsSet() const;
void unsetMax_queued_jobs();
void setMaxQueuedJobs(std::shared_ptr<ConfigNodePropertyInteger> value);
protected:
std::shared_ptr<ConfigNodePropertyArray> m_Hc_tags;
bool m_Hc_tagsIsSet;
std::shared_ptr<ConfigNodePropertyInteger> m_Max_queued_jobs;
bool m_Max_queued_jobsIsSet;
};
}
}
}
}
#endif /* ORG_OPENAPITOOLS_CLIENT_MODEL_ComAdobeGraniteBundlesHcImplJobsHealthCheckProperties_H_ */
| [
"cliffano@gmail.com"
] | cliffano@gmail.com |
ee1405116fbe54ab3d50b96922819bc2d70437d7 | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/git/gumtree/git_patch_hunk_2806.cpp | e0a2ae421afb8dd0a9c460ad05b8cfde7e83ee74 | [] | 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 | 778 | cpp | tagged = tag->tagged;
while (tagged->type == OBJ_TAG) {
tagged = ((struct tag *)tagged)->tagged;
}
if (tagged->type == OBJ_TREE) {
warning("Omitting tag %s,\nsince tags of trees (or tags of tags of trees, etc.) are not supported.",
- sha1_to_hex(tag->object.sha1));
+ oid_to_hex(&tag->object.oid));
return;
}
- buf = read_sha1_file(tag->object.sha1, &type, &size);
+ buf = read_sha1_file(tag->object.oid.hash, &type, &size);
if (!buf)
- die ("Could not read tag %s", sha1_to_hex(tag->object.sha1));
+ die ("Could not read tag %s", oid_to_hex(&tag->object.oid));
message = memmem(buf, size, "\n\n", 2);
if (message) {
message += 2;
message_size = strlen(message);
}
tagger = memmem(buf, message ? message - buf : size, "\ntagger ", 8);
| [
"993273596@qq.com"
] | 993273596@qq.com |
3da9840084bca50684f98bf0628db9c7e115efe6 | 7476f475b4a1b40970120b074fdec33f2c988296 | /hoja5/ejercicio5.cpp | 3b6d99c661251b6e670645322ebe9fbe8ee9c9b2 | [] | no_license | MasterBlck/cpp-programs | 0dc46db676d90e6841d9925dc0ac57fcde50c1bb | d64aba5bd678eb2be8944ba028ecff6f74722a9a | refs/heads/main | 2023-05-30T14:14:15.144624 | 2021-06-14T03:28:40 | 2021-06-14T03:28:40 | 376,653,987 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 81 | cpp | #include <stdio.h>
int contarVocales(char *frase);
int main(){
return 0;
}
| [
"198add@gmail.com"
] | 198add@gmail.com |
11b5f3dc81ee0b6de5a4c0a249ae30c6b39016e3 | 2f015500a180f1dab1eaa23978bbd645cf43131e | /src/borwall-ex1-densityBased/testCases/pitzDaily/7/uniform/functionObjects/functionObjectProperties | 5245c6f1a948732ba83a9a00c9f0acc470bcee9b | [] | no_license | krajit/borwall-example1 | 2da6fb0f4df5efec41b6af4360803c09a13ff3e5 | 834ea8d5fa585570fb946fc907aa84ce9fa5145c | refs/heads/master | 2020-08-02T14:51:34.352745 | 2019-10-09T18:04:06 | 2019-10-09T18:04:06 | 211,396,158 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 895 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: v1806 |
| \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class dictionary;
location "7/uniform/functionObjects";
object functionObjectProperties;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// ************************************************************************* //
| [
"ajitkumar22@gmail.com"
] | ajitkumar22@gmail.com | |
d0351637d58903ff21e410f132aeb700c12c4e6b | 1a4aebcb67a731a7676fef6fa7ffc23e9a409b51 | /870/gradTy | 9d77e64289fa9af252df6a84d19413d36d2b1fa6 | [] | no_license | spaul1995/nanopore_voltage | 8bd6768c44e662293b25298d617c494921cd0543 | e5d32a5bf9021c1296c18335d1bd2f51d3a8dd74 | refs/heads/master | 2020-03-30T19:03:45.366817 | 2018-10-04T08:20:33 | 2018-10-04T08:20:33 | 151,525,959 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 87,172 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 5.0 |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "870";
object gradTy;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [0 -1 0 1 0 0 0];
internalField nonuniform List<scalar>
5796
(
-1594167.61478
-2880.69551397
2886.32572622
715.826091557
-713.684652287
74094.0494183
-74377.9004904
-19834856.5726
17563502.037
21608540.4951
5066006.75862
18587527.1743
-3524189.74666
-1658048.1589
-3615.31081833
3614.79623525
3835652.28272
345585.734932
46.5031710579
-46.3565072777
-0.49164424636
0.492441791995
-9318832.73604
26589.3483311
-26810.3711021
-23511.3345807
-2075235.17081
-114544.476255
-57724.8495066
2175.8887746
-295.130879007
295.125011921
-3.32359881039
3.31420581574
-0.0746971346613
0.0748830302787
3129.34126472
-3125.15934117
-13542406.8377
-557619.945728
67.5926325994
-67.6265311094
13448449.8174
2265540.21437
-11069650.6361
-13640916.4377
419263.470855
1659671.17284
9.39172997285
-9.39559390564
18046.1792376
-18147.0710643
34231.6158687
-34309.6787185
667.78139306
-666.202072052
500.827971925
-501.005275008
-11680237.5343
23905.1296932
-227148.87939
1107305.31099
-424118.506596
52884.6715526
93486.9340605
5204473.00376
-15.1570424223
15.1088549694
5450725.9627
452000.372644
3700207.36164
-0.684600851972
0.686354146161
-32.8644285802
32.8852846115
-58467.6871453
-1852009.20966
-364939.449243
942.562752301
-942.366995534
335.693006318
-599334.358722
194.539202208
-194.413811825
46768.7989198
-48893.7801252
77.6671159602
-77.5374748778
2.13211080031
-2.13668654965
288561.523831
6.88365947757
-6.86247104099
3.22827395348
-3.22375139043
3984.68181662
-3988.40719995
97137.048469
-99529.7417343
375028.880535
1273948.31745
1644176.3727
-1057706.11317
3029663.89272
-918271.485701
1813502.65233
194499.232
1969188.91415
-0.90545193762
0.90587323803
-2985941.7235
2.09269024056
-2.09201357064
-18.1306630585
18.0634095882
-323941.10895
-1454783.51025
1179630.51399
-5293.58537404
5360.47534482
3.43506968425
-3.4326383512
1221851.68982
78643.4735454
1948053.60077
1864836.57638
-200059.865225
49.3952783854
-49.3514428885
-66.468735057
66.2039982921
-5459.59160064
5466.51323669
-0.545205969772
0.545293667173
100456.833823
12039.2125898
-26166.0147733
0.708368912847
-0.70745617754
-906634.314832
-636273.296234
-10733.2102594
-109239.393025
-16.1820833082
16.1262634138
-5671.80670318
-236.56123801
-1713.55579259
1715.3857891
1651963.47403
-1168235.62216
-25621345.1936
-10817463.569
-1476.73331007
1481.6820904
6965976.39995
1375334.9684
5316373.92379
-26479388.7259
9561558.88923
-110055.234638
109940.561477
252107.26123
-259205.381376
-7104698.47369
13185816.0711
-1593738.2588
4645595.66067
1974610.82074
462395.229626
-6796425.20015
-3764245.81268
-1049280.20952
7648637.88318
-1344.91699639
1349.34562847
-9070368.38867
7096125.34825
-2141247.00663
6455858.76247
1801732.53146
-2427543.04991
-4694520.7713
3777517.28269
-10951063.1007
-5308989.50129
-106094.946241
106088.225118
2.57821079277
-2.58923178579
5739961.00175
7206311.26775
-1179939.19309
7339315.28222
1941623.58329
4695566.65272
33007842.7934
-192.150361828
192.089138908
10922564.1156
1653681.65699
4004321.69894
-8537807.52981
-154069.267659
154078.614953
-2892268.06426
-496196.401858
-216.003535151
216.114020422
-44804.6634054
44780.5651516
9643816.84567
116.174815322
-116.252481919
1273943.16635
2699522.61865
-4119460.46997
-537059.590173
595955.650872
2234936.06227
-1831103.73043
359082.197666
-4469687.84915
-444657.077982
-10328394.0927
376.15534114
-375.577631467
-19416997.5715
194.989084978
-194.076984011
7557265.94613
7192852.15029
16703994.7693
-1521163.47208
-6231640.04116
-42856.5952074
42848.7892572
-2258459.67725
-3676654.32789
-86517.7717498
25035039.2997
4348044.57871
-1692898.44132
1126458.28444
-13312571.4547
-692208.905819
-1733355.54816
7399316.94221
-241.158177242
241.333160351
9757633.21298
-419.875675016
420.493852426
-33145.3859597
33130.8949621
3993.29514344
-3984.18727917
7163146.51585
-5140825.1435
6515950.82104
-5505681.49416
-4928323.0149
-3992379.45528
-777188.325555
3221139.30567
-5289111.59436
12269141.8958
-10303320.3519
3476970.02449
-13282180.9176
1461148.38347
7576831.02137
-13454679.8785
2.9402990946
-2.94665459642
6.06360121228
-6.06177454228
6116754.83075
-2.95378692781
2.95297287773
-200057.828343
5684861.67842
2173132.51762
-1677128.17182
1294243.88167
-1704133.69911
-4340270.30414
-9306560.42494
325768.419129
-358540.399061
-14084037.3707
750600.448992
-1618860.35001
17886712.1407
4032354.39231
192565.27032
-198365.820924
3670409.15507
-4259.83531615
4268.90530475
6274406.76799
-5634747.00707
-526045.1811
-4169.50884793
4178.92308298
9437908.32205
12855164.7402
-22830.9040652
22826.9127574
-239574.938391
-2587978.1969
6.4335899955
-6.41430491367
-294162.469197
5079629.10988
-8482437.03902
-273661.13458
275397.798196
1874985.54129
7362681.41809
1816.14933276
-1810.87614634
-2280.75085415
2287.14854659
6675383.51967
-1105354.19981
-57.8507229462
57.684359537
-5235885.24567
1266768.49803
-1447831.76937
-169497.101101
-2096631.76601
-8478684.33048
-469651.38846
464419.252826
1.37552432413
-1.36368171353
5589689.94331
11244649.7869
-60505.4113335
60511.7676111
493816.696717
6577795.58091
-7439394.28738
3951519.8675
-42968.5700736
42954.2278819
5447934.77571
8442424.7659
1240108.12394
6718968.64568
-3040790.89275
-4043997.27466
-2297163.42705
11036779.9733
-6333743.63078
1215923.6809
-22.8232884722
22.7819024533
6749171.97267
-1000363.81275
-7552.48564957
7563.68597947
-292018.62932
299202.545338
-4439123.16383
615.763412441
-614.00607379
980954.539393
4684661.41992
-4197352.21838
-1834762.67377
-698.559026698
700.219751987
1.91777911621
-1.90794272308
2885736.65075
9892053.4354
-2519285.55261
3786501.6755
-1468.15738493
1473.26184036
-3289889.09746
-523758.79334
-7017.34388274
6744.31094136
91.0461488342
-91.1478365587
1118923.46286
5317403.46356
-152521.74358
-2419250.52523
7537682.36165
-7066709.89764
7.09065595954
-7.09406910221
-2713093.07204
15.9704661099
-15.9844548666
9899218.15097
12370265.9495
9327120.94104
-3631.30702411
3639.39262862
-6.19508200777
6.19087696938
1597807.36259
7832160.75023
4356800.48151
-6461267.71234
6569661.79867
-133.739660051
133.544597376
8888818.5007
521.812486611
-519.853206527
47892.7183156
2051512.52848
-2255558.47883
-3470456.64264
-2563306.52482
-51740.7518334
51456.8024911
-2002356.65245
12434546.6723
-4576495.50803
-18137535.6646
-7525800.49906
5340630.30554
-4925208.45205
-572131.287248
-4283346.95259
182606.673072
9358538.59497
4986446.01618
4402520.86213
-7.33388818032
7.32014758393
-1628.11645823
1633.57632148
4399837.26223
6470887.29617
-7715635.61703
9736822.29022
-4680864.19237
-11749034.4238
4277574.97956
-177285.335835
-512407.659395
489278.732024
-5108922.20641
4554663.65271
-2358276.90393
-26204.1251424
26202.6023359
0.452348531166
-0.451314435058
-752830.66163
-8039832.94927
6.41864626165
-6.48891125152
319112.482672
8321386.13507
7926281.63396
-8136218.07284
5763444.38949
-3380056.27531
-7362430.48356
-7568626.66953
-5162289.97168
-5322772.05293
11577407.4141
6257109.79246
-3007.11096393
3011.64955016
-1755502.05475
-26198.3638279
26202.6101482
5950854.83483
-680.293095999
682.090491679
2102.03013764
-2095.70110445
-3621138.87965
6109979.80893
11605763.7112
-422797.602622
382863.714674
-7456236.92988
-19.0188356132
18.9882583217
-2070068.68975
13434430.5443
-15605490.98
-142306.19615
4202070.25273
4487737.26324
-1757713.78744
-44493.219133
44510.4633387
-1564548.04438
-24349.7019881
24346.9706347
1493654.64668
-1509632.24816
4104194.96746
1381629.20083
3151992.06851
-5867186.8556
571.426550412
-569.68736689
-20001.9551888
19947.4992163
-17902470.9746
-2629982.99711
3757196.5432
-65614.8530427
65627.5508774
2924039.20408
4593128.92399
-256786.844506
255442.786552
5.68820087619
-5.66645624014
-4280401.91438
3795654.54673
-108093.091982
-5935355.46018
11.5647435906
-11.5664710955
-3809354.74828
-6794345.63857
-1982.37473197
1988.5712503
-5972288.3159
302.701359719
-301.786402237
6032896.46399
-2524111.51818
34318498.8156
-798.417610547
800.491295268
4501547.84255
8115741.20641
6562337.24342
-3514374.03769
-8382829.82707
-10286361.9645
1586.22906288
-1581.26718096
-1259953.80831
10773790.3368
865650.194467
-15591348.7651
566540.054279
265320.228553
31129588.1424
6450602.25032
13794485.1021
1281954.33405
6373444.99122
5748508.80906
6302619.15341
8562089.50345
-440388.296518
-21.2921967396
21.2612187818
964575.424391
-707.456573891
709.041822186
-3204830.74028
-5754014.53462
2700882.15132
-35.9200211796
35.8445416762
1202965.22228
-3257854.1275
-27803848.1083
1675472.05401
1846968.93776
-2042580.6208
-4627433.4908
5419410.4997
5042089.45019
202.431173687
-201.619767956
-5991821.44415
-5035909.7568
-3127936.0334
-326937.066076
327165.870228
5882228.93607
-2149279.13226
12512193.4811
337823.466943
-1916627.80994
-545043.210152
4612822.0228
-85.9316816906
85.6931822899
11162080.5105
-10512468.7503
446863.755911
9201449.05705
5827360.2341
-4693242.08608
-5919132.7664
-42.6029126156
42.4814683351
598120.917755
-11197733.0736
-3026881.94003
5.23414287729
-5.23325104248
-169.233653086
169.150217907
-22134.7555496
22137.2978089
-6615821.50884
1637367.04964
1814917.46711
-3362.0494316
3371.55392397
-17694891.505
586470.760947
16051463.0535
-551993.234337
137.56202672
-137.538688395
13403079.1842
5248430.05251
7015.35698614
11274227.4571
-4271629.02467
-9540526.04405
1515425.12655
-311017.921478
293909.470281
-3795.39715172
3799.06266642
-2284.27744522
2291.80072556
1617196.91527
-6627524.38928
3382362.76715
-796.72613777
799.1019048
3776591.49996
3750969.18129
9.19820786041
-9.19382303091
-15932746.4535
-4161489.77703
-4539769.364
-1496546.31732
4415655.11398
-281386.082494
13439521.2483
-9526991.51267
-10734090.8544
-1333203.11861
-3913565.27502
-38636.857479
38644.2682966
-16937.2378869
16945.803168
149068.343183
-7594007.97454
12217356.9083
3804204.80003
-1544244.7224
-665247.576828
1294820.79503
10120731.2098
-301997.616754
2136028.57625
-588.205727462
589.535845586
-9086824.36467
-341285.6881
9580734.0795
7986754.86939
-1522241.97214
-3607686.0706
-7402.22647408
7411.78794444
-4838223.1473
5115089.57084
10899618.0398
-1483215.99926
-3009269.44054
-2300174.15128
-11493.6986944
11503.8674318
-0.5911334483
0.601166696642
-595519.144483
7234465.91823
5074230.01222
-10147141.0919
-36266.5119551
36255.0161234
3484417.31375
-10802036.8856
4444996.28562
-18674.406249
18625.910062
-3875881.08027
2.26862919348
-2.27004492274
-10233647.6739
2125316.16576
-3654143.55581
-5336350.8642
30.5896841603
-30.6493255154
846671.764268
4901316.50762
6579960.0855
-1322327.00708
-15924673.9244
-12684.0537016
12692.4229395
-679707.247226
3728667.72051
-20587931.096
64.5852530446
-64.6084185389
5.67775145985
-5.74235390436
3182242.60296
-555830.368553
-4776443.65603
626221.542419
-7787103.25468
9.2257037794
-9.22964953045
-5360073.41707
7684647.52694
15552702.9435
-9601312.01607
-9268794.92691
-1181970.05827
1381648.14547
1832337.02174
-193678.014349
4996802.80347
3285106.58089
-12301655.479
-2430854.1694
-8164260.03673
-7694.83195151
7699.18768899
-3819030.3924
-2075369.12579
283096.614229
5.31319990513
-5.30558638419
380737.637018
-5415690.70798
-1960948.87433
-2918882.3351
3886303.9898
2442586.00843
3002168.76439
6531923.82763
-13102103.9915
-7416902.65508
5476123.65362
-350.511291267
350.967735224
-3105722.04731
-3818003.5357
-13362308.6111
427633.190533
583567.390315
4043906.10948
25401.3776983
-25437.2702072
11531343.5363
-5800672.17729
13968212.374
2301393.95427
-899466.461254
-4558848.83672
-6893274.7976
8648810.59213
-2595562.53275
20855051.1134
-14.8118935136
14.7901434716
-111865.998038
-3397471.42114
8119218.52561
-12422.5321726
12432.5868946
8693567.67306
1178706.35036
-1365120.72536
15868053.9331
5148364.02214
-7391294.88887
-5915005.14019
9957775.03275
-29.9076541895
29.8302545002
-4071219.99079
-5376390.67059
1249.32120081
-1244.48901253
-2017849.62255
10769324.7693
-9148251.34972
-1508818.69143
-9173.23460089
9183.78425701
-1088491.85911
-8743826.95239
747592.674821
8449018.64042
-2346525.71708
-1110123.28649
-35406.4919758
35403.2864832
44.7079654366
-44.7646897276
644392.974642
4643066.06235
4577205.69896
7548135.41362
7023319.00411
4802176.15427
-1665874.09936
-11612584.7544
8365774.20102
-147613.882669
148241.255544
3436609.05505
-44.9641868292
44.8414391116
-5235354.2228
-9450053.71563
-20.3880584579
20.33996834
1721210.20599
-3698999.7785
3110511.90734
-11079469.1022
-6496555.53814
1744686.15006
12.0237493642
-12.0217403187
14802529.3889
2255771.45112
7588201.68089
5874255.03925
4323218.88367
-1509817.22435
12.3179570954
-12.3237096056
727251.525658
-374741.066866
9800364.82886
-616.30977531
617.699675156
8005717.13494
7583213.4502
-394986.554999
7627492.59386
-8935696.76898
4065236.17222
5059360.35727
-3568610.06662
-4333983.45295
4083461.96152
-13248687.0483
367.364506427
-364.109666991
4126185.08451
12271994.9692
5479524.43041
-24242.1747663
24247.4388548
-3887103.02353
8559054.84155
1931665.00944
964974.165578
-1357290.05535
4251307.47466
-21.437306018
21.3879377302
4054035.61148
-2133545.88034
18.4594446164
-18.4847119392
-5433941.56997
4013315.40439
2506436.74026
10584520.3421
1810996.38355
4013484.51498
7524301.91648
-13190497.6052
-10929132.1424
1559050.48222
-217.002150749
216.973176958
3503447.69877
-6215434.97833
255.194500662
-254.930714308
17413.277466
-17400.1999229
-5266344.76634
-13769855.9097
2095674.78569
-25240731.5901
136.763631361
-136.068715233
-5144548.18379
188009.504852
1713256.91966
-1323518.68278
-96919.7562675
96962.453379
485030.836743
7758924.50203
-4800008.51266
1318931.21223
5742154.09345
-507679.423575
9636942.4739
4017147.11949
-5960536.4951
2100469.37678
354696.959504
-4595091.84471
11536518.4903
6961746.40454
3430115.20665
4336506.63341
-6620932.76322
-1225356.6938
-100297.594227
100362.313308
6068224.82246
2071625.89838
-340069.367519
341337.314257
-3030868.39591
2059383.55507
-2757599.76021
-2603726.85962
4520768.0549
-1832535.85716
-1514909.98201
5180383.09457
4559692.78173
-18.8620678086
18.8302706655
-1575149.17154
12103157.7927
-8362745.57219
2158887.06836
-1132609.29108
-1454632.53952
4382057.56286
-8464562.14352
18.3280647982
-18.3501465165
-4181336.85732
-1036299.44695
-3637.14534615
3645.1170177
4386860.02556
10971821.8902
-54942.3943254
54935.6759825
3371424.99409
3210278.1606
3256562.92522
4990237.77399
2138993.22181
345390.63419
-376407.909598
7199824.21845
-6959509.66498
1051.03492208
-1047.26908881
6764404.87326
-400275.553732
397398.878378
952890.231186
-136065.109655
136241.299128
-2102335.13178
-9885887.06234
2656130.03057
1835045.59598
7420149.78186
164080.505875
760.690967141
-758.252579331
6159163.31002
-183.09845168
183.127154218
-1373275.10688
-5588294.59409
953476.629828
6528196.4722
-106.991305575
106.801892679
7121.53006112
-7115.19915349
-89.3722404727
89.2321719583
989946.882179
232080.296231
-2794884.88985
-20062.3272358
20067.4774284
900976.424754
-1017983.08551
9568190.2305
-8375168.06803
-356.753296995
357.165153323
1941714.02616
10.560300899
-10.5744024506
-26.1856261211
26.1042753533
7871339.78003
2209085.52783
-27889.7149549
27887.7173134
321452.203668
-320739.366116
4906075.37414
-4862758.76205
1725227.35639
-56709.1437223
56735.994928
-119944.578756
119822.407579
-4970829.21363
-8809779.09831
5141626.86816
-1925061.94473
-232716.404621
230325.749965
-45654.2156727
45626.4890545
-6246068.74977
840147.629291
2026223.43491
8738416.87144
-1082.96481177
1086.82829806
196179.098407
-3790752.76285
1141294.43673
-234.100069332
234.244958543
892977.484728
-2841670.84615
1154.71726157
-1149.45106633
-0.154067512949
0.162029484941
24.9420116719
-24.9996407746
-6145055.23369
1099.19814892
-1095.62540941
-2695065.13848
-15797.0521434
15801.3665384
-4094741.11047
493883.419862
2873805.72727
7599458.30837
9767888.95502
-6465139.27942
-2547976.20033
-7293.16443817
7304.26920443
-419.334341601
419.979192626
3454136.31833
-16854591.6398
-7833.56118512
7846.09977009
-11815.9592721
11827.0551222
-689304.381266
-5027635.09095
-2678739.88466
4956733.81922
-3717355.1321
-654283.758271
4656268.4898
-418323.729791
-51138.492219
51087.2066869
-868544.241363
801224.016002
-47629.487896
47598.9260646
-2980087.13965
-3813133.40462
36.9849043657
-37.0598015056
-180937.717064
850684.532226
3808351.30785
-26181.5857899
26182.9692741
-9137980.19437
-88.7367329851
88.6513187017
1290017.37282
2454908.97345
135.04802572
-135.108778601
-151104.211346
-5656906.78006
-858852.941632
-105293.173195
104904.153825
7734636.21735
-7998.91795991
8010.07598805
5501654.38484
6.30586237267
-6.31075968623
-11727235.6698
-201746.562301
202526.068051
364153.000039
-405232.787571
-11016538.9986
-5208417.03415
-3976926.54438
-2049023.31838
6813260.67189
-5695100.59876
5949219.96097
8473978.06735
-7188285.62651
-20.0314561144
19.9956859012
7971012.04998
-1996410.79098
-10519630.2955
4709985.69105
-6446477.25121
-9701678.28729
-10015625.9931
-1911897.47524
9612840.13151
-8924984.24324
-345535.825804
3086064.62204
-1315292.93926
-7093338.01175
-4511076.17931
3254824.49674
8107700.50868
1067.94994205
-1064.98087091
-7326223.72874
-89333.4758331
89366.6011633
-8199016.7342
-132094.513362
131067.901989
-5602460.85166
-23.8633754165
23.8099200108
-3326424.34858
-1759.6203608
1765.19304619
-2429240.43608
512435.37568
-99.2396820201
99.1322532685
-2305255.55186
-2768780.72848
6262908.09167
-9032387.06255
-2599175.30951
3299239.42047
-3575126.7581
-4076150.49586
-776737.098365
-10061224.3659
-683919.76009
746135.250294
4623021.28685
9583830.23287
1110317.67327
-290123.194099
288072.218369
-45128.4893471
45135.684281
4205510.83219
-3428153.94095
-2999.24625335
3008.04664795
7.08221692258
-7.06778562509
-9638159.2449
8448257.08706
8475972.68407
8.02330436587
-8.02623176799
-11135970.3713
769601.578284
-2361754.79285
-3424283.92105
3278778.33638
-1803471.09812
10115027.0621
654307.45315
-1259865.75002
-12171430.671
11.9878474345
-12.0172528384
-35931.6145092
35933.5695749
214.788710221
-213.995188004
12985350.4697
-714003.275306
3857689.56604
4626397.65473
-6272230.42368
3664362.59266
3050795.45089
-1593495.26333
2087392.62194
17.226379991
-17.2477062102
-11262960.5882
-9983054.52628
-9780011.83845
7604398.0701
-8579.7101287
8590.37203735
11026661.4059
-5757392.0663
-959770.102474
1065878.49888
1883618.21445
-842094.101512
826157.546969
-1519571.07339
505744.725512
-510644.888031
-3462232.64366
-6323861.45797
401289.195806
1499987.2104
-1072775.21514
704.39454696
-701.971634199
10164738.3631
-12254163.3664
-922827.599612
62663.7738984
-65296.7461575
-1692718.93947
-2504560.45739
6769334.13115
-1996.17296816
2001.97171089
-5481.90279133
5491.27956997
-4524040.3264
6709568.78915
20860013.5639
8131989.4814
5480052.37654
-215537.230271
752376.519985
-1983925.61136
-6797793.06506
10335379.7364
15023533.433
-9451791.28501
-6314.39560479
6221.62816552
-8888300.88766
6716874.7725
-12899.7460293
12909.5062101
-3464742.62349
572883.121743
-5.8619972327
5.80984434582
663672.777259
-299.35496802
299.558409854
-3128133.36917
8575979.23863
-7.6151494841
7.56278394332
-20.9102969398
20.864656022
3076434.77953
2254674.37652
-3374389.06263
-1489138.9345
-3774180.14477
6990143.49648
6.14123913704
-6.14949995935
-5050926.51197
-4377230.12136
16281260.1702
3336847.17202
-80.7254265473
80.5088154167
-9816341.53921
274119.417286
-600486.73185
7951645.93164
-2640541.12709
16579571.4429
5522079.80443
794722.093363
-12725266.3201
-4654128.59126
-737606.453254
-4629287.59603
6520396.55625
6227688.68435
3461407.99989
-50626440.7453
4812971.6399
5298927.79615
2991993.9552
-947916.439278
-5712464.30816
-9118542.98559
-11842530.1401
1618033.24652
8716962.4549
-8737120.65008
-3815.24080113
3819.05458482
-2043671.69003
-1619470.15294
8400377.73695
-3878.3700148
3884.3362401
-5052023.62221
14633096.8015
11509165.5958
7068516.09258
-11550.4936628
11533.57383
-4185645.0396
6321151.27309
3866963.85382
-4950956.67544
-2.02085747126
2.01930687963
13812583.652
4418854.89365
-2189435.69956
-1540412.36355
-7072318.35829
-20199284.5801
-3893125.24428
-1954061.77052
-514613.866969
1157175.07496
-8817.08736443
8826.95096147
-327100.322614
375655.256309
6669364.1153
13.7474392141
-13.8438373044
6.85887981937
-6.84040707571
4316201.47601
2210428.94623
24268041.123
429447.336887
-268258.597674
3588945.27735
7473067.03814
1407764.03135
-12684545.1469
-4228306.5932
-288194.69804
3369260.6346
6463957.99653
-2693477.59158
-489448.255046
2364355.50942
-151871.455134
-55057.7619532
55028.4133601
-2908860.82075
3917705.09938
-11538091.0983
-2689039.06946
5694398.89558
-9238231.9953
-4408882.69424
-10290.8699951
10301.0651257
-24782.5616618
24777.9070338
-1151785.35175
-1649595.55221
3108778.32965
648507.73036
2126741.03455
1288.23888557
-1283.79704635
-694273.867306
-98794.4971263
-570773.822856
557996.463659
-4573094.11327
-14304383.8738
1255774.4329
5947921.14318
1.8067431879
-1.86739943002
10076829.1273
-253141.833329
252958.077849
-8692139.39344
3194024.60463
760.081876148
-757.116668117
-17707.2375625
17713.6989799
3894091.711
-12546693.8973
2028546.78658
1900822.70941
-2830945.62411
-3627077.43932
536294.115083
13748398.4077
11857991.5905
4738737.84917
-13845389.461
-3583923.09876
-21334.7063838
21336.3864282
-80220.2011175
80231.1915793
-12756318.2203
-17.9129995446
17.8890690833
-2119453.88859
-20238415.4653
-6328849.72621
7773126.58458
-4283275.64321
1095318.43863
5341741.57508
-5134958.58129
-4815004.55862
-173.794722814
173.843645999
12413557.0196
11944860.5902
4325078.34935
-1869604.98766
5585102.26468
-16050265.3413
-4637.5570739
4648.3399553
-461607.97952
457564.591342
1697174.2687
11894.7670482
-11887.2489102
7150882.04195
1992376.57724
-35637.00446
35633.8168731
-2147878.24565
2505038.13493
-7463430.10695
-8702798.59578
-100251.023335
100137.582287
-2374244.23187
0.581744759862
-0.613674041019
-1414687.44683
-375940.305132
1987148.98238
-112820.654302
112646.120976
4962924.35955
-4779564.7762
3165927.76543
-2701993.73251
-7267842.15639
-2963754.06114
4073142.04333
-1815021.61284
-357688.02418
-4536921.42197
754716.505601
3913878.31401
6574885.95668
0.593875098766
-0.597063990484
1963127.95622
1535944.09511
1100113.10616
-2920417.64347
-66979.4167021
66904.6702492
-7084458.61593
-2723.19755892
2730.00196481
3038280.95159
2478838.34743
20681200.5781
39898625.9829
418211.440252
3960003.58255
-1724048.1022
7051758.14671
1258700.91689
-3783530.81347
-5103726.07501
1.2191641282
-1.21989642859
65549.6266313
-8623817.72487
3.68698149627
-3.67837510943
1444819.94667
-644.354004627
648.89770606
-6864569.69107
-5975.2549772
5983.77992028
3357782.94297
-5373252.65274
100768.560614
-102426.643204
3678696.1708
2545573.27712
611215.28753
-13672106.2444
-587869.757903
495034.605207
976531.929864
-10773565.2468
-2827807.70203
104.592286479
-104.0963813
4544985.94834
3410355.76117
627964.698777
-2358139.57094
321920.933977
871685.130505
619207.636512
1956651.48148
771350.368511
-700915.652643
-433.00518449
433.878630962
-6759090.81285
-5695143.61275
-8282798.55749
-1512897.43456
7529473.18069
-3172048.34441
-3666615.77889
11845976.0554
2934947.40853
-5726627.5424
-18913178.8856
-7273572.92258
-845852.419031
-186572.826352
186040.972354
-14193.177542
14202.7467408
-90.7935953071
90.5592513214
-81918.9140745
81962.8553046
6090541.07199
576099.875986
5910418.5888
10373153.532
-6423273.3375
4371668.40244
2408595.09763
-8012804.98276
430.9342983
-428.407934552
195810.529055
-914.777910363
917.263786567
-5882734.79795
-12788698.6504
535376.909621
-11881456.956
-1857831.48269
11746149.2607
-4296168.142
-89.196401038
89.0923332473
-21488353.5028
-7897875.33234
-269.227537105
269.345797546
349040.615828
3450714.3227
-3373559.6738
-2263063.74566
52.2624316731
-52.0884902949
-392.219189124
392.853929835
175026.609365
-1059064.75012
2310742.36585
13.3404922304
-13.3646149297
590035.496395
-3206945.74065
6828955.70622
4113020.769
-6616492.34182
-8751801.58463
1890636.99835
-211907.153277
-3036896.28809
-16086869.7528
-7454658.79701
-35.4219878187
35.3354326832
-2181194.05597
-1707246.14539
2879655.17931
-1742179.28026
1348957.47369
-0.703915687963
0.701858553752
5676011.57828
-2356002.95444
-2.2980179682
2.28189547366
227308.856135
-16654.9084086
16627.0067311
4543892.60749
5343977.00819
147.579002012
-147.587564873
-4.72909321559
4.72547665131
-12349499.0806
-2547953.18206
8083410.96373
14597414.4779
-3676541.93883
13.0059034451
-13.0094004855
-15746659.1379
-3808947.70112
1241481.8226
-12206969.1181
-2075747.03741
3091334.8644
-11283156.6678
-971615.890112
1735396.14711
5891400.04149
3909317.47333
23133180.5044
124575.980441
-131971.094483
5875347.35227
861173.344164
-5756303.39795
-1683013.35878
19790936.0365
2734483.56233
-5215002.80844
-6193617.61393
-9040226.22085
-9272.66165114
9284.85707708
4294733.90729
-15.722922795
15.6858192715
13686393.5801
12054030.0934
-3828413.72771
1501598.02378
-5993098.60282
-716249.788619
-246244.975509
-4419370.86856
-21481908.98
-27.1151112673
27.0430018752
-880651.525581
6622955.72114
-4015213.2342
6418353.16662
-3.10813607577
3.12526139665
593415.803864
2840569.26925
-8201000.70948
-231390.211408
-349.477250854
350.890579629
2203638.30897
20634137.2495
-88860.534667
88424.0412642
-4574189.3699
-1735521.01223
-6289547.10233
-746873.362929
807890.380394
9298874.01477
-5642133.29698
76563.8944342
1542587.31033
6964785.37813
1732099.03016
13100660.8523
-6282703.65403
-203763.286974
37095.6394122
6912708.60708
-463950.075367
639.777170306
-637.248483713
-5415936.20016
22802853.499
5.82183398481
-5.86349924858
-4511568.22284
259584.841097
-104486.977128
104437.759265
11938020.2518
-5337926.6098
-3406138.17661
-1006.49738984
1010.23582252
52667595.5917
-9856222.79189
2210179.10102
6.48944198642
-6.48196013584
-8949.44227647
8955.99015325
-6184970.37145
5255904.34158
-2638551.7646
1125785.92245
1323515.83101
525990.491074
-84.0620218805
41.58364429
-29.0408654824
28.9497316262
1317813.76285
-1415035.87664
8246007.94801
4376976.97441
-5735639.18598
2064915.4005
2440972.22414
-35.3129131854
35.2115070909
-8326944.18776
3166119.66727
-4222240.13092
820394.920464
-105250.966189
104555.203556
-3303656.9141
-4575786.06139
-96.1694622276
95.9665768917
-264929.908675
-3577.11050284
3585.24541649
-2760892.79038
-5605957.8072
-10258026.3685
173.674418095
-173.683260555
5618146.306
1845.76928461
-1840.23902181
923158.854177
-4759601.59054
-1764875.28797
1612.52263805
-1607.30539684
-4215199.74289
-1952991.70945
-10061547.615
-1548.26485339
1553.55406352
-40518.0025611
40535.345993
2487973.6503
300307.602375
553068.298196
-551051.561748
1358051.5209
2799354.67445
-93502.4487108
93608.0391169
1278.81008705
-1273.76094171
-5043157.57307
-3694490.83038
90356.6079337
330638.37238
3340647.68355
2171967.47224
5861285.38944
4896969.65762
-2320321.10577
-6567687.72324
-14292547.9535
-43.5005859046
43.3985126046
2646331.38844
7016144.10992
-9453.17445234
9458.66065896
5814829.97966
-469576.749566
-2424358.31674
-1118762.09774
-5460473.62687
11767568.36
-6368254.81084
2505824.66173
-595117.858801
3981962.36199
-4053001.83869
2836756.35962
-507.395816105
508.193946085
1987062.86024
6451504.84798
-20803.4430164
20807.4741407
31.6131649457
-31.6119060539
3767077.23632
8329625.90887
32.0748022508
-32.1722872324
-125567.689954
124155.373233
-44.9932462272
44.8780417931
-64.4586921955
64.3494502922
-26814732.9381
5116614.18761
-6115511.11075
-1019166.18569
2.18557331527
-2.18087032281
2845537.69471
-29078.2606
29077.0845163
8101579.3278
-1007398.43262
-5764.76120222
5769.12041972
-22288.0897353
22294.5791921
-77.1425642516
77.0318619561
1089855.20691
8013567.91835
946282.91324
149.622486449
-149.23709257
8278604.92459
-9028971.53147
-1737536.46236
-11775386.6023
-3266332.64017
-9209685.25367
9856749.63855
6574235.73169
-968233.309307
3934724.99529
-134985.997071
135432.206957
-1137406.38425
803016.383314
8.91125368678
-8.93588196428
1232253.1446
-6498600.47413
-8756264.81418
9.86290177108
-9.88748383601
1598918.79742
-22244906.0695
7364321.99761
-5073696.42383
-1151971.50458
6579511.44446
-2781727.261
-4842237.59345
-5760294.49585
7654769.13245
4758300.69089
4178776.48814
1000394.45243
-976.709937949
979.937480226
-0.133121898608
0.123772874895
704257.543968
-542169.166246
569916.924176
-4925867.05733
597.34236354
-595.083303562
-2103164.66136
3835527.4663
-22334485.8545
1574598.66395
-331684.838188
168.725342855
-167.89416093
-5453615.99112
-397.511631853
398.024347628
-52.488972211
52.3757503628
5364754.24291
2809385.76964
132.222515828
-132.246189131
4133956.39061
6297690.80413
14247037.9716
5288114.64802
-3291942.0347
10192040.1743
278978.231644
-300912.421064
10971744.147
3511010.84654
-325.183532018
325.586570215
7263916.30071
3842367.68391
-1586989.54294
-4511686.21911
-9890435.1634
1205212.31573
-6047198.74271
-6.07548558017
6.06432627371
-3.08123063279
3.07882474287
1797621.74798
-2573694.17412
-29229.142578
29232.2101586
-355560.006899
356762.733184
3374831.80232
-1716939.60447
1163.56021374
-1159.36896276
297729.137789
-8002290.87976
-65.2916409101
65.1034107297
-205445.412334
204930.981631
10.6269993045
-10.6514543376
48.9440376718
-49.052229057
-281489.956129
-6492608.17773
171153.128898
-7708319.48425
-430.647836205
431.107807641
460682.328511
-2301259.81516
185.081170322
-185.090201002
-979178.598461
5162296.90228
129752.720305
-132755.71568
-301815.129359
299281.806972
218821.266263
-601556.133461
596304.671209
7740521.92598
1923644.52421
6563789.03945
2825269.88368
-6541669.39479
-199.348073274
199.354876072
-941984.409313
1070723.35482
4859921.71492
-787722.103083
794451.036562
16.2226023018
-16.3290199751
3.54222707256
-3.54527068755
-5592353.56993
-25097481.6216
-5606462.12013
-5710041.827
-22050.532029
22056.3809545
5666273.77406
-4642879.17136
-17627922.9075
3.90799301356
-3.90926881885
16.7376448382
-16.7528276289
-1107630.3562
40.1748715157
-40.30925788
2700335.85485
662542.085732
-669667.684902
779953.74079
-10625026.0223
-2853361.25763
12762837.2032
-6597738.65688
6230764.28224
4875430.70854
3065706.61756
-9202716.56316
9975555.80133
1.80188613428
-1.76011780033
10586597.6046
1288761.02272
9425.70851985
-9421.50243373
-4209452.42998
669550.314546
-436.411474843
437.168136694
-8744.05839814
8750.86095688
-483262.808052
-42.6531966308
42.5589131685
-139947.261105
-41556.7054379
41537.6497798
9240391.00639
1421939.86553
1974160.15149
-2434401.47663
-622209.683244
-1351100.0254
-11394237.533
26336700.5724
-1834122.00227
-9303.48228008
9317.04790696
175313.213563
-643.244736636
645.283021667
5529911.93165
-1.32896696937
1.33030824077
4369248.41395
2433215.08648
4022002.63711
-5000034.51402
2072963.21598
-14.1879228748
14.1717116397
-3355042.44666
-158498.684135
158096.246578
1645860.17115
11496846.6186
-140.87562134
140.769809799
-5155835.07791
-0.744319821029
0.75478803642
7925505.79813
5776485.81137
31.4779894302
-31.5585631626
-1922287.99377
-23879.0110882
23881.0092456
-481.799502428
482.842129489
6229046.01048
-1942639.04573
-194022.057295
-34046.3553937
34047.6751965
-3412734.91262
-5533.00129948
5541.82932219
-239383.826132
-8323620.02074
-4069098.14972
3432872.44812
-4430732.3193
10373085.7835
-12989422.7716
-14716491.2671
608034.408148
1284058.61008
-1825.23587264
1827.77016173
-5573725.54545
-7231533.69024
-8.93093018392
8.9153352141
-4090961.85976
-49754.2396712
49734.9469517
-36.3049116575
36.2045838456
4464165.04391
-1252100.40934
-2591504.10405
-5558087.45329
5133172.83648
-11460860.9009
-3810178.84726
1546897.48562
-1353333.96463
-2247322.79984
-3865740.68835
2494493.89126
-46.5332928239
46.4456831006
-4846843.99797
9880123.91999
-31.3566324459
31.2869177749
-1157096.19455
-2819030.82564
-8508568.7449
1037.03298553
-1033.26488564
-1931783.79687
-9122501.39067
-38.8699790071
38.7631743863
850490.540722
-6819399.87943
-3830.82090852
3837.55109782
3564191.65911
-4596448.68317
1538075.77078
-3283189.94435
-12001222.6797
9891116.18998
11.5061342839
-11.5880373124
5736110.2388
10.997362686
-11.0729504684
-5602366.71583
-5.17307066366
5.1409469712
66.9479685622
-66.7383251206
-7100944.15515
-1082913.00254
-42475.5727901
42432.1404552
28549724.4579
-4250423.34131
2188508.80811
-6.08337054395
6.08098262632
4694685.13873
-13892564.0586
-4260534.49412
1405903.89377
-295.690806272
295.981202405
2790241.336
-320.039779157
320.544763403
-673553.357633
-6930726.08736
-7599766.02696
744630.555548
-714239.510855
4507444.55795
-1964767.5661
-2415166.23758
-3525284.52588
-3296333.92723
692100.961176
-3300203.26615
-15930997.024
850366.385414
-48.1937788998
48.0816176164
-7935194.64344
-5699313.96
-4664394.25681
129.321439731
-129.204456985
8470119.87838
-886992.816679
290.056101252
-289.754856479
-804433.341561
784169.030976
4127789.83858
-30.4555107908
30.3729713704
1619794.71923
-42915.3078951
42880.2019808
930916.874965
4965135.90041
7335203.12098
5773984.9312
-608697.986322
5786586.9776
-10856.7981297
10863.7213589
-62370.8477943
62095.4105928
-849514.146529
-3362409.55806
-6277496.42889
-1601887.34219
-3830724.34003
1445803.10467
185621.857385
5608195.66881
2697683.31409
-3779490.89536
32.0993577343
-32.2008066221
5121192.1504
2359154.78597
-267.919103425
268.109557578
-11482207.2542
-560341.810186
547910.995846
-3409381.08342
-11269050.7159
8573500.79309
-4645783.88292
-226162.118131
227408.243073
6690274.53189
-21076599.1515
-1066862.18925
12027187.4477
3686477.18417
-1418440.98591
-45.0436749221
44.9059861458
2655909.08698
50852.5342761
-51367.6250713
2133314.5177
-1953446.51228
-3543951.76808
-8325978.85434
1922721.12662
805.612050129
-800.925101199
-71.4559151235
71.3384043914
-2546988.20494
-8742883.35068
-2478588.36549
-18656.2147599
18668.7430839
-2648.30205568
2655.41445919
7194830.91616
9204722.67578
1079129.51852
-6935615.43618
-9666262.48479
-724494.030863
-4677256.30653
-5488257.03897
-5135041.3944
-322849.205707
3754.08269855
-3745.90252286
13094971.889
5052164.86219
-3174131.02967
10.2395187196
-10.2467797078
-2833104.19944
4572146.43525
-5707938.71804
6789678.12639
-59.0884422873
58.9372296894
-5847289.24184
15182077.408
-15284.6042019
15290.6757037
-10052.7550987
10063.5499926
17642853.9153
-1998658.56848
-243757.053215
-356499.221985
7214783.42835
-852.605419657
854.906794812
5107890.99154
7474827.46391
-17955687.4809
8304786.02559
9.97962456694
-10.0066391271
-121048.474408
120801.797388
-164970.405434
165317.236909
2192091.48096
1587857.01554
-5248128.63829
-7043326.9273
-15224396.6875
-4060342.64408
2323098.60484
5102068.7377
12293759.4551
-1715352.1081
4158970.8555
-0.765809334566
0.765842492304
-78.3999487014
78.3266208049
13921209.2298
2357476.66518
8033430.85673
1270280.52497
1508.26346742
-1503.21398669
-139468.428365
-19.3196435283
19.2636758484
7314149.94822
-339485.261966
16911514.3864
-664837.387248
686220.488641
1007769.30021
-124101.986597
123843.354384
1096718.85423
7762137.31825
-42.6455003897
42.5414843793
-1444211.19996
160819.910277
-182177.433373
10022640.9216
-2719955.46865
2094260.99133
7148631.64602
-2097598.47567
-2894461.5147
-2495941.77352
-8239861.50636
-1020.1445109
1023.19747594
8356995.17493
5750304.8426
8.43797083438
-8.45705534136
1.9350073344
-1.96266808579
15.6366304481
-15.6445809591
11619323.9305
12.3928949621
-12.3551458447
-4622.53673969
4630.00409518
-11572460.4157
2399275.11031
3630661.06558
-1150110.10451
1266908.3572
824580.380315
1509041.57543
6412122.92713
1186387.74297
9485343.48233
-1196171.78083
-594883.968181
-3570899.68545
-18685462.2668
14282911.2216
-249.767782345
250.372799982
749356.481202
-3271.69041626
3280.5411589
5090478.46664
-13196769.2264
-7197092.1934
-10009758.0564
1925730.28827
-5972534.52582
999349.369633
7132486.10129
4872193.83457
1460151.54424
223610.364363
-229968.031107
-703961.372489
680744.508887
-870850.06231
1731.22302286
-1725.59159256
269289.638926
5406924.53998
6549910.05908
-574283.686196
-14.7670462507
14.7460522654
10444839.2133
4137184.89844
8757942.17489
802439.512761
-539896.158976
-3745171.72208
14374913.8331
-347557.505921
-10214199.9292
-10284567.7988
7829408.57342
5129623.22047
2910767.619
6845628.57322
-8390258.51488
-4792960.52774
10496182.9793
-2940376.83673
17874741.7184
-1196872.73166
-2771131.06669
-29997.2261043
29998.2080107
-23044.7246172
23051.8864955
-2234612.5298
14368322.4089
8990598.37638
19680.6354899
-19836.6673566
-4327504.44909
117.985622894
-118.038997718
1729460.79173
4952974.50955
5479445.73784
-22753295.8093
-6967297.08547
3610607.51516
-7995290.24735
626.907019427
-703.108218319
-2840141.01212
6085848.80463
3018420.45315
-374845.193489
11371966.7544
2097496.47269
-877064.676699
-1592219.04411
1050632.4383
-33.0589227271
32.9643430538
9.90894554123
-9.91559824102
4802755.19878
7028965.68357
-7024636.58635
-118.126900657
117.885673093
10035748.6115
10352297.6588
642171.768217
-4389235.5494
-10114.6722381
10112.3961956
-2600163.3619
423461.898082
1582607.00926
-4863504.99191
304869.655844
9391564.72806
4554150.55185
167992.168493
7662592.74924
14655629.816
9040605.772
5168222.415
433.106482814
-431.282736191
-257033.11785
-3552.89773955
3561.10863536
-2340946.59666
-9242432.94094
10431031.5539
-4283753.2236
2943021.82925
169.608036189
-168.810842743
-1682955.42995
-2830306.41998
-4091566.38652
-9187903.21079
397.016765896
-395.551850194
8108702.07105
-20975793.6615
4300414.55124
2666380.71261
-13366.5214653
13374.4261358
-2204564.78271
-493951.376427
509391.018141
11358003.5876
-4792145.59207
5548022.19424
3751575.52468
-86188.5567303
86220.0550334
-1787038.27579
-2339638.43767
717693.820761
5714326.47783
-13192870.8421
6218292.60939
-3100755.59982
-3952.51629653
3953.33385973
1291686.70288
9841116.9278
4412230.73138
4224927.40854
1847007.606
-12072430.3916
-2508360.25557
-2308289.70199
-13871611.8312
-802832.631301
764233.93895
4767413.36663
-22.7253170577
22.6429104449
1338045.25911
-1923182.49891
-311.325904237
311.717528181
-9888380.17135
-3.25682427027
3.25961412377
3540923.59558
-22223963.5188
-16299804.0245
-3255505.51843
-14653.4381379
14660.4465857
-8008795.03305
-45330.7965664
-0.907699165379
0.893817828188
9543545.25458
-9622716.8757
-45.0147995596
45.0473832831
1382366.2813
499951.102116
-8612867.08942
-3694833.62534
-1141.04276553
1144.81546436
15047232.8913
-197762.322535
197258.326442
-2779298.8456
90073.173017
-90233.5604448
2548637.16712
6662306.13671
4163948.01428
-11538.1199632
11546.7581804
12357536.859
-1923954.98576
-21.4724338497
21.4391713314
-5832151.16993
16492417.3961
1769266.24145
4009300.41636
-1917664.85486
-11068258.8581
-7384.30688794
7393.73235717
-6393617.34302
-3966949.35353
-97205.5860639
97315.57263
2197457.58529
-6977038.42575
-1536297.09585
-826079.061242
872653.387763
3943347.57789
1744.14787663
-1737.30388785
-1109687.03842
-1764072.20864
3333182.64751
-1721660.04078
4846365.91858
-479165.607536
-3637110.36257
-3783748.8129
5639614.11802
-2649493.06824
36.1323211969
-36.2324788119
-2569693.01593
3.71724620217
-3.74065969954
1882388.82729
2187671.18179
-2769434.86753
3970078.37268
-468.580214398
469.472744368
4841137.05405
-270145.891903
2577074.28529
-57117.0644989
57107.8441998
-3134489.49775
-1216726.06892
-1148127.90155
-8817590.51195
-6559587.05507
-298631.681774
-7089685.63084
-1587.09236293
1592.77447385
-32925.8437456
32772.7649875
-1288259.81538
-339701.439365
335890.073224
-14607611.3284
351695.493103
-8835527.3475
-36481.5071059
36460.7096437
98385.9655033
-3911899.0332
921616.609927
8407633.42758
-18776.8850098
18767.3007227
-8579670.31311
4552166.55237
154888.60874
-162005.142357
-5169251.48438
2817178.89256
-43.3165873172
43.2164625372
1423136.9891
7773718.85643
609273.477644
466.803006757
-464.925560971
2259518.31081
-4606107.93675
-4887442.18631
-2547251.19477
1086.53357496
-1082.81508854
8760680.50666
-4250152.47392
5362659.27263
-12299071.8127
19538376.4172
2384412.35854
-1001422.29972
5918567.63489
-1.74032864694
1.73583867005
11169939.0732
799.071292944
-798.982923659
-191.971318713
191.876532694
1622829.79291
12744153.8545
-4028229.05525
11244092.9787
3833256.89018
9958759.43163
-385.496252541
385.786502944
3716936.65894
-826256.773248
-989.740126852
993.097343766
5.52695620724
-5.52988881436
860460.02889
1816.43357878
-1810.70538487
-372323.084674
373698.526975
-11251783.1311
-892926.187007
-2867890.13117
-4771422.63379
-1355656.5431
2161055.03101
7022132.18552
2746504.92727
13547232.8734
5141837.07722
-1050915.24911
-4198389.87903
-15448701.7453
-54.6405052837
54.5423308652
-3429418.55813
-3902270.48867
-2085222.2817
-632936.980156
-15801.7947395
15808.0558249
6574462.7609
-42003.5789511
41989.6683335
4304965.88625
12351823.4077
-740872.553127
-1994614.64673
1095466.18729
3537037.89652
-9169196.32626
169155.991013
-182556.456496
5367148.73416
-1040098.20022
-931158.592824
-5877697.16881
-68.0996589326
67.9900371745
3633991.33935
-2172428.67391
8475702.27251
-5129188.95757
-1403722.39384
-697929.832609
-11147208.703
462957.629971
-2088217.08584
-7437315.03016
-8096029.55267
-5301543.1699
6256395.55694
115243.339963
-116259.333753
20856922.4815
6974038.37856
-3113241.29924
-10817223.4071
-598.329858775
599.571640963
2082162.62786
-7784.3875132
7785.62142411
13096745.8788
-2624808.3305
-2047070.09667
11152527.0572
567103.973977
-156.960196395
156.82543821
6644791.20258
-10952853.2429
-1657258.57846
-7442862.44672
-141781.879221
141681.400319
230032.213015
8965075.84504
-3607976.08835
41745.4158608
-42212.4103225
7942792.42786
-148226.943161
-3037167.18037
-2143846.55765
-10494987.0551
3275191.30012
8942787.49249
-460490.309827
453269.295775
1427.02670193
-1421.25903926
-1329845.02568
-5173352.44996
-45857.6231237
45182.7829644
22195131.6883
7.3677577441
-7.36966424861
-29516.3763681
29516.3362894
-92.1740359229
92.0225974386
563023.096068
13472179.8619
-1158637.83042
-161.409571849
161.219985349
-7.86604702074
7.85988999842
3251051.06328
-6331204.73921
-545645.187545
-11161458.0971
-1.87521852074
1.87308115214
4636139.32384
18.0186585284
-18.0517418377
8179184.44163
-671828.377873
671650.172745
47.616860607
-47.6619497994
352450.244885
7266641.25258
-468838.821844
-3023175.49259
-96.8555350655
96.693340257
2018272.013
-3174.8130569
3184.95504354
-135324.82509
135521.120829
1838320.85732
5165305.5904
-8664817.25958
-8450860.06867
-552.188061737
553.200210243
-37980.6989605
37977.1154326
-691796.147001
-109.881131343
109.790623244
-5590119.41224
-0.193158979309
0.182086438524
-6023679.96573
-6114338.38531
-377003.41908
-15733613.8233
7358438.26265
-51.7018457797
51.58134871
1839974.30473
5765484.50802
16166055.8445
5443926.6389
-3409420.49782
-175252.525287
174780.988146
3629666.1812
-2532947.44908
12114628.0431
-136844.96076
136612.491081
2805879.69982
3751898.74628
-71102.8304822
12454350.2936
8495383.35852
774913.961628
-270.732651772
270.799950057
-6744482.99116
355277.990248
3901065.57018
-46730.4227381
-14301495.772
-3744685.33077
155924.063799
8534752.56505
-672446.834887
669818.319053
-1289133.2649
3189743.79764
-4058.65525211
4068.59233013
9772777.37446
-1299449.70827
-4721.75359078
4732.17725404
1323550.7537
4283171.57921
5212104.56246
6075253.12983
-21712.8653651
21715.2693598
-480402.090508
-7081.01263022
7093.41905858
20777948.3986
945744.335971
1707875.70833
-19612676.039
4.55404864165
-4.57168220634
-1819261.80766
6722019.59121
-1844643.70507
2386406.77842
-345335.035276
-12815844.879
7526579.30793
-4719347.25236
6446584.0612
3379376.05973
-10460611.0951
-152842.579308
152950.259379
8838550.06232
-1600036.69481
-430194.61179
2104019.85553
2773.81429682
-2765.64367532
-424049.730636
422798.172925
1407259.64042
374.971474911
-373.611670663
-16483.2834078
16483.8491113
-61.5014691272
61.3981906039
-148209.581468
148474.203001
-1443057.77811
-6390044.76752
778132.511093
-5744445.24267
6982897.0785
-12872912.9948
4849400.15544
6.27200642743
-6.28990198975
-1308354.09598
-630489.405678
-3401906.13384
-1024791.46954
12017112.1343
6228877.4203
-4631124.98281
5049053.61886
-56777.0686489
56742.4443567
1898297.2287
-4308392.46871
-12889358.4336
155297.235947
560247.988863
-550229.065694
535416.969047
4667768.60451
-8665074.0686
9119096.06645
-5918180.03709
-974769.834375
3712420.62722
-6892629.58623
2166830.40499
8.46748132699
-8.46666020774
-15487065.0967
-8184452.76826
-79986.5420321
79907.9348594
7626401.3171
1761821.87972
6840538.90411
-36610.0749222
36598.2264179
-260240.233981
258544.239907
-148.228895078
148.139793004
6455821.46002
-7461374.95226
-542651.352229
3634259.3669
10506156.769
-25434.4662398
-321589.674904
-668054.921921
676756.803338
-5106.21840685
5114.02460892
15661607.1288
496507.921905
2223537.93201
-655191.266283
-23161.0856286
23166.0188115
154.121231604
-154.112107964
26.3601357951
-26.3415938448
8355506.04835
-12749249.0236
-7820443.7677
-0.955155507739
0.95179181544
-5679864.29432
-5253428.99475
-496.17058162
496.926906738
7568360.51363
5.36744961963
-5.39919454852
20684890.1004
-4041.39941886
4051.30016848
15479728.9076
-188794.57381
190272.968827
-311213.07637
109567.501152
-6653322.62575
-2657477.88212
-5696.7587519
5708.83805148
-6052194.19382
-10780665.9206
3126199.4182
2708602.83785
-1984.57743908
1990.78009727
-4631357.35823
4893670.84826
-314472.730314
-7942717.75467
10530723.897
-938777.414203
-1789798.20448
-559687.932692
-3753099.22015
-6790849.51213
-84.40827066
84.1906747297
323329.150802
-338688.833708
-9955.1002243
9961.95356204
356243.742518
4710359.76295
-2956049.28881
3201461.57832
608042.986688
-2119416.00149
-549006.780723
-17.3210290929
17.2959833176
-2448442.844
119.499120607
-119.574001836
-2942263.70942
6976934.7319
484.554836458
-482.602434959
-637.570456898
639.478670064
2069316.03286
1096507.75683
913624.792057
7892318.82489
18662207.4544
1483.85196166
-1476.44274374
-1552530.78101
8859379.91449
-4666.78878214
4677.00017737
-2524161.09663
2282982.43353
7600511.36813
-3450792.12553
-4137178.01775
-1976646.61281
1139527.69872
-3482148.82829
1913076.22461
-1762596.28097
-18546.9935014
18555.507914
-654496.060752
-5598153.93938
-450.687088752
451.369850699
2992865.44882
-12955267.1279
-451.188078017
451.902032381
-4373900.96075
3941169.59941
-4906353.78782
-6434.36136126
6444.86132884
-9.11405431726
9.08071868973
571244.968123
4971714.31547
12863472.1032
1195620.51054
-838279.436617
851415.549432
9.88066779412
-9.89345491728
986586.359082
4554430.66194
2321233.96724
-365982.806252
364427.96125
4.91104768108
-4.90876639002
-9196467.32846
-213561.75725
212393.296031
-201767.138763
-822633.21876
-1732680.87929
-555.404649439
556.892755245
-13725.5335022
13730.2064472
4991430.96749
1950162.61492
-35789.8565769
35761.8989614
1540652.44431
-3064.24445363
3072.00236448
105.022857232
-105.095715386
6681358.75351
13190335.8655
-16103.9910519
16110.2969671
-841152.881997
-2365597.88813
2541063.64993
3051734.30116
-1540121.30613
-8429990.94321
1396495.14549
-2672202.63305
-9492174.75842
-764.802942528
771.408584886
3824379.30707
-209.355926173
209.462367255
-652755.483666
629536.526764
-1149010.38287
880786.116084
-2416932.96079
-5195.12130734
5205.39020077
-72879.4524601
72782.9467178
8306072.23637
-581.290908394
-6.97607004262
6.95904868219
5824930.91042
-10300563.3405
3452306.08139
5773843.71351
4192793.6319
11465585.1154
4325648.82124
139512.746149
-143361.937695
-6109119.70909
-12883441.4271
-7069870.41722
-20062546.2655
-2078226.07714
7261632.57526
2875442.05371
8081109.41492
-480072.348615
470393.540602
-649479.111238
218657.868693
-224610.75694
7587092.73626
10135595.5047
-3943918.50463
-7821490.55043
3060999.78635
6665520.23829
1179444.76534
-2540235.69286
2488827.1098
6205653.81449
-17519763.678
-2030121.41342
-11480057.3723
-5453680.15596
1825375.56154
-1511074.34482
-721.910190991
724.666427695
25767615.1641
-25614.0743283
25577.6598987
839082.412076
-4014696.74363
2012676.15586
2427266.39176
2604861.53154
-141308.962468
141697.846062
594701.765439
777006.383887
-12329234.9508
-83617.7477352
83473.9769153
-8728063.82891
1265066.63391
2361219.64071
8035114.50371
-3228813.44726
4714547.02567
-14679071.6142
-9607645.1225
-10330728.712
2114627.05696
-86987.8602433
-7433491.61607
-12963.001623
12967.403639
6730644.26002
612881.858492
-618815.82751
-561.555448273
562.672989365
-381.663440907
382.051247586
2975520.56103
-22.8346160777
22.7649653583
589135.496169
-9063047.12559
-22508.905216
22468.6892212
5070268.83234
1162454.52729
-8285.54040792
8292.76740634
52.1100026987
-52.2356329996
-571135.271037
-4205574.66462
-1733.56977556
1739.55524412
-4361217.34438
-12787060.4614
-6333748.02453
-7158406.98139
-3737.57540136
3746.53887062
-6923334.5624
1512.67643354
-1507.39101073
19360970.7921
4776370.44665
-2229167.77644
3987544.56082
-779589.184322
-368400.582051
374451.393077
-8786252.74834
-178242.473556
177598.809627
18763530.8081
-389620.215387
384715.479395
-1168331.78225
-218.437632445
218.583618831
1489028.0382
-195303.860407
196375.224305
711989.365933
2449912.02094
-234.456275488
235.216608601
4962755.9459
-2154212.73708
278787.240595
5957482.734
-2653206.51521
-1936159.95777
-5361171.1243
-2597626.70982
1106009.14184
3277514.58908
6140510.70608
-3789835.63312
-3560548.74665
12473745.7743
3100870.68877
-498.335144143
499.278287068
5219453.67063
-8605095.74041
6225608.45132
1426751.85555
2544733.75919
-35.9405896858
35.8345979194
5977956.80392
4903260.83279
-12.0033728025
12.0032966995
-844541.1645
-339320.075321
-0.0378626482287
0.0378897945057
-347.517639095
348.008027356
-2975042.15594
-3550427.29389
-2386708.54595
6058846.34662
-797.255082011
800.593514725
-446864.314358
-2454365.62108
-8746646.9095
-944265.777499
1793813.20867
-2797782.78521
-8391028.77364
1112982.86014
3674281.02874
5340712.80604
-3360.49804724
3368.84976966
-10017.898942
10030.9593901
-1669690.6487
-11440869.9684
9499423.45185
-1645.50802517
1651.0677646
-352.485219434
352.927563909
-11160773.4195
2798146.28693
-4820022.84815
295208.655436
14.4664265677
-14.5034619178
6809558.66038
168.630030157
-167.941391775
-3923641.42298
-16587.5170616
16595.0402497
-7983905.98314
-1541492.53662
-474949.509571
-18456211.3339
-11246691.717
-359571.698107
306423.738514
-4534.08483163
4542.17874167
1.53602036325
-1.55048141323
8626577.00536
1676779.28643
14553692.4437
-2643082.2796
-741917.309542
11513325.3227
7.86314029819
-7.8574558371
-6146783.61326
-19216123.6845
4011681.48762
148.516978698
-148.579576932
-949.182138365
952.218197611
3611889.62009
4512592.69196
6607386.96075
-2364629.07344
6693205.70343
-91.7437062937
91.5723434267
-5818661.95858
-8565530.60943
-196.665341615
196.694492375
563783.234155
-13621934.7098
-2.02146265664
2.03559384139
-72.0639374878
71.8843231018
1986457.57441
-3458774.78064
1641368.75114
7667986.50337
-7582548.94357
464985.940449
-8380533.95647
311497.832313
5459806.95699
-570370.193568
1636931.32966
-5086750.37264
-275515.021603
279748.596805
191760.296307
9312526.58808
-10583.7046961
10589.9379058
5996066.76682
-2099300.818
288805.417211
129804.927296
-132967.517918
-559027.339666
-2300516.38352
-3270460.93134
-98095.4918813
97947.3689643
-17852295.3683
-3214184.56718
-4813436.63463
7995528.64614
-15660968.0002
-5468382.22303
321.141375015
-319.871857608
-1165585.12595
-14116493.3809
-700.125466716
701.92816521
4569221.72822
-54692.7664521
54696.3952106
-16680362.3754
-10933626.2731
5691188.64002
7159189.99717
-2284673.35047
-3620076.63432
-754383.390362
-4233088.2605
-5475631.98519
7214222.67483
14.0406429096
-14.0535287141
-6406181.57777
5041901.82555
-5839041.6494
9030852.96873
-1179012.66819
-315919.420966
313152.595435
-81435.2276059
81440.909726
69569.3803085
25.6489753139
-25.6857935213
-1762916.94052
-76200.8697313
24543.5906203
3354318.41183
-9698978.24843
-4820441.18842
-34081.1075989
34073.6441347
-1007327.9681
3468738.46009
-7773573.84357
-415740.399726
435540.208882
-6247.13175711
6259.01107922
-1372250.09238
-4225271.47139
-2289373.3569
-7971618.90804
10757701.5934
2.8791081338
-2.87313953458
3621860.5588
-2409391.05879
2770589.85987
12707566.5967
-2.51229788935
2.45128628456
7352565.25381
7706372.93448
464425.23027
-186685.432035
187433.408298
6.45442961504
-6.46389760847
3237492.47928
3033211.53115
-4896670.78079
-12259.1869638
12265.8578949
3909960.41484
-832.833442102
835.336407895
3063134.12743
-1530193.17473
13955382.0039
4135301.12773
2961386.53169
6486827.49453
-447.328194721
448.586122219
3063702.16892
-533.253367074
534.205185109
-2102166.90879
-2293138.82147
226607.884314
-235361.324286
22025899.1355
-588240.978917
-140723.404809
2129608.93047
10235130.2461
10975253.0116
-23557.0546666
23550.0678492
-3478.87418825
3488.35167197
-13528896.3303
31726694.7298
-2751279.25357
-5643364.14496
-6954371.02152
24378234.9304
2815444.38045
-13564.0683773
13555.2325445
-4795687.71356
-28188769.9285
-3977111.28104
3761200.52105
-602694.379396
585287.650538
16654156.6491
6923481.70218
3073420.31197
2990713.61701
26463.680992
1782667.04389
2428614.0692
-62104.3258088
62137.062124
11285280.9885
-1287733.96589
-3758526.76235
-3520682.09066
13520439.2147
-4272359.55931
-165714.104893
165658.143663
-17534249.3857
-208383.034915
-18785833.6126
4976120.40797
93.929457913
-93.6446838094
-11224375.6664
6012174.69455
696106.941614
-4244.21804822
4254.60478271
-3219.80155881
3227.55061072
6741716.68311
5.29074753413
-5.30567938937
-3623616.53436
-5752867.49389
836253.989537
-5407104.33161
-43.5035309608
43.3732020125
-245457.640852
245510.929629
3930453.02162
-3692450.9189
4510574.04287
12480070.3127
-12576883.0489
83631675.3436
29576053.5411
-15592.3669722
15600.6320386
-1221.99666326
1226.09188881
-1685278.88705
4948408.54944
-4646256.50926
24.351664735
-24.35513258
3608468.59134
6697390.66089
-13771.1181629
13775.1543695
-2646310.62724
9127668.52814
-5712216.82304
-108318.281425
108114.40511
-882532.819722
-814785.407733
-21221.2577032
21228.7248863
303561.305999
-312854.710746
-14.5724543151
14.5602160056
1823.06640685
-1817.21888807
-5632138.24085
7685749.17814
4851860.30918
19484017.7487
-665727.668644
-6336450.59984
15789220.7058
-779306.619437
1029.75293051
-1026.23192968
-411.562502691
412.362526643
-846892.09209
800766.298851
-146.070231152
145.87218042
4519210.57651
-10798763.671
18602099.5235
704616.535979
-5332118.46259
359826.058574
-754008.984701
723865.203734
2179429.48475
-1.54622204221
1.54672277274
-1206638.95222
5667670.35067
8322482.66882
-1981.18525585
1987.11752105
1836851.6976
4956850.00112
576898.213239
3940654.69287
8804761.5482
6798166.75814
5386037.09973
21005219.6652
3136616.6443
16880846.7602
2193182.72481
-3719084.44865
-669.426791272
670.80596762
1334293.85161
1528523.35747
-75.7491410812
75.5700799825
-3602133.85417
-853156.186578
-53533.9683292
53224.8928401
62994.0386691
-4956663.90423
-7836160.72164
1090216.03814
-52.5685743235
52.4471754828
-1308584.24766
-3120758.92366
-47229.7977093
10581523.8746
-12305199.8869
-8005896.24092
-3678983.86254
-9992135.6406
-702688.973178
-4519424.68699
-323323.54788
20.8898683389
-20.9256126835
1638.70548628
-1632.79070217
-3454654.74647
-8704836.39808
-633567.293464
-7868381.75034
-1013.63405128
1017.58321153
-7521043.43318
-910348.954639
-21163.0833225
21166.6422627
11.1441312701
-11.0052760743
2766581.24635
-10823240.7082
-10920.3426066
10922.5456141
-3294708.24631
-5575.26247521
5586.75089878
659763.820242
36.2310640353
-36.3217729555
255449.763994
4580734.7195
-1236056.2752
4607698.5301
-4634085.64516
-5634.85376812
5644.94719453
-32099866.9392
-27135.8949616
27129.5021402
1349497.93942
6482146.99193
4247740.31992
14023616.2107
-2243650.28506
-13592167.3275
5533755.43928
14756226.7631
-2893197.40029
-779367.955971
-1766035.15463
843736.485359
586.11415063
-583.833473726
-3054868.02374
4.20365342244
-4.19980149294
-1643601.20084
-538.963275953
541.018750424
-9739351.43338
-23573307.4853
-1035.75621961
1039.58662983
-3012175.21771
1053434.21177
-6963913.24331
-6272830.96989
-0.881534214284
0.878907023563
-15221.565433
15229.1267432
-2990234.42137
-290.739584748
291.068210321
11850592.7697
5284991.32168
205849.047952
4638790.17246
5110306.12208
-1372437.8075
-4656719.08803
-5332092.98023
-961781.330028
3835619.94033
-13867551.0363
2439184.05214
-12219.6314969
12225.1218533
-12767.2477462
12779.2443767
-87255.1113267
87230.4432755
-6911251.95604
3385673.19037
-3146047.51517
16801680.0287
20.6731052173
-20.7022689973
2115799.23159
-3085729.06076
11.5258484818
-11.5823072539
-8385206.19029
-3679989.77558
-362.834651326
363.590612851
-4221454.22476
-5052.56225637
5062.72882411
-400785.391774
395331.148632
134257.230152
-8991882.28096
578222.509531
-1553639.67336
-1363558.62999
164.73108032
-164.142597175
-13368258.0774
-8.04023989565
8.03396213055
10981968.8268
-12434398.7679
-591866.107646
586042.965525
743646.013561
-1305603.88356
-5443185.41404
-27.4155580674
27.3454695961
-561895.803424
566270.272142
6019023.5935
-31849755.5738
-2773060.76249
-169092.086218
167306.79882
-567281.435528
374126.423407
-4217149.56802
-9498232.5611
674765.19559
-40.1774712617
40.079106068
8163428.19116
567156.421243
4457030.80494
-7969632.47711
-98332.514802
98488.4486178
10638817.9087
7125761.20803
5036413.74109
2885143.78017
-916630.752692
1230925.76573
782199.319538
14573716.9785
43849.4740668
-842867.798094
2869396.72979
-811447.442819
2265062.09505
5368752.01597
3535549.38398
-6128227.07853
613158.023271
2284531.1922
-4976914.92961
-14348.7894034
14353.2921468
-2869565.37327
-4198.65302808
4207.3239739
72.1797914146
-71.9657388655
-46177108.6262
-6921071.95765
-1165599.97108
1156517.16075
7101380.57736
40798463.5529
-11515320.4191
-13908.1988345
13887.8496788
-69333049.8354
-12833167.4336
-979402.229116
141813.683214
-42737.9073969
42701.5821681
-3515980.73643
4507904.60041
-4306973.97636
-702229.961989
-6940.02978914
6946.5604852
-2522130.28269
-902595.346198
-3784240.37639
-801.944288509
804.109917041
-4831851.87519
782858.711444
-7581222.22878
-679.32865038
681.617434611
-1029861.52048
-3946034.34445
-3743670.00192
3105766.27614
-12079.2950744
12083.0395883
-2864315.17452
1398643.10591
-3.15264242278
3.15602699261
1763279.09485
7783974.70859
-2695854.79902
-975419.690775
-206.852449089
206.909338731
5328505.57123
-270.035742051
270.17907738
3845234.56113
8459167.82067
10454534.3171
-181475.967701
181678.071889
-5521.85197024
5532.68770019
20579062.2102
-0.737293480379
0.750246733438
-9149719.24738
-4271180.85626
-2565189.81185
264582.555662
-272193.748695
3205269.58321
-320449.806252
323953.056358
-714.499726081
716.129206669
-431.344053827
431.966136694
8454129.96455
3666545.34626
-5368216.30245
1562368.31205
-1380124.44852
10162655.825
-361645.468746
309650.403664
506880.533687
18.8934420405
-18.9391231214
5997924.12844
1313221.34044
4705050.77574
10052887.9904
-1963259.11212
-3063.2483688
3072.18666574
176323.222801
-6323890.80498
-16474339.9844
3884.34852496
-3880.0093375
10428212.2352
12254873.8324
-9953408.89421
5510411.72714
132909.898127
5065243.39942
-4371635.70315
2832702.46018
6269553.49743
-3789679.23926
9700696.65447
-2523655.316
-11476953.5372
-2768938.24931
22698137.1229
-568790.58368
-816300.667913
2.67481993634
-2.68422147207
-5224062.28235
1641994.97075
424685.963788
2583395.70289
-12682570.7411
-1749140.15262
-8139370.18227
-1784321.75933
2099569.1364
-35.2294492857
35.1411919235
83798.8458434
5106574.02959
-17235.716938
17242.8264025
-74180.316882
74126.6790565
4405753.15967
2559265.75447
-67385.4755985
67387.7160331
13355383.5177
959794.928513
-2436464.12105
5889680.1556
-2947936.60264
5676086.10637
8312810.0048
-2913279.20755
2.70629247546
-2.70390885367
-3216522.69852
-1058333.39258
-17802843.8304
-1055576.55898
-5036144.16258
-207390.160261
206536.027001
-488.794216665
490.359272884
1499809.3025
4206516.21097
-22382956.5271
744588.155146
3441068.29721
3402508.88662
-4949343.58081
6449128.17322
3385122.33575
-4774082.73581
-1564481.30085
9842272.35989
-9213803.96871
10459931.3192
-116056.440596
116057.211545
14015570.1819
1977.0688074
-1969.11009311
-2694.72811961
2701.96847509
-5662803.26991
-9543665.09566
-5473888.75072
-6548865.05917
-9221299.47219
13227172.5056
-5275281.34466
-934859.13599
912659.804061
-6232305.66659
15074411.1164
3206049.30435
6625965.49617
-196059.507653
1421054.9973
-15143706.4994
-87.9979985358
87.9111582541
-270282.021438
268131.026067
-1761236.78255
-420757.544316
415916.974323
-6552877.62822
-9378611.68902
11704931.4826
16251924.8915
3362665.94631
-6044120.5562
-356255.403284
354702.079922
-15742280.2769
-926583.637654
-3450394.73195
1473967.54602
5966867.53402
-267733.524382
4679742.46926
-62147.0248266
62026.5817733
-4759831.72947
3937115.45291
256877.624432
-1517.78074423
1522.96272044
-7318339.37192
-2266337.67518
-2279665.61587
192527.843634
-20595406.2193
-3445870.26892
-4881861.98262
5497148.82658
265329.495629
2199625.31167
1644340.00988
-18336723.4331
694164.780555
14837457.4047
-245243.058083
3038309.51659
-2079826.8897
4102252.04238
1057703.40624
-5204310.15055
2640074.70231
-1383695.51023
-5299379.95774
-3106105.31561
14811709.0907
6392754.22389
-103.604223361
103.482014934
8527765.67022
2531455.2914
-2355.98357409
2362.76314873
-111447.192101
1.39272346042
-1.39231618517
2119991.35229
-39.6754509187
39.5560915341
4089719.8719
-2975057.99647
-8881271.68703
3185796.75533
3457384.83707
1469429.90299
3687808.88873
-8343223.24987
2760891.32287
2150024.50469
-9142306.77838
19668924.9501
-533085.922258
-741281.930432
4424459.8261
506382.644449
-8949.66690868
8961.96320888
1529210.88438
3.51758354482
-3.51466547356
7682347.50439
-13726772.8754
7892718.89892
-1628271.31571
109.457976908
-109.523036337
-103863.078827
103974.521443
-4623895.83873
-189008.477159
-8884652.04845
-6635105.48083
4723032.59967
-38664979.8232
0.726618677332
-0.74755671697
-2788584.40372
910795.242359
-11354643.4684
296828.754934
-19157376.6822
2707990.1383
119553.22841
-120718.355686
6630597.1372
1141629.19261
-1958260.17304
-15151.7549436
15155.6268308
-8807514.39206
-8648280.02136
3.8241592747
-3.81565152629
-76749.0060914
76659.3225615
-5759797.07778
-1249707.79723
12739123.7969
137972.428517
-3372447.11291
3179081.43858
5464771.53007
-38743.0840317
38607.5246057
4801560.44581
-2581804.15334
24951335.9812
-4804090.85883
-100608.357474
-6943087.91929
-5479453.49598
-884.83385508
888.225141088
-994554.333895
7913526.03137
121052.879766
-125700.808203
2915830.06058
1184.18256989
-1180.8936338
-9529524.29425
-230.063205121
230.229216604
-6259372.2065
8675070.31527
-2971696.25099
-69192.1602274
69205.9175966
3359405.42783
-62951.0638977
62935.217511
-492560.383285
-5697292.48518
3229403.26295
-185127.252344
184200.31493
-470.704905798
471.639249996
-7076461.24311
-1303250.94907
-1060107.32936
-4412328.13057
5361256.22409
842349.044447
-7299992.22887
-2591344.10218
-4920.20301701
4929.13078168
12579273.3528
-2269250.11307
-1953623.96088
396356.44183
4900574.8448
14412825.7266
-293232.300359
-363756.24074
358053.075753
6006365.42856
-5.81534069392
5.81981826653
-634171.723683
10636974.9788
5100355.9058
-924711.332386
-150565.623946
150319.285466
6421358.70996
-1680199.51289
1905577.86912
6301434.47965
-34.2807197125
34.2142878604
1337054.29995
12465566.4433
19209155.3078
17678752.4435
1435526.71645
193748.941792
-3811984.00281
-242.416155126
242.313375488
2925199.06432
2878821.69467
2645825.47355
4579494.47446
-271624.363681
272040.181066
-2263586.04787
1485240.10251
-5952.35077998
5964.44491732
4637286.58635
525066.218861
3062.37321114
-3053.76374984
4936350.09056
-18582.4591093
18589.2084287
-632574.947096
610011.888147
-5012248.27158
1485545.14079
-239.860943384
240.041179728
-3629164.19241
-2.65961462071
2.66295736903
-3816644.89199
5691607.95631
2832216.32654
-325712.210089
361238.347781
4959338.71253
-2120520.43291
-197036.731562
-7528509.50196
5466547.69641
4035147.6147
-8379528.7828
-5390802.35198
3083881.55119
-547137.772045
-1494527.69111
-8775.29027366
8786.04234386
104.008846852
-104.046187
3637045.88231
2574833.80012
-16350986.47
2692092.16914
-2645241.75075
-362574.70402
1893073.08245
1972207.2159
-9567461.38426
10504655.9557
-82.1972119597
81.9891836404
8336922.57558
1578759.48675
2741.11107688
-2732.8708063
-3738572.69547
-175942.512014
2815727.47878
55.359289325
-55.4240285342
-10322738.7888
6826686.30879
-9839817.14558
-796459.715726
-3377581.80896
-3562689.13368
11048887.8749
-1.20992556265
1.2124677494
-497.849352377
499.21101688
-7823956.09285
-6799026.04729
8324477.14421
11.252819691
-11.2373962401
3847466.51025
5367507.47134
3008092.26036
-40148633.906
-1160783.84454
-2244541.53088
-6346275.75658
7503379.05876
2622318.09996
-392171.231035
3919805.24891
-1708539.7914
7.84685972372
-7.84145922411
-3695.48096698
3704.34091715
7547106.75939
-1700767.67224
1359405.01609
6904286.88916
19652530.0183
15434048.5777
-2223099.548
6958276.05638
-12678887.5466
1126788.08147
-26135.0185041
26118.8943741
2591430.51504
171396.764891
-2629.25565225
2637.74411649
-10116029.2358
804285.764389
-643729.780499
11260045.493
5545787.263
752070.634961
-10551293.6469
3275128.72163
-670118.169734
20231021.6366
517659.442653
443666.510536
-13089794.8803
-3584993.77878
1075344.73959
-1397416.83727
1496920.46414
-7439337.57004
223314.809406
2365310.54402
4614110.59084
2620629.43147
-524052.927008
514328.651739
21288725.2947
-665.317114574
666.645948893
490383.382985
-10245722.9278
-7073.10861672
7085.26731799
-960230.691723
-164956.574626
165292.52384
5231084.76703
4923995.99674
3987621.65948
-8122133.17866
-13705213.4963
19714171.0738
-47809.2970608
47695.9122309
-5017240.5319
96.0115293763
-96.0550011859
-27317107.1793
-4705662.30996
3750724.90115
-39.9722101167
39.8781055588
-1514088.2944
-2904673.40965
-1038617.66869
-983.696602649
986.053300365
-11280834.8235
12320211.9933
11092396.745
6.34591183509
-6.34838426443
-366218.8593
352802.018437
-861873.34913
792034.668643
6822286.79251
-3732818.61407
0.294161462282
-0.322997214924
-8206306.01942
17710538.2522
250456.204762
-2916675.55985
-1484997.71333
-5469795.14732
-17266235.2442
5911177.80042
-2369.95967906
2376.63594157
6452730.8062
2617248.38229
13479668.5775
-15114464.8686
-2793127.91369
10138266.0717
-3845.3200509
3854.99388216
112811.328832
-4336783.91958
-1056328.27926
-2635327.03002
-3867043.47374
-12385670.134
2597756.67012
-4089499.07805
-6934772.74563
2668650.41436
3546178.68265
55372383.3042
1471627.76278
1676067.809
2658241.03759
4683721.34417
-2576215.17423
-4460669.83153
-1297601.99284
2517630.75999
-21571087.0927
1545034.24609
5889713.66626
3.9665792474
-3.97039367294
76.2801962255
-76.3045681394
6651389.77896
15208688.0122
-1082275.05082
-753547.288355
-1629471.62307
-1395296.32927
-6479501.47125
25773231.8175
101065.658484
-103093.05721
-41973.680108
-2649962.49907
-2449126.53282
-10211292.2025
-19400702.5092
1468793.30134
105592.081784
2722267.0415
-623815.051734
929714.444909
11249979.9529
-9577078.84215
-7094411.40845
18058159.5351
-687914.700153
2852710.98058
9052562.49396
1752671.87859
-402335.634567
411931.742024
10758685.2683
-12086230.013
-4238.95384014
4248.55446547
-1004907.1988
2206.16918477
-2198.44467042
6853889.14415
-797094.182448
779593.790013
11927715.7806
933841.570559
1219749.1319
-5803579.31561
-16653.9436903
16660.2776398
-11063673.0975
-4113894.38249
-4388125.70653
19.5608932326
-19.6152192097
-2750821.91226
-7981272.82518
6474522.90736
1.35415011988
-1.33688380219
-1469961.63293
-8652220.79653
2821.04108238
-2826.45855883
1372813.63283
0.667110952274
-0.662786840007
-1311349.69227
10907869.975
-12110.2166521
12119.2425236
-5011895.98963
6.99900464022
-6.98267613207
16475807.449
-71.6949091809
71.5342653836
-1338178.32653
1593176.99331
-2151189.77405
-4963363.44447
-11001.9554968
11005.7665599
-2001094.79885
-12814251.1969
-7738479.10674
870.522079375
-863.218707092
-3445711.00541
532776.407112
-8009466.20702
-10137236.6921
-6574941.42187
2279949.34799
-539986.939168
-3326986.71018
335848.753697
-1962139.37653
-184974.179523
184522.66681
438.798179428
-436.541891718
8316932.28764
-939257.704852
-10965112.6557
19.369931743
-19.4514130864
-10014714.9044
-2428854.5814
180537.351307
-1343032.8524
184603.987272
-202107.809574
1657648.28164
2471744.33646
13581176.7153
-3534584.55109
1939972.62497
2604648.96864
10533560.9712
-2209.44989544
2216.09198686
3225628.14166
-6842765.09331
2300729.55855
4122986.8506
20648750.9305
-522722.081529
-1184379.03642
-489579.396106
4617526.70358
-1373696.84764
0.414058008215
-0.413790849079
-2033565.37864
-5903479.31977
-769954.541851
896916.344262
8875953.95015
-229.896618428
229.847851085
-3226259.52755
5.41388765651
-5.42040658884
-2069687.52857
-6952046.25289
-1386559.61202
-11362221.7634
7624355.56491
-10019663.2002
-1300348.21121
2552573.16
-616321.696397
6070660.07163
-240842.40624
-3369475.55647
-3005816.07807
-3766186.56428
-2367.25829757
2374.88242757
5651214.2072
-16490918.8201
-31.5472984022
31.4770158668
-68782.9228711
68721.5163236
150.439709711
-150.50169461
-3042385.10538
3355873.13167
-6919237.56165
1091287.00515
-6695365.82808
-1528010.16809
-5774112.23339
1125784.53464
-291.749274068
292.019590107
33066.5819206
-33261.0503553
2194538.75526
-1927039.24564
-2622201.57219
2299273.3818
2824664.03669
-1880496.4439
2159191.7019
5861799.80088
-5132882.39367
5165885.86808
-3.9210911283
3.90505016261
1052.78638284
-1048.12358804
163952.725044
9955359.02413
4917984.92917
-2881604.16542
4.40074115121
-4.38461434918
15.8327547519
-15.8705419887
-4962741.30758
-3003972.68151
2690782.27196
-2550359.27991
-1080976.62216
-9089595.15286
7383678.16635
-2549041.10321
7929141.24975
-3131890.13399
-4323625.25594
-2813134.93766
4700585.6724
870144.140854
-7588620.96747
4513775.18506
1027259.1236
-6106489.57085
102780.597643
-104542.58585
892706.512889
12078439.8212
-1028130.86629
-27225.6196081
27156.0797264
4426602.41501
-4493793.75849
1545824.44648
-8.28320376514
8.27694669085
-13940641.1377
-995.241871925
998.319186089
-48528.6238738
48535.1806543
-1088088.9289
-4468680.79709
6344309.28784
-1824778.46627
-1277483.30708
-55959.0513617
55892.1489774
-4946453.40927
1912332.77005
584432.721618
-5739226.62485
4788318.0219
-1750965.16698
-5832301.61669
-2837.88806363
2845.18410602
30.7306863581
-30.6748263008
431493.208141
-1015888.88469
1042612.20583
816241.654299
2622009.91256
5798072.4673
3530775.84022
-34644572.1981
-292.197116848
292.48696354
-5975193.52111
1635.47005746
-1632.8568277
-4218481.8784
-13739149.5672
7137958.53819
2467275.07442
-7242551.52527
94.7393252533
-94.812442252
-649771.265383
-19.0856063616
19.0301408529
-2911510.94656
-973.412691308
976.144324305
-1942910.97734
-7694.35468043
7703.52247391
5166114.56635
12.0282485137
-12.0440499449
-2035236.11632
-548.173410106
549.987444241
-1357083.37098
-0.419351199754
0.426316536609
-73743.1690624
73656.9049841
-9510435.37528
3558342.46501
608156.884122
-293242.767347
291423.560178
-12412771.3783
-2.12768614527
2.11098435828
-6526968.48829
-1848348.46256
4708367.13898
-3905383.93407
-102.381264737
102.170704776
-122495.256624
-5752657.31313
-4477161.39309
-6681512.32781
-565.368459088
567.505795448
-414604.359757
464753.071796
6583176.39032
-3025410.45362
-3531926.46165
2978763.01635
1675.39433546
-1669.28840513
6827457.25778
-2816.71117492
2823.96263529
-50.2810165125
50.1829680272
-3662.94804144
3662.90834028
7158272.52572
-1773871.52804
-26213081.2141
1.08905867395
-1.0831308474
-6.72131698657
6.71764221025
-10667470.3367
-5916216.8738
3966405.47354
-5682.09929203
5693.74194637
-3155063.23275
3343889.57572
-1355188.1697
-2587906.00345
763362.023927
-296397.919478
302669.08885
3115.95813974
-3107.37988245
507.128812272
-505.035919792
-1321768.49855
1391741.30016
13213441.5144
6458970.23395
15722815.8513
-16769.1747099
2957852.01763
9853635.1999
14092213.2769
2426351.37596
-6643932.46959
1691815.55319
-9885.59373067
9894.32139327
3805453.58725
494609.15472
-9932282.28143
26095180.2929
2891.18736541
-2882.17527933
-2048477.01672
1675366.85004
79348.4737179
-80010.6163569
-7798288.68451
-2533.18151047
2540.01319469
353760.793717
-731.638468539
734.494599263
620611.735683
1972461.45095
-3651381.65724
-9.98807758498
9.98653263993
3008686.31557
-16.4040235241
16.3728085031
2387672.76098
-10712.9003858
10718.2744838
-5264521.35659
11011942.4281
-10400511.1842
-4662737.18002
-2897574.33379
1040846.96172
-1359841.21669
12.7501524822
-12.7622936486
2457867.71499
-6802073.73963
17050712.8121
-246459.221772
245382.382446
-256.219389309
256.357670443
-146.312602775
146.20817677
10327837.9821
1238915.29501
-2823084.99106
34976526.0292
-6479.51530692
6490.99713994
22343756.0828
4596597.78152
-565320.051837
-6941533.08447
-5574632.26607
-2542360.94306
3308140.77525
-1456697.76685
-2391388.34801
-711772.391173
-5576803.00976
-8860.33459312
8856.198416
217492.459573
-1715.775162
1721.68559555
-110673.021458
-2028967.53044
-761438.191248
7945505.90303
-78799.1412988
3698539.65392
-5825061.04301
3537410.75038
3418597.9068
48193.368517
-49120.2097949
6378043.25758
-1900149.14402
-3083511.6458
10354.8601297
-10796.2171036
-4879313.07574
7404887.88509
1470071.95471
1833235.66442
-250.624940627
250.798077805
5757050.3107
-6632733.90454
-808110.635548
8459395.59409
-2908327.00196
-6942.81725143
6950.43837289
-61.9983024574
61.8107568468
-417.561838178
418.18765779
3221404.11152
-4041143.29722
347888.398035
-367018.062364
-195054.755643
191697.855397
-7720819.09869
-22718.6489622
22719.3303505
2389950.83312
7791897.52416
-5238.77859732
5249.15147782
-734662.443954
-4.44812281765
4.46291480672
-4461548.08146
-12546217.4148
-6457.27978405
6469.28766441
32122930.9051
9492141.07439
-2447210.91913
-1054885.73075
-4635016.63953
3334867.34645
-69.853592708
69.6880898261
-1898.64474807
1905.09800662
500825.345985
-162.380293224
162.308035733
-3870708.71027
-5933595.60602
-1718283.86576
2665194.68637
-7629.01574182
7639.6732528
2409756.43522
743913.013491
7110106.42974
-9913032.27824
-3451463.58036
-547433.295731
1145198.14689
-1767147.88738
-1657360.86233
2452346.02246
6717012.84386
-12122826.046
7774865.54533
13.5423383247
-13.6151675675
-3008481.77365
18.199052377
-18.2864815056
-3841062.19578
13.663641085
-13.6743868287
6321402.94778
15636835.5629
16105615.5104
-6651699.99375
3.79180586712
-3.81234251023
-184.814198664
184.761517638
-3050450.24336
-1189372.69806
-4571014.92536
93.0306732535
-93.0663592036
10834266.5055
166473.217299
-21972243.2036
-15357.0005846
15354.6684086
-75250.5774129
75201.8785967
85100.0016316
-87261.1778739
-13.2475894203
13.2212831486
4427637.23346
1973126.23318
-92.4696634263
92.2781833487
4358381.1671
10632789.5051
-861231.856863
-2150606.19115
-1107559.95819
-590217.978002
-5056957.94757
-1742.29387179
1747.99806853
-1067782.32974
4676551.99718
4086941.19366
1817284.39946
887521.07898
-171391.892377
1399680.05246
10209280.0582
8.10377135557
-8.08700161425
749913.634246
100886.923814
817.680865844
-810.718143392
5090845.45502
689677.206339
1168715.41731
-1440389.46413
-3913899.75436
-912497.704519
-3080238.71176
-2356366.97676
3982807.36321
-673942.483887
21424314.1309
4026932.6583
-4369.65857688
4379.19056585
-1147.07161363
1150.83621854
3592943.53227
-1360034.40564
4746748.21137
-2630254.96128
-244789.855574
-1336.7658768
1341.16337741
4163222.11781
-17.4684826976
17.4296428619
-11428924.859
-4682857.53527
7120163.02324
-7138461.22833
-5581869.9159
-73632.3001607
73565.3992339
-157545.183571
157389.628266
-32.2778123903
32.2102524581
6591588.95345
-844806.67387
-89.2649635774
89.0419129813
-18845.4414861
18759.3786578
-167268.178915
49.6908095193
-49.6774409803
2337017.30916
-2161063.93879
-857596.549538
-836642.692891
9774664.22709
-5582869.36469
-4358106.36574
-4992517.37533
-1343.75988568
1348.2620253
-1432325.94556
1826768.03707
-195124.803191
194946.66478
269193.755393
-282024.6664
6534121.50924
12377655.058
-1377417.06681
689431.2412
3294876.7355
-1480720.23221
212181.773007
4636514.19328
-4245881.04089
-6397.23174599
6406.03320779
2494250.49866
-3159818.4418
14963291.7202
29061888.432
-8142457.27975
-794.001282934
798.512561652
1.15215806827
-1.15237632045
-2675.93082805
2683.30712538
-20525799.716
-80.8452238083
80.6817882297
-4012398.89456
-2736127.64213
0.58089941218
-0.578506709393
5698797.30461
-6366576.52277
-4393816.31564
-7714243.74815
-2792.72278914
2801.67769472
-569499.20439
3745660.87568
-2911385.75444
-7513486.10171
12784819.5375
3875440.52257
-750475.252363
85.8459015089
-85.5741836118
6730963.84057
-4387720.79556
-2414176.52377
341210.125883
-322714.477602
-1040.07388134
1043.12641
2366503.8945
-5014196.44701
1142192.3801
-11433231.6381
-80655.2099234
80640.8069718
-3975.91302646
3977.74423172
-550676.460076
3127796.9506
78.7213523619
-78.7622209476
2758952.12856
1950421.54707
4896179.27951
2045461.68742
-199.791046813
199.914719019
-24896374.9783
941061.175959
-27.0472861126
26.9939390877
6907832.4992
-33174.0256154
33181.7106598
-224447.370117
224873.969986
-1197065.86883
-2534917.00823
-19.5766546308
19.5369798587
-2515777.75566
-40.8359376432
40.7415504173
-12830.9780058
12839.8446014
-1322472.0761
1203669.53532
-1211720.88579
3655232.3205
-11446606.3615
-6664372.54673
1298002.01107
-86436.4469939
-214232.363282
1234312.29017
-10667229.7236
8932506.43943
247.941639039
-246.919274076
6464257.61277
12978984.1416
-45009080.2661
-4670261.41952
7067176.23052
-5340052.01053
-11498610.9682
2009771.83048
-19.9637108306
19.9280553237
3047914.57034
-989227.318934
-5003530.73605
20.4270566876
-20.458165748
-791823.544664
-72972.1871215
72918.3601816
-13923498.7212
8095151.52056
-19406.5424295
19410.5758194
-21.4830884184
21.4496855199
7.31977109551
-7.29369932346
-5818045.74594
90.4311591373
-90.379251493
6495453.77603
-173210.898807
1952417.49524
-3342945.49862
-3110367.33738
18437859.2645
98.2388036063
-98.2228290917
3279771.30952
1999189.31418
2263149.85426
-2744540.28332
-9620937.15445
-796715.250821
-6073789.84517
4002456.90674
-3763950.82572
-49.9193887038
49.7730641865
10555475.4489
-2339535.85376
2034631.98021
-6863474.22307
5824378.21991
-23763753.5382
4164242.63983
-3111.01897818
3120.29619624
11133033.6303
-14707.243755
14715.4684933
549825.979461
6102520.50948
1503329.26192
-2127858.32475
1575468.28412
-1689573.11551
-1607088.92035
4049113.03577
3979140.05723
307794.384096
-4149742.53529
-1108484.30659
-4597925.68786
1987129.84542
-11312.7938667
11323.963876
4635468.71694
-2311527.3198
7233991.94466
1295.39621811
-1291.17750656
144.357844289
-144.411600578
80.7191175246
-80.7507326313
50927.244228
-208362.421536
207443.895842
-277630.176617
-12406355.7468
-3660856.02112
-2907023.07278
25410141.4356
-5910436.63614
-1458769.14389
-1.48140274863
1.47786367789
-15250411.9002
-7355364.87314
3198266.62237
-13121327.54
-4965762.0612
-2283.04347619
2289.45079387
-15971326.5545
-5995111.30262
5456589.07799
2965226.37166
794193.091792
1230313.03061
-1124221.39105
-1643239.11776
302849.386234
-5465106.94576
6051866.78898
12092915.5999
5079794.05143
-1226.44088344
1230.39962435
-9930771.77742
514296.978761
-511632.726958
9115342.06398
11806370.4938
-360608.425591
20.9813299741
-21.0113392789
-23842513.022
6740297.51778
381773.640613
-1922329.41822
-60214.8246218
60186.0834112
-4385894.13417
-812493.210162
-9050427.43689
1681641.16304
-267898.308948
8034399.18116
-304622.140631
3394250.45731
-3564.29845836
3573.4351602
3401860.86019
1825.80875643
-1817.61272425
3114413.52109
-3511416.02649
228.299310525
-227.607407907
10974121.9479
8291050.19934
-332422.080297
2429377.47036
-3666541.64388
7332827.55221
8355734.60046
-1690534.51571
-670815.553825
85.1950699783
-84.9007758257
-1331711.6267
-7255230.42595
5392111.92917
4428630.67734
-3211353.23594
752385.331442
-2415083.47839
8127.02766171
-8137.00933604
24753688.7881
-965956.437037
361349.646605
1593645.40756
-1924881.82107
-1729365.65558
270573.528016
-273468.340011
2593824.28631
195239.326034
11861839.0834
-28344.0888403
28351.5430519
-546253.20601
-3006285.48749
4099504.42047
-3461210.02051
-154039.912816
-32502078.4591
1936390.56882
-962048.709013
-36.4609314626
36.3821900933
-459453.783765
195304.106036
10105360.8329
1788363.87254
-2515481.36903
-6824052.6887
-1377746.29907
19385.8130772
-5931097.80728
4844080.04047
2575620.93171
-4866933.44675
-215075.262463
214230.560605
726826.517133
1561.19222059
-1554.53928262
-6075.01258789
6078.59330164
-910117.234196
1841749.33168
52407.2998027
-125711.532098
7667083.16623
72.5447729393
-72.523277232
-396430.292437
7764512.367
-630047.504113
628444.005276
3349501.05264
689813.963626
4078043.38763
6846555.26355
-3104736.36635
-13284.1767526
13290.7039123
-2141569.01557
5119296.11882
-1348575.62547
-13198669.959
-2255136.67248
-1697768.58065
-1321.0901908
1325.5835345
12174358.9281
-2864787.53866
-2700807.67061
3448326.63893
-813696.696021
4990206.44974
3520077.31953
5915905.18557
-7815596.51044
-78534.6920098
78495.9654118
1249190.7791
-3496680.78942
3948104.27954
804095.760914
-982444.702911
8610130.89263
8179305.19379
10.9069176622
-10.9143279449
-3590741.38869
977643.399645
-1495041.86737
1474694.92701
-3091753.9848
6765536.17829
5572185.91459
-1009811.6806
-22702.1900348
22707.888059
-3948606.64598
-11685045.1643
6526239.30133
-4217088.24801
997119.446949
742492.942688
-1011928.28148
2670888.89507
-907.00479867
909.745768527
1415.95598784
-1408.86807666
11987772.9811
15.5203804673
-15.5408712202
-1044501.02545
-10846816.1045
-951354.594352
-1569473.73973
3651165.34401
3056762.19696
-124241.042806
121415.048465
8745404.8033
-462242.526356
468516.226014
10347973.3372
71.9440447841
-71.9342607424
-5402648.7617
-17860335.4878
1281.9530648
-1277.57058861
4248544.13267
1181.41256513
-1177.31040823
3549354.36673
6200838.25119
-1595396.47079
49154.6195178
-49439.1479693
11969951.9978
-1495866.18054
6019734.18936
-11832575.2884
781.436451485
-779.351648943
-9984556.45161
16.9047675024
-16.8780117364
-10946529.7214
892187.865116
5364404.45524
1926765.36838
14334995.6807
-10706978.9252
13210.7918726
-13288.5304587
11585412.1013
-153.023110947
152.784073979
12306626.9516
9939325.77899
-2504130.89514
496553.845482
-6976425.86034
-22.1231227743
22.1164512999
-5614018.87781
197985.794015
12.7811766402
-12.7933825246
2249.13895837
-2252.04971196
5699362.74037
4074842.0871
-7429507.18421
49.0097207968
-49.0118749884
-12.8628945868
12.8760595805
-582.056267211
580.071820687
19874.9244086
-21647.0085812
25420.2550747
-25469.9769219
-12038904.8341
1401.29580047
-1396.05563811
851.910452346
-847.542919839
-12675792.9923
6507495.64498
1978182.06496
4590548.38366
25.1252846481
-25.2187242574
44257.1947614
9550172.09842
20452.5393381
12183825.5306
10948134.0115
207205.919334
-378092.829156
-3342739.06775
-3724.30698845
3721.44172316
167362.107307
-170956.940095
-5.17185375597
5.15219552205
-1448467.32727
-3647618.39835
98578.5397718
-99689.7777429
9167.80197251
-9165.77552597
-13421615.2923
612856.818164
394900.884817
4218.77236124
-4228.03327957
-537228.86652
-2684967.96718
-28566.0549008
27981.8427207
-1150.48364025
941.411728613
18.1072473026
-17.9468341844
748.074678869
-745.962189653
2149838.89555
-37.7038345151
37.7154907631
-223.6658261
222.938005213
-868.956848669
866.312956895
3931055.65286
293.399502627
-292.479714188
5110.81156792
-5110.31229204
-363423.623287
-9301673.61111
-533544.592733
-7950546.89433
-71242.1829593
52063.8032053
199.489218799
-198.674580399
9202951.84695
164698.709804
1930240.95982
99.7070460177
-99.5177571619
-7.84934116262
7.83303729214
-3.63955954174
3.63134716001
-15010.3113846
15017.4447075
7791274.72935
-3988760.57036
24169.2989953
-3304.19801689
3303.75620275
16.4769022217
-16.5448954098
-1.17453150374
1.17433689475
-2040612.51622
-10137337.9501
11953453.7275
1106863.64671
5042677.35763
1529100.93466
2023308.13887
7.908254908
-7.89598702782
-4603314.49475
-2736632.42233
143257.506756
3478.7072486
-3493.38636382
-5910421.50571
7150140.12427
13186214.4367
6472502.01455
-4897150.31023
-11.1660183618
11.2379383991
124470.855908
-133769.995809
-3.9903415138
3.98421374776
7.74754072983
-7.76307147462
3145874.65484
562253.626689
)
;
boundaryField
{
front
{
type wedge;
}
outlet
{
type calculated;
value nonuniform List<scalar> 8(2.26862919348 -0.133121898608 3.07882474287 -1.87521852074 -0.881534214284 -1.20992556265 3.9665792474 1.17433689475);
}
inlet
{
type calculated;
value nonuniform List<scalar> 8(-2.27004492274 0.123772874895 -3.08123063279 1.87308115214 0.878907023563 1.2124677494 -3.97039367294 -1.17453150374);
}
back
{
type wedge;
}
topfluid
{
type calculated;
value uniform 0;
}
SiNxwalls
{
type calculated;
value nonuniform List<scalar>
166
(
-44804.6634054
44780.5651516
7192852.15029
-1468.15738493
1473.26184036
-133.739660051
133.544597376
-1628.11645823
1633.57632148
0
31129588.1424
0
4901316.50762
-20587931.096
0
-9173.23460089
9183.78425701
-3568610.06662
4251307.47466
-217.002150749
216.973176958
-18.8620678086
18.8302706655
0
-26181.5857899
26182.9692741
0
0
-5602460.85166
-290123.194099
288072.218369
0
0
0
-570773.822856
557996.463659
-13845389.461
-112820.654302
112646.120976
-4536921.42197
-66979.4167021
66904.6702492
0
-1742179.28026
-4.72909321559
4.72547665131
-27.1151112673
27.0430018752
52667595.5917
-96.1694622276
95.9665768917
-1548.26485339
1553.55406352
0
-65.2916409101
65.1034107297
2825269.88368
-140.87562134
140.769809799
0
0
0
-124101.986597
123843.354384
-2495941.77352
-1020.1445109
1023.19747594
-1150110.10451
1266908.3572
0
0
-22223963.5188
-14653.4381379
14660.4465857
0
-339701.439365
335890.073224
0
0
-6331204.73921
0
0
0
-5106.21840685
5114.02460892
0
20684890.1004
-9955.1002243
9961.95356204
1913076.22461
-451.188078017
451.902032381
4554430.66194
-1732680.87929
2541063.64993
-652755.483666
629536.526764
-72879.4524601
72782.9467178
-14679071.6142
-4361217.34438
-3737.57540136
3746.53887062
-178242.473556
177598.809627
-35.9405896858
35.8345979194
-3550427.29389
-352.485219434
352.927563909
0
2990713.61701
18602099.5235
0
-27135.8949616
27129.5021402
-8.04023989565
8.03396213055
-31849755.5738
0
-4198.65302808
4207.3239739
-46177108.6262
-1165599.97108
1156517.16075
-42737.9073969
42701.5821681
-2522130.28269
-270.035742051
270.17907738
-714.499726081
716.129206669
1562368.31205
0
-3063.2483688
3072.18666574
10428212.2352
0
-9543665.09566
-934859.13599
912659.804061
0
0
0
0
14811709.0907
-39.6754509187
39.5560915341
-8881271.68703
-15151.7549436
15155.6268308
8675070.31527
-185127.252344
184200.31493
-470.704905798
471.639249996
-7299992.22887
-363756.24074
358053.075753
5100355.9058
0
-632574.947096
610011.888147
0
10504655.9557
6651389.77896
)
;
}
}
// ************************************************************************* //
| [
"soumya.paul.deep@gmail.com"
] | soumya.paul.deep@gmail.com | |
966de4c908e5e2079ad80e4eb195c86f5e2e0836 | a1809f8abdb7d0d5bbf847b076df207400e7b08a | /Simpsons Hit&Run/game/libs/pure3d/tools/plugins/maya/p3dDeformer/expressionGroup.hpp | d3cc7b66886756af5447b27c059811fe0aa49266 | [] | no_license | RolphWoggom/shr.tar | 556cca3ff89fff3ff46a77b32a16bebca85acabf | 147796d55e69f490fb001f8cbdb9bf7de9e556ad | refs/heads/master | 2023-07-03T19:15:13.649803 | 2021-08-27T22:24:13 | 2021-08-27T22:24:13 | 400,380,551 | 8 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,981 | hpp | /*===========================================================================
p3dDeformer/expressionGroup.hpp
Copyright (c)2000 Radical Entertainment, Inc.
All rights reserved.
===========================================================================*/
#ifndef P3D_DEFORM_EXPRESSIONGROUP_HPP
#define P3D_DEFORM_EXPRESSIONGROUP_HPP
#include <maya/MPxDeformerNode.h>
#include <maya/MNodeMessage.h>
class MObject;
class MTypeId;
class MStatus;
class MPlug;
class MDataBlock;
class MItGeometry;
/*
An expression group is a deformer that operates on a mesh.
It has expression states as inputs- multiple states per mesh
are blended together.
This happens in the deform() method: an array of states are passed in.
Each data handle is in the following format:
0th element- weight_value
1st element- blend_stage
2...n*4+2 element- <vertex(i) index, vertex(i).x, vertex(i).y, vertex(i).z>
where there are n vertices in that expression.
Each vertex is multiplied by its weight and added to an accumulator, per blend stage.
Then the accumulator is divided by the reciprocal of the weights.
That's the average of all the states in that blend stage.
The geometry that's passed into the function is moved by the calculated amount.
*/
class p3dDeformExpressionGroup: public MPxDeformerNode
{
public:
p3dDeformExpressionGroup();
virtual ~p3dDeformExpressionGroup();
virtual void postConstructor();
virtual MStatus deform(MDataBlock& block,
MItGeometry& iter,
const MMatrix& mat,
unsigned int multiIndex);
static void* creator();
static MStatus initialize();
public:
static MTypeId id;
static MObject states; //is an array object containing output from connected expression state nodes
MCallbackId cbRename, cbDelete;
private:
};
#endif
| [
"81568815+RolphWoggom@users.noreply.github.com"
] | 81568815+RolphWoggom@users.noreply.github.com |
a39b4f61b2a6e4d3ae8e2e2287f29f78b6234ecc | 9ccc4359f3a7c242cbe6bbd410f267af16d2deca | /unset_ith_bit.cpp | a48bf7bad0627e0ae8201dd22a0f0288943d5c89 | [] | no_license | anuragpratap05/C_N_Bit_Manipulation | c7f36606c7104db1847282edf8d1cc43a9ce3413 | f114a584ca66bc797d168c963d9c12567f118dc4 | refs/heads/master | 2022-12-22T18:22:46.885004 | 2020-09-26T17:30:42 | 2020-09-26T17:30:42 | 298,602,717 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 341 | cpp | # C_N_Bit_Manipulation
int turnOffIthBit(int n, int i){
/* Don't write main().
* Don't read input, it is passed as function argument.
* Return output and don't print it.
* Taking input and printing output is handled automatically.
*/
int z=1<<i;
int y=~z;
int ans=y&n;
return ans;
}
| [
"noreply@github.com"
] | anuragpratap05.noreply@github.com |
52b17ab6dc6af83bd91ef212d63db1e2c2ea49a5 | b0b96f7c89b458f7fe6a7f2feaf8684992a48c26 | /src/test/DoS_tests.cpp | baa85d594132aecf48dad9922c92932da3f6ae61 | [
"MIT"
] | permissive | straks/straks | 28cf4ba40db492df7a59110e77b615727c17cf26 | cbb43f453231aa71a991249f61d3f35fe1503a1e | refs/heads/master | 2023-02-09T00:02:38.845280 | 2019-06-15T23:30:15 | 2019-06-15T23:30:15 | 110,913,987 | 68 | 53 | MIT | 2018-05-31T13:46:09 | 2017-11-16T02:45:14 | C++ | UTF-8 | C++ | false | false | 7,257 | cpp | // Copyright (c) 2017-2018 STRAKS developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
// Unit tests for denial-of-service detection/prevention code
#include "chainparams.h"
#include "keystore.h"
#include "net.h"
#include "net_processing.h"
#include "pow.h"
#include "script/sign.h"
#include "serialize.h"
#include "util.h"
#include "validation.h"
#include "test/test_straks.h"
#include <stdint.h>
#include <boost/assign/list_of.hpp> // for 'map_list_of()'
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <boost/foreach.hpp>
#include <boost/test/unit_test.hpp>
// Tests these internal-to-net_processing.cpp methods:
extern bool AddOrphanTx(const CTransactionRef& tx, NodeId peer);
extern void EraseOrphansFor(NodeId peer);
extern unsigned int LimitOrphanTxSize(unsigned int nMaxOrphans);
struct COrphanTx {
CTransactionRef tx;
NodeId fromPeer;
int64_t nTimeExpire;
};
extern std::map<uint256, COrphanTx> mapOrphanTransactions;
CService ip(uint32_t i)
{
struct in_addr s;
s.s_addr = i;
return CService(CNetAddr(s), Params().GetDefaultPort());
}
static NodeId id = 0;
BOOST_FIXTURE_TEST_SUITE(DoS_tests, TestingSetup)
BOOST_AUTO_TEST_CASE(DoS_banning)
{
std::atomic<bool> interruptDummy(false);
connman->ClearBanned();
CAddress addr1(ip(0xa0b0c001), NODE_NONE);
CNode dummyNode1(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr1, 0, 0, "", true);
dummyNode1.SetSendVersion(PROTOCOL_VERSION);
GetNodeSignals().InitializeNode(&dummyNode1, *connman);
dummyNode1.nVersion = 1;
dummyNode1.fSuccessfullyConnected = true;
Misbehaving(dummyNode1.GetId(), 100); // Should get banned
SendMessages(&dummyNode1, *connman, interruptDummy);
BOOST_CHECK(connman->IsBanned(addr1));
BOOST_CHECK(!connman->IsBanned(ip(0xa0b0c001|0x0000ff00))); // Different IP, not banned
CAddress addr2(ip(0xa0b0c002), NODE_NONE);
CNode dummyNode2(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr2, 1, 1, "", true);
dummyNode2.SetSendVersion(PROTOCOL_VERSION);
GetNodeSignals().InitializeNode(&dummyNode2, *connman);
dummyNode2.nVersion = 1;
dummyNode2.fSuccessfullyConnected = true;
Misbehaving(dummyNode2.GetId(), 50);
SendMessages(&dummyNode2, *connman, interruptDummy);
BOOST_CHECK(!connman->IsBanned(addr2)); // 2 not banned yet...
BOOST_CHECK(connman->IsBanned(addr1)); // ... but 1 still should be
Misbehaving(dummyNode2.GetId(), 50);
SendMessages(&dummyNode2, *connman, interruptDummy);
BOOST_CHECK(connman->IsBanned(addr2));
}
BOOST_AUTO_TEST_CASE(DoS_banscore)
{
std::atomic<bool> interruptDummy(false);
connman->ClearBanned();
ForceSetArg("-banscore", "111"); // because 11 is my favorite number
CAddress addr1(ip(0xa0b0c001), NODE_NONE);
CNode dummyNode1(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr1, 3, 1, "", true);
dummyNode1.SetSendVersion(PROTOCOL_VERSION);
GetNodeSignals().InitializeNode(&dummyNode1, *connman);
dummyNode1.nVersion = 1;
dummyNode1.fSuccessfullyConnected = true;
Misbehaving(dummyNode1.GetId(), 100);
SendMessages(&dummyNode1, *connman, interruptDummy);
BOOST_CHECK(!connman->IsBanned(addr1));
Misbehaving(dummyNode1.GetId(), 10);
SendMessages(&dummyNode1, *connman, interruptDummy);
BOOST_CHECK(!connman->IsBanned(addr1));
Misbehaving(dummyNode1.GetId(), 1);
SendMessages(&dummyNode1, *connman, interruptDummy);
BOOST_CHECK(connman->IsBanned(addr1));
ForceSetArg("-banscore", std::to_string(DEFAULT_BANSCORE_THRESHOLD));
}
BOOST_AUTO_TEST_CASE(DoS_bantime)
{
std::atomic<bool> interruptDummy(false);
connman->ClearBanned();
int64_t nStartTime = GetTime();
SetMockTime(nStartTime); // Overrides future calls to GetTime()
CAddress addr(ip(0xa0b0c001), NODE_NONE);
CNode dummyNode(id++, NODE_NETWORK, 0, INVALID_SOCKET, addr, 4, 4, "", true);
dummyNode.SetSendVersion(PROTOCOL_VERSION);
GetNodeSignals().InitializeNode(&dummyNode, *connman);
dummyNode.nVersion = 1;
dummyNode.fSuccessfullyConnected = true;
Misbehaving(dummyNode.GetId(), 100);
SendMessages(&dummyNode, *connman, interruptDummy);
BOOST_CHECK(connman->IsBanned(addr));
SetMockTime(nStartTime+60*60);
BOOST_CHECK(connman->IsBanned(addr));
SetMockTime(nStartTime+60*60*24+1);
BOOST_CHECK(!connman->IsBanned(addr));
}
CTransactionRef RandomOrphan()
{
std::map<uint256, COrphanTx>::iterator it;
it = mapOrphanTransactions.lower_bound(GetRandHash());
if (it == mapOrphanTransactions.end())
it = mapOrphanTransactions.begin();
return it->second.tx;
}
BOOST_AUTO_TEST_CASE(DoS_mapOrphans)
{
CKey key;
key.MakeNewKey(true);
CBasicKeyStore keystore;
keystore.AddKey(key);
// 50 orphan transactions:
for (int i = 0; i < 50; i++)
{
CMutableTransaction tx;
tx.vin.resize(1);
tx.vin[0].prevout.n = 0;
tx.vin[0].prevout.hash = GetRandHash();
tx.vin[0].scriptSig << OP_1;
tx.vout.resize(1);
tx.vout[0].nValue = 1*CENT;
tx.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
AddOrphanTx(MakeTransactionRef(tx), i);
}
// ... and 50 that depend on other orphans:
for (int i = 0; i < 50; i++)
{
CTransactionRef txPrev = RandomOrphan();
CMutableTransaction tx;
tx.vin.resize(1);
tx.vin[0].prevout.n = 0;
tx.vin[0].prevout.hash = txPrev->GetHash();
tx.vout.resize(1);
tx.vout[0].nValue = 1*CENT;
tx.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
SignSignature(keystore, *txPrev, tx, 0, SIGHASH_ALL);
AddOrphanTx(MakeTransactionRef(tx), i);
}
// This really-big orphan should be ignored:
for (int i = 0; i < 10; i++)
{
CTransactionRef txPrev = RandomOrphan();
CMutableTransaction tx;
tx.vout.resize(1);
tx.vout[0].nValue = 1*CENT;
tx.vout[0].scriptPubKey = GetScriptForDestination(key.GetPubKey().GetID());
tx.vin.resize(2777);
for (unsigned int j = 0; j < tx.vin.size(); j++)
{
tx.vin[j].prevout.n = j;
tx.vin[j].prevout.hash = txPrev->GetHash();
}
SignSignature(keystore, *txPrev, tx, 0, SIGHASH_ALL);
// Re-use same signature for other inputs
// (they don't have to be valid for this test)
for (unsigned int j = 1; j < tx.vin.size(); j++)
tx.vin[j].scriptSig = tx.vin[0].scriptSig;
BOOST_CHECK(!AddOrphanTx(MakeTransactionRef(tx), i));
}
// Test EraseOrphansFor:
for (NodeId i = 0; i < 3; i++)
{
size_t sizeBefore = mapOrphanTransactions.size();
EraseOrphansFor(i);
BOOST_CHECK(mapOrphanTransactions.size() < sizeBefore);
}
// Test LimitOrphanTxSize() function:
LimitOrphanTxSize(40);
BOOST_CHECK(mapOrphanTransactions.size() <= 40);
LimitOrphanTxSize(10);
BOOST_CHECK(mapOrphanTransactions.size() <= 10);
LimitOrphanTxSize(0);
BOOST_CHECK(mapOrphanTransactions.empty());
}
BOOST_AUTO_TEST_SUITE_END()
| [
"squbs@protonmail.com"
] | squbs@protonmail.com |
1fa8d92f0b7bc5653d2baa6130bff9165273d747 | dfcd0002703bbd36408646ac02a3e3927c80741c | /src/ConEmu/VirtualConsole.h | 3f64ef36aba9e1f4d6e7d4024238ffb36d169c9d | [
"BSD-3-Clause"
] | permissive | explosion78/ConEmu | 7cc45a733a8c649698c26b93548cb004a41e5982 | 40d4c613535434417d5642d2ce7f135ec6e7a06a | refs/heads/master | 2020-12-25T11:57:46.176532 | 2016-06-20T08:43:11 | 2016-06-20T08:43:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,589 | h |
/*
Copyright (c) 2009-2016 Maximus5
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ''AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include "../common/ConEmuCheck.h"
#include "../common/MSection.h"
#include "VConRelease.h"
#include "Options.h"
#include "FontPtr.h"
#include "RealConsole.h"
#include "VConChild.h"
#include "CustomFonts.h"
#include "SetColorPalette.h"
#define MAX_COUNT_PART_BRUSHES 16*16*4
#define MAX_SPACES 0x400
class CBackground;
class CTaskBarGhost;
class CVConGroup;
class CTab;
class CBackgroundInfo;
typedef DWORD VConFlags;
const VConFlags
vf_Active = 0x0001,
vf_Visible = 0x0002,
vf_Maximized = 0x0008,
vf_Grouped = 0x0010,
vf_None = 0
;
class CVirtualConsole :
public CVConRelease,
public CConEmuChild
{
private:
// RealConsole
CRealConsole *mp_RCon;
CConEmuMain *mp_ConEmu;
CTaskBarGhost *mp_Ghost;
protected:
friend class CVConGroup;
void* mp_Group; // For internal use of CVConGroup
protected:
VConFlags mn_Flags;
bool SetFlags(VConFlags Set, VConFlags Mask, int index = -1);
private:
int mn_Index; // !!! Debug, Informational !!!
wchar_t ms_Idx[16]; // !!! Debug, Informational !!!
int mn_ID; // !!! Debug, Unique per session id of VCon !!!
wchar_t ms_ID[16]; // !!! Debug, Informational !!!
protected:
struct VConRConSizes
{
uint TextWidth, TextHeight; // размер в символах
uint Width, Height; // размер в пикселях
uint nMaxTextWidth, nMaxTextHeight; // размер в символах
uint LastPadSize;
LONG nFontHeight, nFontWidth;
} m_Sizes;
//WARNING: Move to CFontCache object
bool isFontSizeChanged;
protected:
CVirtualConsole(CConEmuMain* pOwner, int index);
bool Constructor(RConStartArgs *args);
public:
void InitGhost();
protected:
virtual ~CVirtualConsole();
friend class CVConRelease;
public:
CRealConsole *RCon();
HWND GuiWnd();
void setFocus();
HWND GhostWnd();
bool isActive(bool abAllowGroup);
bool isVisible();
bool isGroup();
bool isGroupedInput();
public:
int Index();
LPCWSTR IndexStr();
int ID();
LPCWSTR IDStr();
public:
bool LoadConsoleData();
private:
struct
{
bool isVisible;
bool isVisiblePrev;
bool isVisiblePrevFromInfo;
bool isPrevBackground;
short x;
short y;
COLORREF foreColor;
COLORREF bgColor;
BYTE foreColorNum, bgColorNum;
wchar_t ch;
DWORD nBlinkTime, nLastBlink;
RECT lastRect;
UINT lastSize; // предыдущая высота курсора (в процентах)
} Cursor;
//
bool mb_IsForceUpdate; // Это устанавливается в InitDC, чтобы случайно isForce не потерялся
bool mb_RequiredForceUpdate; // Сменился шрифт, например...
bool isForce; // а это - сейчас (устанавливается по аргументу в Update)
bool mb_PaintSkippedLogged;
DWORD mn_LastBitsPixel;
protected:
friend class CConEmuChild;
HDC GetIntDC();
private:
bool mb_InUpdate;
RECT mrc_Client, mrc_Back;
CEDC m_DC;
HBRUSH hBrush0, hOldBrush, hSelectedBrush;
HBRUSH CreateBackBrush(bool bGuiVisible, bool& rbNonSystem, COLORREF *pColors = NULL);
CEFontStyles m_SelectedFont;
//CEFONT mh_FontByIndex[MAX_FONT_STYLES_EX]; // pointers to Normal/Bold/Italic/Bold&Italic/...Underline
CFontPtr m_UCharMapFont;
SMALL_RECT mrc_UCharMap;
wchar_t ms_LastUCharMapFont[32];
#ifdef _DEBUG
bool mb_DebugDumpDC;
#endif
bool mb_ConDataChanged;
HRGN mh_TransparentRgn;
//
bool mb_ChildWindowWasFound;
public:
bool InitDC(bool abNoDc, bool abNoWndResize, MSectionLock *pSDC, MSectionLock *pSCON);
void ResetOnStart();
bool GetUCharMapFontPtr(CFontPtr& pFont);
private:
// Working pointers
bool mb_PointersAllocated;
wchar_t *mpsz_ConChar, *mpsz_ConCharSave; // nMaxTextWidth * nMaxTextHeight
// CharAttr определен в "common/RgnDetect.h"
CharAttr *mpn_ConAttrEx, *mpn_ConAttrExSave; // nMaxTextWidth * nMaxTextHeight
DWORD *ConCharX; // nMaxTextWidth * nMaxTextHeight
DWORD *ConCharDX; // nMaxTextWidth
bool *pbLineChanged; // nMaxTextHeight
bool *pbBackIsPic; // nMaxTextHeight :: заполняется если *pbLineChanged
COLORREF* pnBackRGB; // nMaxTextHeight :: заполняется если *pbLineChanged и НЕ *pbBackIsPic
ConEmuTextRange m_etr;// Подсветка URL's и строк-ошибок-компиляторов
// функции выделения памяти
void PointersFree();
bool PointersAlloc();
void PointersZero();
// PanelViews
PanelViewInit m_LeftPanelView, m_RightPanelView;
// Set to `true`, if we have to update FarPanel sized on next Redraw
bool mb_LeftPanelRedraw, mb_RightPanelRedraw;
SMALL_RECT mrc_LastDialogs[MAX_DETECTED_DIALOGS]; int mn_LastDialogsCount; DWORD mn_LastDialogFlags[MAX_DETECTED_DIALOGS];
SMALL_RECT mrc_Dialogs[MAX_DETECTED_DIALOGS]; int mn_DialogsCount; DWORD mn_DialogAllFlags, mn_DialogFlags[MAX_DETECTED_DIALOGS];
bool UpdatePanelView(bool abLeftPanel, bool abOnRegister=false);
CRgnRects m_RgnTest, m_RgnLeftPanel, m_RgnRightPanel;
bool UpdatePanelRgn(bool abLeftPanel, bool abTestOnly=FALSE, bool abOnRegister=FALSE);
void PolishPanelViews();
bool CheckDialogsChanged();
bool mb_DialogsChanged;
UINT mn_ConEmuFadeMsg;
void CharAttrFromConAttr(WORD conAttr, CharAttr* pAttr);
#ifdef __GNUC__
AlphaBlend_t GdiAlphaBlend;
#endif
public:
const PanelViewInit* GetPanelView(bool abLeftPanel);
public:
// Плагин к фару может установить свою "картинку" для панелей (например, нарисовать в фоне букву диска)
//void FreeBackgroundImage(); // Освободить (если создан) HBITMAP для mp_BkImgData
SetBackgroundResult SetBackgroundImageData(CESERVER_REQ_SETBACKGROUND* apImgData); // вызывается при получении нового Background
bool HasBackgroundImage(LONG* pnBgWidth, LONG* pnBgHeight);
//void NeedBackgroundUpdate();
#ifdef APPDISTINCTBACKGROUND
CBackgroundInfo* GetBackgroundObject();
#endif
void NeedBackgroundUpdate();
protected:
// Содержит текущий фон (из плагина или из файла-цвета по настройке)
CBackground* mp_Bg;
#ifdef APPDISTINCTBACKGROUND
CBackgroundInfo* mp_BgInfo; // RefRelease, global object list
#endif
const AppSettings* mp_Set;
public:
bool isEditor, isViewer, isFilePanel, isFade, isForeground;
BYTE attrBackLast;
COLORREF *mp_Colors;
// In some cases (Win+G attach of external console)
// we use original RealConsole palette instead of ConEmu's default one
ColorPalette m_SelfPalette;
void SetSelfPalette(WORD wAttributes, WORD wPopupAttributes, const COLORREF (&ColorTable)[16]);
//wchar_t *Spaces; WORD nSpaceCount;
static wchar_t ms_Spaces[MAX_SPACES], ms_HorzDbl[MAX_SPACES], ms_HorzSingl[MAX_SPACES];
// Для ускорения получения индексов цвета
//BYTE m_ForegroundColors[0x100], m_BackgroundColors[0x100];
//HFONT mh_FontByIndex[0x100]; // содержит ссылки (не копии) на шрифты normal/bold/italic
bool mb_LastFadeFlag;
void DumpConsole();
bool LoadDumpConsole();
bool Dump(LPCWSTR asFile);
bool Update(bool abForce = false, HDC *ahDc=NULL);
void UpdateCursor(bool& lRes);
static bool UpdateCursorGroup(CVirtualConsole* pVCon, LPARAM lParam);
CECursorType GetCursor(bool bActive);
void UpdateThumbnail(bool abNoSnapshot = FALSE);
void SelectFont(CEFontStyles newFont);
void SelectBrush(HBRUSH hNew);
void PaintBackgroundImage(const RECT& rcText, const COLORREF crBack);
bool CheckSelection(const CONSOLE_SELECTION_INFO& select, SHORT row, SHORT col);
//bool GetCharAttr(wchar_t ch, WORD atr, wchar_t& rch, BYTE& foreColorNum, BYTE& backColorNum, FONT* pFont);
COLORREF* GetColors();
COLORREF* GetColors(bool bFade);
int GetPaletteIndex();
bool ChangePalette(int aNewPaletteIdx);
void PaintVCon(HDC hPaintDc);
bool PrintClient(HDC hPrintDc, bool bAllowRepaint, const LPRECT PaintRect);
bool Blit(HDC hPaintDC, int anX, int anY, int anShowWidth, int anShowHeight);
bool StretchPaint(HDC hPaintDC, int anX, int anY, int anShowWidth, int anShowHeight);
void UpdateInfo();
LONG GetVConWidth();
LONG GetVConHeight();
LONG GetTextWidth();
LONG GetTextHeight();
RECT GetRect();
RECT GetDcClientRect();
void OnFontChanged();
COORD ClientToConsole(LONG x, LONG y, bool StrictMonospace=false);
POINT ConsoleToClient(LONG x, LONG y);
void OnConsoleSizeChanged();
void OnConsoleSizeReset(USHORT sizeX, USHORT sizeY);
static void ClearPartBrushes();
HRGN GetExclusionRgn(bool abTestOnly=false);
COORD FindOpaqueCell();
bool RegisterPanelView(PanelViewInit* ppvi);
void OnPanelViewSettingsChanged();
bool IsPanelViews();
bool CheckTransparent();
void OnTitleChanged();
void SavePaneSnapshot();
void OnTaskbarSettingsChanged();
void OnTaskbarFocus();
void OnAppSettingsChanged(int iAppId = -1);
LONG mn_AppSettingsChangCount;
protected:
wchar_t* mpsz_LogScreen; DWORD mn_LogScreenIdx;
CONSOLE_SCREEN_BUFFER_INFO csbi; DWORD mdw_LastError;
CONSOLE_CURSOR_INFO cinf;
COORD winSize, coord;
uint TextLen;
bool isCursorValid, drawImage, textChanged, attrChanged;
DWORD nBgImageColors;
COORD bgBmpSize; HDC hBgDc; // Это только ссылка, для удобства отрисовки
void PaintVConSimple(HDC hPaintDc, RECT rcClient, bool bGuiVisible);
void PaintVConNormal(HDC hPaintDc, RECT rcClient);
void PaintVConDebug(HDC hPaintDc, RECT rcClient);
void UpdateCursorDraw(HDC hPaintDC, RECT rcClient, COORD pos, UINT dwSize);
bool UpdatePrepare(HDC *ahDc, MSectionLock *pSDC, MSectionLock *pSCON);
void UpdateText();
void PatInvertRect(HDC hPaintDC, const RECT& rect, HDC hFromDC, bool bFill);
WORD CharWidth(wchar_t ch, const CharAttr& attr);
void CharABC(wchar_t ch, ABC *abc);
bool CheckChangedTextAttr();
bool CheckTransparentRgn(bool abHasChildWindows);
HANDLE mh_Heap;
LPVOID Alloc(size_t nCount, size_t nSize);
void Free(LPVOID ptr);
MSection csCON;
int mn_BackColorIdx; //==0
typedef struct tag_PARTBRUSHES
{
wchar_t ch; // 0x2591 0x2592 0x2593 0x2588 - по увеличению плотности
COLORREF nBackCol;
COLORREF nForeCol;
HBRUSH hBrush;
} PARTBRUSHES;
//std::vector<PARTBRUSHES> m_PartBrushes;
static PARTBRUSHES m_PartBrushes[MAX_COUNT_PART_BRUSHES];
//static HBRUSH PartBrush(wchar_t ch, SHORT nBackIdx, SHORT nForeIdx);
static HBRUSH PartBrush(wchar_t ch, COLORREF nBackCol, COLORREF nForeCol);
bool mb_InPaintCall;
bool mb_InConsoleResize;
//
bool FindChanges(int row, const wchar_t* ConCharLine, const CharAttr* ConAttrLine, const wchar_t* ConCharLine2, const CharAttr* ConAttrLine2);
//bool bExtendFonts, bExtendColors;
//BYTE nFontNormalColor, nFontBoldColor, nFontItalicColor, nExtendColorIdx;
struct _TransparentInfo
{
INT nRectCount;
POINT *pAllPoints;
INT *pAllCounts;
} TransparentInfo;
//static HMENU mh_PopupMenu, mh_TerminatePopup, mh_DebugPopup, mh_EditPopup;
struct _HighlightInfo
{
COORD m_Last;
COORD m_Cur;
// store last paint coords
RECT mrc_LastRow, mrc_LastCol;
RECT mrc_LastHyperlink;
// true - if VCon visible & enabled in settings & highlight exist
bool mb_Exists;
// true - if Invalidate was called, but UpdateHighlights still not
bool mb_ChangeDetected;
bool mb_SelfSettings;
bool mb_HighlightRow;
bool mb_HighlightCol;
} m_HighlightInfo;
void ResetHighlightCoords();
void ResetHighlightHyperlinks();
void UpdateHighlights();
void UpdateHighlightsRowCol();
void UpdateHighlightsHyperlink();
void UndoHighlights();
bool CalcHighlightRowCol(COORD* pcrPos);
bool WasHighlightRowColChanged();
bool isHighlightAny();
bool isHighlightMouseRow();
bool isHighlightMouseCol();
bool isHighlightHyperlink();
public:
void ChangeHighlightMouse(int nWhat, int nSwitch);
protected:
virtual void OnDestroy() override;
};
| [
"ConEmu.Maximus5@gmail.com"
] | ConEmu.Maximus5@gmail.com |
15bcf28db22ac36df4771519e4bbdf979aa30fb6 | 002b6230874dea6e4d76defafc1ae293b5744918 | /library/MultiRegions/GlobalLinSysIterativeFull.h | 8bc79e2eed86cea3cd44a84f31f5364b47a51e1b | [
"MIT"
] | permissive | SCOREC/nektar | f3cf3c44106ac7a2dd678366bb53861e2db67a11 | add6f04b55fad6ab29d08b5b27eefd9bfec60be3 | refs/heads/master | 2021-01-22T23:16:16.440068 | 2015-02-27T17:26:09 | 2015-02-27T17:26:09 | 30,382,914 | 6 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 3,989 | h | ///////////////////////////////////////////////////////////////////////////////
//
// File GlobalLinSysIterativeFull.h
//
// For more information, please see: http://www.nektar.info
//
// The MIT License
//
// Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
// Department of Aeronautics, Imperial College London (UK), and Scientific
// Computing and Imaging Institute, University of Utah (USA).
//
// License for the specific language governing rights and limitations under
// 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.
//
// Description: GlobalLinSysIterativeFull header
//
///////////////////////////////////////////////////////////////////////////////
#ifndef NEKTAR_LIB_MULTIREGIONS_GLOBALLINSYSIterativeCG_H
#define NEKTAR_LIB_MULTIREGIONS_GLOBALLINSYSIterativeCG_H
#include <MultiRegions/GlobalLinSysIterative.h>
namespace Nektar
{
namespace MultiRegions
{
// Forward declarations
class ExpList;
/// A global linear system.
class GlobalLinSysIterativeFull : public GlobalLinSysIterative
{
public:
/// Creates an instance of this class
static GlobalLinSysSharedPtr create(
const GlobalLinSysKey &pLinSysKey,
const boost::weak_ptr<ExpList> &pExpList,
const boost::shared_ptr<AssemblyMap>
&pLocToGloMap)
{
return MemoryManager<GlobalLinSysIterativeFull>
::AllocateSharedPtr(pLinSysKey, pExpList, pLocToGloMap);
}
/// Name of class
static std::string className;
/// Constructor for full direct matrix solve.
MULTI_REGIONS_EXPORT GlobalLinSysIterativeFull(
const GlobalLinSysKey &pLinSysKey,
const boost::weak_ptr<ExpList> &pExpList,
const boost::shared_ptr<AssemblyMap>
&pLocToGloMap);
MULTI_REGIONS_EXPORT virtual ~GlobalLinSysIterativeFull();
private:
// Local to global map.
boost::shared_ptr<AssemblyMap> m_locToGloMap;
/// Solve the linear system for given input and output vectors
/// using a specified local to global map.
virtual void v_Solve(
const Array<OneD, const NekDouble> &in,
Array<OneD, NekDouble> &out,
const AssemblyMapSharedPtr &locToGloMap,
const Array<OneD, const NekDouble> &dirForcing
= NullNekDouble1DArray);
virtual void v_DoMatrixMultiply(
const Array<OneD, NekDouble>& pInput,
Array<OneD, NekDouble>& pOutput);
virtual void v_UniqueMap();
};
}
}
#endif
| [
"dan.a.ibanez@gmail.com"
] | dan.a.ibanez@gmail.com |
49a5ee982496a7b38a3da4f200c9d759b295921e | 882f9cdff36d2cb59b4e04841b109cfe5f8fdd2c | /Source/GeneticFPS/Public/Wall.h | ff873889e3f4239c714876b1aad300a28b8c209f | [] | no_license | DylanWard14/Genetically-Generated-FPS-Maps | a8bf3f5008c1010120a57c65ed92f86991fcee06 | e1c656720ced576563d7b17e3f2bf71013f8d860 | refs/heads/master | 2020-04-05T08:12:52.309112 | 2018-11-09T05:12:42 | 2018-11-09T05:12:42 | 156,706,083 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 509 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Wall.generated.h"
UCLASS()
class GENETICFPS_API AWall : public AActor
{
GENERATED_BODY()
public:
// Sets default values for this actor's properties
AWall();
protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;
public:
// Called every frame
virtual void Tick(float DeltaTime) override;
};
| [
"dylan.ward@iinet.net.au"
] | dylan.ward@iinet.net.au |
d126a96e96832f2a24ff8acec70258abf1d5bc78 | e2995b3e9d3cc3852ac69551873c16fc08a73b1b | /IShader.h | 1cc608fd529b917b95202ea3ac6e4bfd1e3c621c | [] | no_license | kristiansterjo/eyden-tracer-02 | 999467a77a978a32130f203cc1d04fb611bd7cc1 | de07e136af5753f0fe52bfb28348fb22321aba40 | refs/heads/master | 2020-08-10T09:52:51.058591 | 2019-10-31T00:37:53 | 2019-10-31T00:37:53 | 214,320,198 | 0 | 0 | null | 2019-10-11T01:50:12 | 2019-10-11T01:50:12 | null | UTF-8 | C++ | false | false | 501 | h | //Kristian Sterjo & Albrit Bendo
#pragma once
#include "types.h"
struct Ray;
/**
* @brief Base shader abstract interface class
*/
class IShader
{
public:
IShader(void) = default;
IShader(const IShader&) = delete;
virtual ~IShader(void) = default;
const IShader& operator=(const IShader&) = delete;
/**
* @brief Calculates the color of the hit by the ray \ray object
* @param ray The ray
* @return The color of the hit objesct
*/
virtual Vec3f Shade(const Ray& ray) const = 0;
};
| [
"noreply@github.com"
] | kristiansterjo.noreply@github.com |
b178fe7e299f321f1d191ddfa5cb1ac5d7b72f45 | 59ee5e1f9d2639bef0626d955300e32131e106f7 | /include/fbxsdk/scene/fbxscene.h | a147ab2aa2b3e02fa050bd672624e689ef2511d6 | [] | no_license | gwihlidal/fbx2json | cf60e0edb768133b7048a8292f91b46ceba30cba | cd1e2d1bb7b4562c8d6b52399eb102ee686b0ca3 | refs/heads/master | 2021-01-10T21:42:23.784052 | 2013-03-26T17:47:49 | 2013-03-26T17:47:49 | 20,610,677 | 14 | 6 | null | null | null | null | UTF-8 | C++ | false | false | 22,422 | h | /****************************************************************************************
Copyright (C) 2012 Autodesk, Inc.
All rights reserved.
Use of this software is subject to the terms of the Autodesk license agreement
provided at the time of installation or download, or which otherwise accompanies
this software in either electronic or hard copy form.
****************************************************************************************/
//! \file fbxscene.h
#ifndef _FBXSDK_SCENE_H_
#define _FBXSDK_SCENE_H_
#include <fbxsdk/fbxsdk_def.h>
#include <fbxsdk/core/base/fbxset.h>
#include <fbxsdk/core/base/fbxcharptrset.h>
#include <fbxsdk/scene/fbxdocument.h>
#include <fbxsdk/scene/animation/fbxanimevaluator.h>
#include <fbxsdk/scene/geometry/fbxlayer.h>
#include <fbxsdk/scene/geometry/fbxnodeattribute.h>
#include <fbxsdk/fileio/fbxiosettings.h>
#include <fbxsdk/fileio/fbxglobalsettings.h>
#include <fbxsdk/fbxsdk_nsbegin.h>
class FbxGeometry;
class FbxTexture;
class FbxSurfaceMaterial;
class FbxCharacter;
class FbxControlSetPlug;
class FbxGenericNode;
class FbxPose;
class FbxCharacterPose;
class FbxVideo;
class FbxGlobalLightSettings;
class FbxGlobalCameraSettings;
class FbxGlobalTimeSettings;
/** This class contains the description of a 3D scene. It contains the nodes (including the root node) (FbxNode),
* materials, textures, videos, gobos,
* poses, characters, character poses, control set plugs,
* generic nodes,
* scene information, global settings,
* and a global evaluator.
* The nodes are structured in a tree under the scene's root node.
*
* When an object is created using the FBX SDK, a scene is usually passed as argument to the
* object creation function to specify that the object belongs to this scene.
* At this point, a connection is made with the object as source and the scene as destination.
*
* All objects in the scene can be queried by connection index. In addition,
* generic nodes, materials, and textures can also be queried by name. In this latter case, the
* first object with the queried name will be returned.
*
* The global evaluator (FbxAnimEvaluator) is used to compute animation values
* for animated scenes.
* \nosubgrouping
*/
class FBXSDK_DLL FbxScene : public FbxDocument
{
FBXSDK_OBJECT_DECLARE(FbxScene, FbxDocument);
public:
/**
* \name Clear scene
*/
//@{
//! Delete the node tree below the root node and restore default settings.
void Clear();
//@}
/**
* \name Node Tree Access
*/
//@{
/** Get the root node of the scene.
* \return Pointer to the root node.
* \remarks This node is not saved. Do not use it to apply a global transformation
* to the node hierarchy. If a global transformation must be applied, insert a
* new node below this one.
*/
FbxNode* GetRootNode() const;
//@}
/**
* \name Texture Material and Video Access
*/
//@{
/** Clear, then fill, a texture array with all existing textures included in the scene.
* \param pTextureArray An array of texture pointers.
*/
void FillTextureArray(FbxArray<FbxTexture*>& pTextureArray);
/** Clear, then fill, a material array with all existing materials included in the scene.
* \param pMaterialArray An array of material pointers.
*/
void FillMaterialArray(FbxArray<FbxSurfaceMaterial*>& pMaterialArray);
//@}
/**
* \name Generic Node Access
*/
//@{
/** Get number of generic nodes in the scene.
* \return Number of Generic Nodes in this scene.
*/
int GetGenericNodeCount() const;
/** Get generic node at given index.
* \param pIndex Position in the list of the generic nodes.
* \return Pointer to the generic node or \c NULL if the index is out of bounds.
*/
FbxGenericNode* GetGenericNode(int pIndex);
/** Access a generic node from its name.
* \param pName Name of the generic node.
* \return found generic node
*/
FbxGenericNode* GetGenericNode(char* pName);
/** Add a generic node to this scene.
* \param pGenericNode Pointer to the generic node to be added.
* \return If the passed parameter is \c NULL, this method will return \c false, otherwise \c true.
*/
bool AddGenericNode(FbxGenericNode* pGenericNode);
/** Remove the generic node from this scene.
* \param pGenericNode Pointer to the generic node to be removed.
* \return If the passed parameter is \c NULL, this method will return \c false, otherwise \c true.
* \remarks The pointed object is not referenced by the scene anymore but is not deleted.
*/
bool RemoveGenericNode(FbxGenericNode* pGenericNode);
//@}
/**
* \name Character Management
*/
//@{
/** Get number of characters.
* \return Number of characters in this scene.
*/
int GetCharacterCount() const;
/** Get character at given index.
* \param pIndex Position in the list of the characters.
* \return Pointer to the character or \c NULL if index is out of bounds.
*/
FbxCharacter* GetCharacter(int pIndex);
/** Create a new character.
* \param pName Name given to character.
* \return Index of the created character.
*/
int CreateCharacter(const char* pName);
/** Destroy character.
* \param pIndex Specify which character to destroy.
*/
void DestroyCharacter(int pIndex);
//@}
/**
* \name ControlSetPlug Management
*/
//@{
/** Get number of ControlSetPlugs.
* \return Number of ControlSet plugs in this scene.
*/
int GetControlSetPlugCount() const;
/** Get ControlSetPlug at given index.
* \param pIndex Position in the list of the ControlSetPlug
* \return Pointer to ControlSetPlug or \c NULL if index is out of bounds.
*/
FbxControlSetPlug* GetControlSetPlug(int pIndex);
/** Create a new ControlSetPlug.
* \param pName Name given to ControlSetPlug.
* \return Index of created ControlSetPlug.
*/
int CreateControlSetPlug(char* pName);
/** Destroy ControlSetPlug.
* \param pIndex Specify which ControlSetPlug to destroy.
*/
void DestroyControlSetPlug(int pIndex);
//@}
/**
* \name Character Pose Management
*/
//@{
/** Get number of character poses.
* \return Number of character poses in this scene.
* \remarks Character Poses and Poses are two distinct entities having their own lists.
*/
int GetCharacterPoseCount() const;
/** Get character pose at given index.
* \param pIndex Position in the list of character poses.
* \return Pointer to the character pose or \c NULL if index is out of bounds.
*/
FbxCharacterPose* GetCharacterPose(int pIndex);
/** Create a new character pose.
* \param pName Name given to character pose.
* \return Index of created character pose.
*/
int CreateCharacterPose(char* pName);
/** Destroy character pose.
* \param pIndex Specify which character pose to destroy.
*/
void DestroyCharacterPose(int pIndex);
//@}
/**
* \name Pose Management
*/
//@{
/** Get number of poses.
* \return Number of poses in the scene.
* \remarks Poses and Character Poses are two distinct entities having their own lists.
*/
int GetPoseCount() const;
/** Get pose at given index.
* \param pIndex Position in the list of poses.
* \return Pointer to the pose or \c NULL if index is out of bounds.
*/
FbxPose* GetPose(int pIndex);
/** Add a pose to this scene.
* \param pPose The pose (for example: bind pose, rest pose) to be added to the scene.
* \return If the pose is correctly added to the scene, return \c true. Otherwise, if the pose is
* already in the scene, return \c false.
*/
bool AddPose(FbxPose* pPose);
/** Remove the specified pose from the scene.
* \param pPose The pose (for example: bind pose, rest pose) to be removed from the scene.
* \return If the pose was successfully removed from the scene, return \c true. Otherwise, if the
* pose could not be found return \c false.
*/
bool RemovePose(FbxPose* pPose);
/** Remove the pose at the given index from the scene.
* \param pIndex Index of the pose to be removed.
* \return If the pose was successfully removed from the scene, return \c true. Otherwise, if the
* pose could not be found return \c false.
*/
bool RemovePose(int pIndex);
//@}
/**
* \name Scene information
*/
//@{
/** Get the scene information.
* \return Pointer to the scene information object.
*/
inline FbxDocumentInfo* GetSceneInfo() { return GetDocumentInfo(); }
/** Set the scene information.
* \param pSceneInfo Pointer to the scene information object.
*/
inline void SetSceneInfo(FbxDocumentInfo* pSceneInfo) { SetDocumentInfo(pSceneInfo); }
//@}
/**
* \name Global Settings
*/
//@{
/** Access global settings.
* \return Reference to the Global Settings.
*/
FbxGlobalSettings& GetGlobalSettings();
/** Const access to global settings.
* \return Const reference to the Global Settings.
*/
const FbxGlobalSettings& GetGlobalSettings() const;
//@}
/**
* \name Global Evaluator
* The global evaluator is used to compute animation values
* for animated scenes.
* A typical usage would be to compute the global transform
* matrix of a node \c lNode at a given time \c lTime.
* \code
FbxAMatrix& lGlobalMatrix = lNode->GetScene()->GetEvaluator()->GetNodeGlobalTransform(lNode, lTime);
or the exact equivalent:
FbxAMatrix& lGlobalMatrix = lNode->EvaluateGlobalTransform(lTime);
* \endcode
*
* The user can create one or more evaluators in the scene.
* The default evaluator is set using SetEvaluator.
* When GetEvaluator is called, if the scene has no evaluator,
* an evaluator is created with default values.
*/
//@{
/** Set the global evaluator used by this scene evaluation engine.
* \param pEvaluator The evaluator to be used for evaluation processing of this scene.
*/
void SetEvaluator(FbxAnimEvaluator* pEvaluator);
/** Get the global evaluator used by this scene evaluation engine.
* If no evaluator were previously set, this function will return either the
* first evaluator found attached to this scene, or a new default evaluator.
* \return The evaluator to be used for evaluation processing of this scene.
*/
FbxAnimEvaluator* GetEvaluator();
//@}
/** Clear then fill a pose array with all existing pose included in the scene.
* \param pPoseArray An array of pose pointers.
*/
void FillPoseArray(FbxArray<FbxPose*>& pPoseArray);
/**
* \name Material Access
*/
//@{
/** Get number of materials.
* \return Number of materials in this scene.
*/
int GetMaterialCount () const;
/** Get the material at the given index.
* \param pIndex Position in the list of materials.
* \return Pointer to the material or \c NULL if the index is out of bounds.
* \remarks pIndex must be between 0 and GetMaterialCount().
*/
FbxSurfaceMaterial* GetMaterial (int pIndex);
/** Get the material by its name.
* \param pName Name of the material.
* \return Pointer to the material or \c NULL if not found.
*/
FbxSurfaceMaterial* GetMaterial (char* pName);
/** Add the material to this scene.
* \param pMaterial Pointer to the material to be added.
* \return true on successful addition.
*/
bool AddMaterial (FbxSurfaceMaterial* pMaterial);
/** Remove the material from this scene.
* \param pMaterial Pointer to the material to be removed.
* \return true on successful removal.
*/
bool RemoveMaterial (FbxSurfaceMaterial* pMaterial);
//@}
/**
* \name Texture Access
*/
//@{
/** Get number of textures (type FbxTexture).
* \return Number of textures in this scene. Includes types FbxFileTexture, FbxLayeredTexture and FbxProceduralTexture.
* \remarks To get the number of textures of a specific type, use GetSrcCount(). For example:
* \code
* int lNbFileTextures = lScene->GetSrcObjectCount<FbxFileTexture>();
* int lNbLayeredTextures = lScene->GetSrcObjectCount<FbxLayeredTexture>();
* int lNbProceduralTextures = lScene->GetSrcObjectCount<FbxProceduralTexture>();
* \endcode
*/
int GetTextureCount () const;
/** Get the texture at the given index. pIndex must be between 0 and GetTextureCount().
* \param pIndex Position in the list of textures.
* \return Pointer to the texture or \c NULL if the index is out of bounds.
* \remarks To get the texture of a specific texture type, use GetSrcObject(). For example:
* \code
* FbxFileTexture* lFileTexture = lScene->GetSrcObject<FbxFileTexture>(i);
* FbxLayeredTexture* lLayeredTexture = lScene->GetSrcObject<FbxLayeredTexture>(i);
* FbxProceduralTexture* lProceduralTexture = lScene->GetSrcObject<FbxProceduralTexture>(i);
* \endcode
*/
FbxTexture* GetTexture (int pIndex);
/** Get the texture by its name.
* \param pName Name of the texture.
* \return Pointer to the texture or \c NULL if not found.
*/
FbxTexture* GetTexture (char* pName);
/** Add the texture to this scene.
* \param pTexture Pointer to the texture to be added.
* \return \c true on successful addition.
*/
bool AddTexture (FbxTexture* pTexture);
/** Remove the texture from this scene.
* \param pTexture Pointer to the texture to be removed.
* \return \c true on successful removal.
*/
bool RemoveTexture (FbxTexture* pTexture);
//@}
/**
* \name Node Access
*/
//@{
/** Get number of nodes.
* \return Number of nodes in this scene.
*/
int GetNodeCount () const;
/** Get the node at the given index.
* \param pIndex Position in the list of nodes.
* \return Pointer to the node or \c NULL if the index is out of bounds.
* \remarks pIndex must be between 0 and GetNodeCount().
*/
FbxNode* GetNode (int pIndex);
/** Add the node to this scene.
* \param pNode Pointer to the node to be added.
* \return true on successful addition.
*/
bool AddNode (FbxNode* pNode);
/** Remove the node from this scene.
* \param pNode Pointer to the node to be removed.
* \return true on successful removal.
*/
bool RemoveNode (FbxNode* pNode);
/** Helper method for determining the number of nodes that have
* curves on surface attributes in the scene. Since the curve-on-surface
* nodes are connected to nurbs geometry and not any FbxNode in the
* scene, they won't normally be picked up in a graph traversal.
* \return The number of curve-on-surface nodes in the scene
*/
int GetCurveOnSurfaceCount ();
/** Get the first node with this name.
* \param pName Name of the node.
* \return Pointer to the node, or \c NULL if node is not found.
*/
FbxNode* FindNodeByName ( const FbxString& pName );
//@}
/**
* \name Geometry Access
*/
//@{
/** Get number of geometries.
* \return Number of geometries in this scene.
*/
int GetGeometryCount () const;
/** Get the geometry at the given index.
* \param pIndex Position in the list of geometries.
* \return Pointer to the geometry or \c NULL if the index is out of bounds.
* \remarks pIndex must be between 0 and GetGeometryCount().
*/
FbxGeometry* GetGeometry (int pIndex);
/** Add the geometry to this scene.
* \param pGeometry Pointer to the geometry to be added.
* \return true on successful addition.
*/
bool AddGeometry (FbxGeometry* pGeometry);
/** Remove the geometry from this scene.
* \param pGeometry Pointer to the geometry to be removed.
* \return true on successful removal.
*/
bool RemoveGeometry (FbxGeometry* pGeometry);
//@}
/**
* \name Video Access
*/
//@{
/** Get number of videos.
* \return Number of videos in this scene.
*/
int GetVideoCount () const;
/** Get the video at the given index.
* \param pIndex Position in the list of videos.
* \return Pointer to the video or \c NULL if the index is out of bounds.
* \remarks pIndex must be between 0 and GetVideoCount().
*/
FbxVideo* GetVideo (int pIndex);
/** Add the video to this scene.
* \param pVideo Pointer to the video to be added.
* \return true on successful addition.
*/
bool AddVideo (FbxVideo* pVideo);
/** Remove the video from this scene.
* \param pVideo Pointer to the video to be removed.
* \return true on successful removal.
*/
bool RemoveVideo (FbxVideo* pVideo);
//@}
/**
* \name Utilities
*/
//@{
/** Synchronize all the Show properties of node instances.
* Walks all the node attributes defined in the scene and synchronize the Show property
* of all the nodes that reference the node attribute so that they all contain the same
* value. This method should be called after the FBX scene is completely created (typically
* right after the calls to the FbxImporter::Import() or just before the calls to the
* FbxExporter::Export().
*
* \remarks Applications only need to call this method if their interpretation of the Show
* property implies that setting the Show state on one instance affect all of them.
*
* \see FbxNode::Visibility property, FbxNode::Show property
*/
void SyncShowPropertyForInstance();
//@}
/*****************************************************************************************************************************
** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
*****************************************************************************************************************************/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
/** Clone this scene object (and everything else it contains if clone type is eDeepClone)
* \param pCloneType The type of clone to be created. By default, the clone type is eDeepClone.
* \param pContainer An optional parameter to specify which object will "contain" the new object. By contain, we mean the new object
* will become a source to the container, connection-wise.
* \return The new clone, or NULL (if the specified clone type is not supported).
* \remark This method overwrites the FbxObject::Clone() method. When the clone type is "deep", the whole scene network is cloned. With the "reference"
* clone type, this method is simply calling the parent's Clone() method
*/
virtual FbxObject* Clone(FbxObject::ECloneType pCloneType=eDeepClone, FbxObject* pContainer=NULL) const;
virtual FbxObject& Copy(const FbxObject& pObject);
void ConnectMaterials();
void BuildMaterialLayersDirectArray();
void ReindexMaterialConnections(); // called to make sure that eIndex is remapped to eIndexToDirect
FbxSet* AddTakeTimeWarpSet(char *pTakeName);
FbxSet* GetTakeTimeWarpSet(char *pTakeName);
// This function will destroy the scene (and all the objects directly connected to it) without sending
// the Connect notifications nor trying to disconnect the objects first. This is a bypass of the intended
// workflow and should be used with care.
void ForceKill();
private:
virtual void Construct(const FbxScene* pFrom);
virtual void Destruct(bool pRecursive);
void ConnectTextureLayerElement(FbxLayerContainer* pLayerContainer,
FbxLayerElement::EType pLayerType,
FbxNode* pParentNode);
void BuildTextureLayersDirectArrayForLayerType(FbxLayerContainer* pLayerContainer,
FbxLayerElement::EType pLayerType);
public:
void ConvertNurbsSurfaceToNurbs();
void ConvertMeshNormals();
void ConvertNurbsCurvesToNulls();
void ConnectTextures();
void BuildTextureLayersDirectArray();
void FixInheritType(FbxNode *pNode);
void UpdateScaleCompensate(FbxNode *pNode, FbxIOSettings& pIOS);
FbxClassId ConvertAttributeTypeToClassID(FbxNodeAttribute::EType pAttributeType);
FbxGlobalLightSettings& GlobalLightSettings() { return *mGlobalLightSettings; }
FbxGlobalCameraSettings& GlobalCameraSettings() { return *mGlobalCameraSettings; }
FbxGlobalTimeSettings& GlobalTimeSettings() { return *mGlobalTimeSettings; }
private:
FbxNode* mRootNode;
FbxGlobalLightSettings* mGlobalLightSettings;
FbxGlobalCameraSettings* mGlobalCameraSettings;
FbxGlobalTimeSettings* mGlobalTimeSettings;
FbxAnimEvaluator* mEvaluator;
FbxCharPtrSet mTakeTimeWarpSet;
#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
};
#include <fbxsdk/fbxsdk_nsend.h>
#endif /* _FBXSDK_SCENE_H_ */
| [
"cameronyule@preloaded.com"
] | cameronyule@preloaded.com |
13bbc207b28968c841e7584680ad074895a424d8 | 15a7fd482bdeb804c6247b9baa376a11dc98a823 | /Portable/zoolib/Util_Chan_UTF_Operators.cpp | 368ef25b7fe4a833776c17d74ccf07038289dba0 | [
"MIT"
] | permissive | MorningSun-GitBoy/zoolib_cxx | e2da8153005b12b8493ac45fa8f2e5c504619284 | 456a969b88ae26af928eabc892bedaccdded526a | refs/heads/master | 2021-03-25T09:58:09.288346 | 2020-03-10T16:06:28 | 2020-03-10T16:06:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,190 | cpp | /* -------------------------------------------------------------------------------------------------
Copyright (c) 2014 Andrew Green
http://www.zoolib.org
Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) 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 "zoolib/Util_Chan_UTF_Operators.h"
#include <inttypes.h> // For PRIuLEAST16 and PRIuLEAST32
#include "zoolib/Stringf.h"
#include "zoolib/Util_Chan.h" // For sCopyAll
#include "zoolib/Util_Chan_UTF.h"
// =================================================================================================
#pragma mark - Util_Chan_UTF_Operators
namespace ZooLib {
namespace Util_Chan_UTF_Operators {
const ChanW_UTF& operator<<(const ChanW_UTF& w, const string32& iString)
{
sEWrite(w, iString);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, const UTF32* iString)
{
sEWrite(w, iString);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, UTF32* iString)
{
sEWrite(w, iString);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, const string16& iString)
{
sEWrite(w, iString);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, const UTF16* iString)
{
sEWrite(w, iString);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, UTF16* iString)
{
sEWrite(w, iString);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, const string8& iString)
{
sEWrite(w, iString);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, const UTF8* iString)
{
sEWrite(w, iString);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, UTF8* iString)
{
sEWrite(w, iString);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, const ChanR_UTF& r)
{
sCopyAll<UTF32>(r, w);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, bool iVal)
{
sEWrite(w, iVal ? "true" : "false");
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, char iVal)
{
sEWritef(w, "%c", iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, unsigned char iVal)
{
sEWritef(w, "%u", (unsigned int)iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, signed char iVal)
{
sEWritef(w, "%d", int(iVal));
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, __wchar_t iVal)
{
sEWritef(w, "%lc", iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, short iVal)
{
sEWritef(w, "%d", iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, unsigned short iVal)
{
sEWritef(w, "%u", iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, int iVal)
{
sEWritef(w, "%d", iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, unsigned int iVal)
{
sEWritef(w, "%u", iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, long iVal)
{
sEWritef(w, "%ld", iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, unsigned long iVal)
{
sEWritef(w, "%lu", iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, __int64 iVal)
{
sEWritef(w, "%lld", iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, __uint64 iVal)
{
sEWritef(w, "%llu", iVal);
return w;
}
#if ZCONFIG_CPP >= 2011
const ChanW_UTF& operator<<(const ChanW_UTF& w, char16_t iVal)
{
// Would like to use PRIuLEAST16, but the compiler complains.
sEWritef(w, "%u", iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, char32_t iVal)
{
sEWritef(w, "%u", iVal);
// sEWritef(w, "%" PRIuLEAST32, iVal);
return w;
}
#endif // ZCONFIG_CPP >= 2011
const ChanW_UTF& operator<<(const ChanW_UTF& w, float iVal)
{
Util_Chan::sWriteExact(w, iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, double iVal)
{
Util_Chan::sWriteExact(w, iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, long double iVal)
{
Util_Chan::sWriteExact(w, iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, const void* iVal)
{
sEWritef(w, "%p", iVal);
return w;
}
const ChanW_UTF& operator<<(const ChanW_UTF& w, void* iVal)
{
sEWritef(w, "%p", iVal);
return w;
}
} // namespace Util_Chan_UTF_Operators
} // namespace ZooLib
| [
"ag@em.net"
] | ag@em.net |
43092f4965bfc5bdcab98b2bcaa9f6b2128b275f | 964170ed8f181ef172656cae59bcb6058830cbac | /Source/BlackWolf.Lupus.Core/UdpClient.h | 53e992f88e9724ced0f322006fc2c413b0831ab8 | [
"MIT"
] | permissive | Qazwar/lupus-core | 90d189fae2ba6dd24a9c67a1612aed5b8c390390 | ea5196b1b8663999f0a6fcfb5ee3dc5c01d48f32 | refs/heads/master | 2021-05-29T09:34:51.090803 | 2014-11-14T14:47:42 | 2014-11-14T14:47:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,889 | h | /**
* Copyright (C) 2014 David Wolf <d.wolf@live.at>
*
* This file is part of Lupus.
* 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.
*/
#pragma once
#include <tuple>
#include <vector>
#include <memory>
#include <functional>
#include "SocketEnum.h"
#include "Task.h"
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251)
#endif
namespace Lupus {
namespace Net {
namespace Sockets {
class Socket;
class IPAddress;
class IPEndPoint;
class LUPUSCORE_API UdpClient : public NonCopyable
{
public:
UdpClient() = default;
UdpClient(AddressFamily); // Socket
UdpClient(uint16_t port); // Bind
UdpClient(std::shared_ptr<IPEndPoint> ep) throw(null_pointer); // Bind
UdpClient(uint16_t port, AddressFamily); // Bind
UdpClient(const String& hostname, uint16_t port); // Connect
virtual ~UdpClient() = default;
virtual size_t Available() const throw(invalid_operation);
virtual std::shared_ptr<Socket> Client() const NOEXCEPT;
virtual void Client(std::shared_ptr<Socket>) NOEXCEPT;
virtual bool ExclusiveAddressUse() const throw(socket_error);
virtual void ExclusiveAddressUse(bool) throw(socket_error);
virtual Task<std::vector<uint8_t>> ReceiveAsync(std::shared_ptr<IPEndPoint>&) NOEXCEPT;
virtual Task<int> SendAsync(const std::vector<uint8_t>&, size_t) NOEXCEPT;
virtual Task<int> SendAsync(const std::vector<uint8_t>&, size_t, std::shared_ptr<IPEndPoint>) NOEXCEPT;
virtual Task<int> SendAsync(const std::vector<uint8_t>&, size_t, const String&, uint16_t) NOEXCEPT;
virtual void Connect(std::shared_ptr<IPEndPoint> remoteEndPoint) throw(socket_error, invalid_operation);
virtual void Connect(std::shared_ptr<IPAddress> address, uint16_t port) throw(socket_error, invalid_operation);
virtual void Connect(const String& host, uint16_t port) throw(socket_error, std::invalid_argument, invalid_operation);
virtual void Close() throw(socket_error, invalid_operation);
virtual std::vector<uint8_t> Receive(std::shared_ptr<IPEndPoint>&) throw(socket_error);
virtual int Send(const std::vector<uint8_t>&, size_t) throw(socket_error);
virtual int Send(const std::vector<uint8_t>&, size_t, std::shared_ptr<IPEndPoint>);
virtual int Send(const std::vector<uint8_t>&, size_t, const String&, uint16_t) throw(std::invalid_argument);
private:
std::shared_ptr<Socket> mClient = nullptr;
};
}
}
}
#ifdef _MSC_VER
#pragma warning(pop)
#endif
| [
"d.wolf@live.at"
] | d.wolf@live.at |
000cd8afc038b43dd8ab6eb1404039f75b8ea391 | 77783f275694f90e6e7452f2d6da319563f71cc1 | /as per lectures/src/eligibility.cpp | 3ade928489b234b9d60ef5965c8375ae507ecee1 | [] | no_license | JD-93/Hackathon-Case-Study | 940af0f20a885bbfde8b084f67727ddb63170cb6 | a6868847bdeaea546ba8974199de20d8adc9a9cb | refs/heads/master | 2023-02-25T19:50:18.329762 | 2021-02-04T10:10:24 | 2021-02-04T10:10:24 | 255,705,848 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 347 | cpp | /*
* eligibility.cpp
*
* Created on: 19-Apr-2020
* Author: sunbeam
*/
#include "eligibility.h"
eligibility::eligibility() {
// TODO Auto-generated constructor stub
}
eligibility::~eligibility() {
// TODO Auto-generated destructor stub
}
void eligibility::display() {
cout<<course<<","<<eligible_branch<<","<<min_marks<<endl ;
}
| [
"jaydeep.kachare93@gmail.com"
] | jaydeep.kachare93@gmail.com |
3626831767c48485eb2b02d642a4f352cfc368b9 | ea18d801262e84618aff0a36c0bf6457bbbc3e21 | /homework2/src/helpers/MotionPlanningTree.cpp | de7736c629c82ec6321b18f48076f532b82c5bee | [] | no_license | aruisdante/RBE595-Motion-Planning | 34709d2245eb865e4af49e38d8240456ce94adce | 263d1d704c1604605ccb4ca891bd11140c1ea268 | refs/heads/master | 2016-08-12T03:52:22.540046 | 2013-04-02T20:51:51 | 2013-04-02T20:51:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,677 | cpp | /**
* @file MotionPlanningTree.cpp
*
* @date Feb 28, 2013
* @author parallels
* @brief implementation for Motion Planning Tree
*/
//License File
//****************SYSTEM DEPENDANCIES**************************//
#include<iostream>
//*****************LOCAL DEPENDANCIES**************************//
#include "MotionPlanningTree.h"
//**********************NAMESPACES*****************************//
SimpleMotionPlanningTree::SimpleMotionPlanningTree(const ompl::base::SpaceInformationPtr& si)
{
this->si_ = si;
}
SimpleMotionPlanningTree::~SimpleMotionPlanningTree()
{
this->flushTree();
}
SimpleMotionPlanningTree::size_type SimpleMotionPlanningTree::size() const
{
return this->nodes_.size();
}
void SimpleMotionPlanningTree::addNode(SimpleMotionPlanningTree::SimplePathNode* node, size_type& index)
{
this->nodes_.push_back(node);
index = this->nodes_.size();
}
SimpleMotionPlanningTree::SimplePathNode* SimpleMotionPlanningTree::addNode(size_type& index)
{
SimpleMotionPlanningTree::SimplePathNode* new_node = new SimplePathNode(this->si_);
this->nodes_.push_back(new_node);
index = this->nodes_.size()-1;
return new_node;
}
SimpleMotionPlanningTree::SimplePathNode* SimpleMotionPlanningTree::getNode(size_type index) const
{
if(index < this->nodes_.size())
{
return this->nodes_.at(index);
}
else
{
return NULL;
}
}
void SimpleMotionPlanningTree::flushTree()
{
for (size_type index = 0; index < this->nodes_.size(); ++index)
{
SimpleMotionPlanningTree::SimplePathNode* node = this->nodes_.at(index);
if(node!=NULL)
{
if(node->node_state_) this->si_->freeState(node->node_state_);
delete node;
}
}
this->nodes_.clear();
}
| [
"adampanzica@gmail.com"
] | adampanzica@gmail.com |
146c18181e40008b2f84be7c7cd2c52d587c705b | 22cda40520fbeb925bf121d39a90dd85b3692244 | /cipher.cpp | c4726b6f86d2987976e078de4a33c34290860ad8 | [
"MIT"
] | permissive | dcberumen/Classical-Ciphers | 57d26b5e61bb345da82b2fedaacd399207f8e3d0 | c8725e5d96757e1f393aef70627eadaf671a687e | refs/heads/master | 2021-01-19T21:35:59.031599 | 2017-04-18T21:38:19 | 2017-04-18T21:38:19 | 88,670,947 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,984 | cpp | #include <string>
#include <stdio.h>
#include <stdlib.h>
#include <fstream>
#include <iostream>
#include "CipherInterface.h"
#include "Caesar.h"
#include "Playfair.h"
#include "Railfence.h"
#include "RowTransposition.h"
#include "Vigenere.h"
using namespace std;
int main(int argc, char** argv)
{
CipherInterface* cipher = NULL;
string EncDec = argv[2];
ifstream read;
ofstream out;
string CODE;
read.open(argv[4]);
while(read)
{
read >> CODE;
}
read.close();
// Create an instance of Playfair cipher
if( std::string(argv[1]) == "-PLF")
{
cipher = new Playfair();
/* Error checks */
if(!cipher)
{
fprintf(stderr, "ERROR [%s %s %d]: could not allocate memory\n",
__FILE__, __FUNCTION__, __LINE__);
exit(-1);
}
/* Set the encryption key */
if(cipher->setKey(argv[3]))
{
/* Perform encryption */
if(EncDec == "-E" || EncDec == "-e")
{
string cipherText = cipher->encrypt(CODE);
out.open(argv[5]);
out << cipherText;
out.close();
}
/* Perform decryption */
else if(EncDec == "-D" || EncDec == "-d")
{
string plaintext = cipher->decrypt(CODE);
out.open(argv[5]);
out << plaintext;
out.close();
}
else
{
fprintf(stderr, "ERROR: Invalid encrypt or decrypt choice\n");
exit(-1);
}
}
else
{
fprintf(stderr,"ERROR: Invalid key\n");
exit(-1);
}
}
/* Create an instance of the Caesar cipher */
else if( std::string(argv[1]) == "-CES")
{
cipher = new Caesar();
/* Error checks */
if(!cipher)
{
fprintf(stderr, "ERROR [%s %s %d]: could not allocate memory\n",
__FILE__, __FUNCTION__, __LINE__);
exit(-1);
}
/* Set the encryption key */
if(cipher->setKey(argv[3]))
{
/* Perform encryption */
if(EncDec == "-E" || EncDec == "-e")
{
string cipherText = cipher->encrypt(CODE);
out.open(argv[5]);
out << cipherText;
out.close();
}
/* Perform decryption */
else if(EncDec == "-D" || EncDec == "-d")
{
string plaintext = cipher->decrypt(CODE);
out.open(argv[5]);
out << plaintext;
out.close();
}
else
{
fprintf(stderr, "ERROR: Invalid encrypt or decrypt choice\n");
exit(-1);
}
}
else
{
fprintf(stderr,"ERROR: Invalid key\n");
exit(-1);
}
}
else if( std::string(argv[1]) == "-VIG")
{
cipher = new Vigenere();
/* Error checks */
if(!cipher)
{
fprintf(stderr, "ERROR [%s %s %d]: could not allocate memory\n",
__FILE__, __FUNCTION__, __LINE__);
exit(-1);
}
/* Set the encryption key */
if(cipher->setKey(argv[3]))
{
/* Perform encryption */
if(EncDec == "-E" || EncDec == "-e")
{
string cipherText = cipher->encrypt(CODE);
out.open(argv[5]);
out << cipherText;
out.close();
}
/* Perform decryption */
else if(EncDec == "-D" || EncDec == "-d")
{
string plaintext = cipher->decrypt(CODE);
out.open(argv[5]);
out << plaintext;
out.close();
}
else
{
fprintf(stderr, "ERROR: Invalid encrypt or decrypt choice\n");
exit(-1);
}
}
else
{
fprintf(stderr,"ERROR: Invalid key\n");
exit(-1);
}
}
else if( std::string(argv[1]) == "-RTS")
{
cipher = new RowTransposition();
/* Error checks */
if(!cipher)
{
fprintf(stderr, "ERROR [%s %s %d]: could not allocate memory\n",
__FILE__, __FUNCTION__, __LINE__);
exit(-1);
}
/* Set the encryption key */
if(cipher->setKey(argv[3]))
{
/* Perform encryption */
if(EncDec == "-E" || EncDec == "-e")
{
string cipherText = cipher->encrypt(CODE);
out.open(argv[5]);
out << cipherText;
out.close();
}
/* Perform decryption */
else if(EncDec == "-D" || EncDec == "-d")
{
string plaintext = cipher->decrypt(CODE);
out.open(argv[5]);
out << plaintext;
out.close();
}
else
{
fprintf(stderr, "ERROR: Invalid encrypt or decrypt choice\n");
exit(-1);
}
}
else
{
fprintf(stderr,"ERROR: Invalid key\n");
exit(-1);
}
}
else if( std::string(argv[1]) == "-RFC")
{
cipher = new Railfence();
/* Error checks */
if(!cipher)
{
fprintf(stderr, "ERROR [%s %s %d]: could not allocate memory\n",
__FILE__, __FUNCTION__, __LINE__);
exit(-1);
}
/* Set the encryption key */
if(cipher->setKey(argv[3]))
{
/* Perform encryption */
if(EncDec == "-E" || EncDec == "-e")
{
string cipherText = cipher->encrypt(CODE);
out.open(argv[5]);
out << cipherText;
out.close();
}
/* Perform decryption */
else if(EncDec == "-D" || EncDec == "-d")
{
string plaintext = cipher->decrypt(CODE);
out.open(argv[5]);
out << plaintext;
out.close();
}
else
{
fprintf(stderr, "ERROR: Invalid encrypt or decrypt choice\n");
exit(-1);
}
}
else
{
fprintf(stderr,"ERROR: Invalid key\n");
exit(-1);
}
}
else
{
fprintf(stderr,"ERROR: Invalid cipher choice\n");
exit(-1);
}
return 0;
}
| [
"noreply@github.com"
] | dcberumen.noreply@github.com |
b13837131251fc1fa9b576be1be0c718373e5aea | 005cb1c69358d301f72c6a6890ffeb430573c1a1 | /Pods/Headers/Private/GeoFeatures/boost/core/demangle.hpp | 86a2f3994d3e5c7c428051ad9ea024b0760369be | [
"Apache-2.0"
] | permissive | TheClimateCorporation/DemoCLUs | 05588dcca687cc5854755fad72f07759f81fe673 | f343da9b41807694055151a721b497cf6267f829 | refs/heads/master | 2021-01-10T15:10:06.021498 | 2016-04-19T20:31:34 | 2016-04-19T20:31:34 | 51,960,444 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 62 | hpp | ../../../../../GeoFeatures/GeoFeatures/boost/core/demangle.hpp | [
"tommy.rogers@climate.com"
] | tommy.rogers@climate.com |
70716759376dc9127488b12ab78b09ddb25ac54c | 700f312f15170a34e6e58ce8475e42f9e7eeb7a3 | /Deputy_chef.cpp | 89e294bb41bef0fd3a79b491fbbe3d248f47a3a5 | [] | no_license | sharad4730/Codechef-feb-long-challenge-2019 | 3850c46e9db19fd88a8dde469ade7606b65c7bfe | ce77f721acc1a8ace1d7b0e66983b9e4ebe868df | refs/heads/master | 2020-05-15T11:25:54.541830 | 2019-04-19T08:19:19 | 2019-04-19T08:19:19 | 182,227,441 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,008 | cpp | #include<bits/stdc++.h>
using namespace std;
int main()
{
int t,n,value1,value2;
cin>>t;
for(int i=0;i<t;i++)
{
cin>>n;
vector<int>v1(n);
vector<int>v2(n);
for(int j=0;j<n;j++)
{
cin>>value1;
v1[j]=value1;
}
for(int j=0;j<n;j++)
{
cin>>value1;
v2[j]=value1;
}
int def=0,max=0;
for(int j=0;j<n;j++)
{
if(j==0)
{
if(v1[n-1]+v1[1]<v2[j])
def=v2[j];
}
else if(j==n-1)
{
if(v1[j-1]+v1[0]<v2[j])
def=v2[j];
}
else
{
if(v1[j-1]+v1[j+1]<v2[j])
def=v2[j];
}
if(def>max)
max=def;
}
if(max!=0)
cout<<max<<endl;
else
cout<<-1<<endl;
}
return 0;
}
| [
"noreply@github.com"
] | sharad4730.noreply@github.com |
67fa31e5b9705961d9ac7c4a42592510a9245b81 | e396ca3e9140c8a1f43c2505af6f318d40a7db1d | /unittest/logic_test/HA763_ReArbitration_82.hpp | 0d6bbb64f845ada5e7ba5b4603dadaaeaa9ed27e | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | kenji-hosokawa/rba | 4fb2c8ef84c5b8bf2d80785986abd299c9e76203 | 52a88df64dcfec8165aea32cb3052e7e74a3a709 | refs/heads/master | 2022-12-17T10:23:05.558421 | 2020-07-29T11:03:27 | 2020-07-29T11:03:27 | 274,852,993 | 0 | 0 | null | 2020-06-25T07:19:19 | 2020-06-25T07:19:19 | null | UTF-8 | C++ | false | false | 1,644 | hpp | // Copyright (c) 2019 DENSO CORPORATION. All rights reserved.
/**
* HA763_ReArbitration_82.hpp
*/
#ifndef HA763_REARBITRATION_82_HPP
#define HA763_REARBITRATION_82_HPP
#include <string>
#include "gtest/gtest.h"
#include "RBAArbitrator.hpp"
#define JSONFILE "HA763_ReArbitration_82.json"
namespace {
using namespace rba;
class HA763_ReArbitration_82 : public ::testing::Test
{
protected:
HA763_ReArbitration_82();
virtual ~HA763_ReArbitration_82();
virtual void SetUp();
virtual void TearDown();
bool isSuccess(const std::string& msg);
bool isSatisfiedConstraints(const std::string& msg);
bool isTrue(const std::string& msg, bool res);
std::string getAllocated(const std::string& msg,
const std::string& allocName);
bool isCanceled(const std::string& msg,
const std::string& contentName);
bool isActive(const std::string& msg,
const std::string& sceneName);
int32_t getProperty(const std::string& msg,
const std::string& sceneName,
const std::string& propertyName);
bool isEnableAllocatable(const std::string& msg,
const std::string& allocName);
bool isEnableContext(const std::string& msg,
const std::string& contextName);
bool isEnableScene(const std::string& msg,
const std::string& sceneName);
bool isAttenuated(const std::string& msg,
const std::string& zoneName);
protected:
rba::RBAModel* model_=nullptr;
rba::RBAArbitrator* arb_=nullptr;
std::unique_ptr<RBAResult> result_=nullptr;
};
}
#endif
| [
"nnishiguchi@jp.adit-jv.com"
] | nnishiguchi@jp.adit-jv.com |
3d6f424bd562e6f812e0118f7c8e5695fd3a1873 | 164e709dcf03ce4769c3ba8f874da0666c35bc03 | /RtTpsGalleryControllerApp/tps_gca_measureanglecmd.h | e0ae8eb47b5515ab96ef38b2daeee7f6c43b4e4d | [] | no_license | liq07lzucn/tps | b343894bcfd59a71be48bd47d6eff6e010464457 | a3be6dc50c5f9a2ff448ecff3f5df1956e26ad4f | refs/heads/master | 2021-06-23T16:35:01.349523 | 2017-08-30T08:09:02 | 2017-08-30T08:09:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,105 | h | //////////////////////////////////////////////////////////////////////////
/// Copyright, (c) Shanghai United Imaging Healthcare Inc., 2014
/// All rights reserved.
///
/// \author yuxuan.duan (mailto:yuxuan.duan@united-imaging.com)
///
/// \file tps_gca_measureanglecmd.h
/// \brief Measure Angle Command
///
/// \version 1.0
/// \date 2015/03/06
/// \
//////////////////////////////////////////////////////////////////////////
#ifndef TPS_GCA_MEASUREANGLECMD_H_
#define TPS_GCA_MEASUREANGLECMD_H_
#include "RtTpsFramework/tps_fw_command.h"
//MCSF
#include "McsfMedViewer3DArithmetic/point2d.h"
#include <list>
TPS_BEGIN_NAMESPACE
class TpsGcaMeasureAngleCmd : public TpsCommand
{
public:
/////////////////////////////////////////////////////////////////
/// \brief Constructor
///
/// \param[in]
/// \param[out]
/// \return
/// \exceptions: none
/////////////////////////////////////////////////////////////////
TpsGcaMeasureAngleCmd(const tps::LAYOUT_UNIT &unit, const std::list<Mcsf::MedViewer3D::Point2D>& anglePoints,
const float cursorX, const float cursorY, const bool actionStarted, const bool firstSideDone, const bool secondSideDone);
/////////////////////////////////////////////////////////////////
/// \brief Destructor
///
/// \param[in]
/// \param[out]
/// \return
/// \exceptions: none
/////////////////////////////////////////////////////////////////
~TpsGcaMeasureAngleCmd();
protected:
virtual bool PreExecute();
virtual bool Execute();
virtual bool PostExecute();
TpsGcaMeasureAngleCmd * Clone();
private:
tps::LAYOUT_UNIT mUnit;
std::list<Mcsf::MedViewer3D::Point2D> mAnglePoints;
float mCursorX;
float mCursorY;
bool mActionStarted;
bool mFirstSideDone;
bool mSecondSideDone;
//private:
// TPS_DISALLOW_COPY_AND_ASSIGN(MeasureAngleCmd);
};
TPS_END_NAMESPACE
#endif | [
"genius52@qq.com"
] | genius52@qq.com |
bbf47f9d7093e83a8ce9b36ca51915a2bef584a3 | 73ee941896043f9b3e2ab40028d24ddd202f695f | /external/chromium_org/chrome/browser/sync_file_system/local/local_file_sync_status.cc | 230f6c4d0bc2a0391343e270f9d84ffcffe76e33 | [
"BSD-3-Clause"
] | permissive | CyFI-Lab-Public/RetroScope | d441ea28b33aceeb9888c330a54b033cd7d48b05 | 276b5b03d63f49235db74f2c501057abb9e79d89 | refs/heads/master | 2022-04-08T23:11:44.482107 | 2016-09-22T20:15:43 | 2016-09-22T20:15:43 | 58,890,600 | 5 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 2,937 | cc | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/sync_file_system/local/local_file_sync_status.h"
#include "base/logging.h"
using fileapi::FileSystemURL;
using fileapi::FileSystemURLSet;
namespace sync_file_system {
LocalFileSyncStatus::LocalFileSyncStatus() {}
LocalFileSyncStatus::~LocalFileSyncStatus() {}
void LocalFileSyncStatus::StartWriting(const FileSystemURL& url) {
DCHECK(CalledOnValidThread());
DCHECK(!IsChildOrParentSyncing(url));
writing_[url]++;
}
void LocalFileSyncStatus::EndWriting(const FileSystemURL& url) {
DCHECK(CalledOnValidThread());
int count = --writing_[url];
if (count == 0) {
writing_.erase(url);
FOR_EACH_OBSERVER(Observer, observer_list_, OnSyncEnabled(url));
}
}
void LocalFileSyncStatus::StartSyncing(const FileSystemURL& url) {
DCHECK(CalledOnValidThread());
DCHECK(!IsChildOrParentWriting(url));
DCHECK(!IsChildOrParentSyncing(url));
syncing_.insert(url);
}
void LocalFileSyncStatus::EndSyncing(const FileSystemURL& url) {
DCHECK(CalledOnValidThread());
syncing_.erase(url);
FOR_EACH_OBSERVER(Observer, observer_list_, OnWriteEnabled(url));
}
bool LocalFileSyncStatus::IsWriting(const FileSystemURL& url) const {
DCHECK(CalledOnValidThread());
return IsChildOrParentWriting(url);
}
bool LocalFileSyncStatus::IsWritable(const FileSystemURL& url) const {
DCHECK(CalledOnValidThread());
return !IsChildOrParentSyncing(url);
}
bool LocalFileSyncStatus::IsSyncable(const FileSystemURL& url) const {
DCHECK(CalledOnValidThread());
return !IsChildOrParentSyncing(url) && !IsChildOrParentWriting(url);
}
void LocalFileSyncStatus::AddObserver(Observer* observer) {
DCHECK(CalledOnValidThread());
observer_list_.AddObserver(observer);
}
void LocalFileSyncStatus::RemoveObserver(Observer* observer) {
DCHECK(CalledOnValidThread());
observer_list_.RemoveObserver(observer);
}
bool LocalFileSyncStatus::IsChildOrParentWriting(
const FileSystemURL& url) const {
DCHECK(CalledOnValidThread());
URLCountMap::const_iterator upper = writing_.upper_bound(url);
URLCountMap::const_reverse_iterator rupper(upper);
if (upper != writing_.end() && url.IsParent(upper->first))
return true;
if (rupper != writing_.rend() &&
(rupper->first == url || rupper->first.IsParent(url)))
return true;
return false;
}
bool LocalFileSyncStatus::IsChildOrParentSyncing(
const FileSystemURL& url) const {
DCHECK(CalledOnValidThread());
FileSystemURLSet::const_iterator upper = syncing_.upper_bound(url);
FileSystemURLSet::const_reverse_iterator rupper(upper);
if (upper != syncing_.end() && url.IsParent(*upper))
return true;
if (rupper != syncing_.rend() &&
(*rupper == url || rupper->IsParent(url)))
return true;
return false;
}
} // namespace sync_file_system
| [
"ProjectRetroScope@gmail.com"
] | ProjectRetroScope@gmail.com |
8c759911f8395807309b633f8f94c2722d854177 | 91604aa0369c53e8c76f48039ef4f72b994160dd | /SearchTree/main.cpp | 5785fb5dd1543fb6295a95441679cd8220c7c2aa | [] | no_license | Devang-25/dev_cpp | 391a32baa1ddf765849e945a616f783f2fca56cf | 6847f85e5b35b7c2d23acad935d4ae752f1c5b56 | refs/heads/master | 2023-01-30T16:32:56.134960 | 2020-09-05T00:55:39 | 2020-09-05T00:55:39 | 308,292,954 | 0 | 0 | null | 2020-12-18T18:32:04 | 2020-10-29T10:27:28 | null | UTF-8 | C++ | false | false | 6,675 | cpp | #include <iostream>
#include "LinkedBinaryTree.h"
using namespace std;
template <typename K, typename V>
class Entry//a (key, value) pair
{
public://public types
typedef K Key;//key type
typedef V Value;//value type
public://public functions
Entry(const K& k = K(), const V& v = V())//constructor
: _key(k), _value(v) { }
const K& key() const//get key (read only)
{
return _key;
}
const V& value() const//get value (read only)
{
return _value;
}
void setKey(const K& k)//set key
{
_key = k;
}
void setValue(const V& v)//set value
{
_value = v;
}
private://private data
K _key;//key
V _value;//value
};
class RuntimeException
{
// generic run-time exception
private:
string errorMsg;
public:
RuntimeException(const string& err)
{
errorMsg = err;
}
string getMessage() const
{
return errorMsg;
}
};
class NonexistentElement : public RuntimeException
{
public:
NonexistentElement(const string& err) : RuntimeException(err) { }
};
template <typename E>
class SearchTree //a binary search tree
{
public://public types
typedef typename E::Key K;//a key
typedef typename E::Value V;//a value
class Iterator;//an iterator/position
public://public functions
SearchTree();//constructor
int size() const;//number of entries
bool empty() const;//is the tree empty?
Iterator find(const K& k);//find entry with key k
Iterator insert(const K& k, const V& x);//insert (k,x)
void erase(const K& k);// remove key k entry
void erase(const Iterator& p);//remove entry at p
Iterator begin();//iterator to first entry
Iterator end();//iterator to end entry
protected://local utilities
typedef LinkedBinaryTree<E> BinaryTree;//linked binary tree
typedef typename BinaryTree::Position TPos;//position in the tree
TPos root() const;//get virtual root
TPos finder(const K& k, const TPos& v);//find utility
TPos inserter(const K& k, const V& x);//insert utility
TPos eraser(TPos& v);//erase utility
TPos restructure(const TPos& v);//restructure
private://member data
BinaryTree T;//the binary tree
int n;//number of entries
public:
// . . .insert Iterator class declaration here
class Iterator
{
// an iterator/position
private:
TPos v;// which entry
public:
Iterator(const TPos& vv) : v(vv) { }// constructor
const E& operator*() const// get entry (read only)
{
return *v;
}
E& operator*()// get entry (read/write)
{
return *v;
}
bool operator==(const Iterator& p) const// are iterators equal?
{
return v == p.v;
}
Iterator& operator++();// inorder successor
friend class SearchTree;// give search tree access
};
};
template <typename E>
typename SearchTree<E>::Iterator& SearchTree<E>::Iterator::operator++()// inorder successor
{
TPos w = v.right();
if (w.isInternal())// have right subtree?
{
do// move down left chain
{
v = w;
w = w.left();
}
while (w.isInternal());
}
else
{
w = v.parent();// get parent
while (v == w.right())// move up right chain
{
v = w;
w = w.parent();
}
v = w;// and first link to left
}
return *this;
}
template <typename E>
SearchTree<E>::SearchTree() : T(), n(0)// constructor
{
T.addRoot(); // create the super root
T.expandExternal(T.root());
}
template <typename E>
typename SearchTree<E>::TPos SearchTree<E>::root() const// get virtual root
{
return T.root().left();// left child of super root
}
template <typename E>
typename SearchTree<E>::Iterator SearchTree<E>::begin()// iterator to first entry
{
TPos v = root();// start at virtual root
while (v.isInternal())// find leftmost node
v = v.left();
return Iterator(v.parent());
}
template <typename E>
typename SearchTree<E>::Iterator SearchTree<E>::end()// iterator to end entry
{
return Iterator(T.root());// return the super root
}
template <typename E>// find utility
typename SearchTree<E>::TPos SearchTree<E>::finder(const K& k, const TPos& v)
{
if (v.isExternal())
return v;// key not found
if (k < v->key())
return finder(k, v.left());// search left subtree
else if (v->key() < k)
return finder(k, v.right()); // search right subtree
else
return v;// found it here
}
template <typename E>
typename SearchTree<E>::Iterator SearchTree<E>::find(const K& k) // find entry with key k
{
TPos v = finder(k, root());// search from virtual root
if (v.isInternal())
return Iterator(v);// found it
else
return end();// didn’t find it
}
template <typename E>
typename SearchTree<E>::TPos SearchTree<E>::inserter(const K& k, const V& x)// insert utility
{
TPos v = finder(k, root());//search from virtual root
while (v.isInternal())//key already exists?
v = finder(k, v.right());//look further
T.expandExternal(v);//add new internal node
v->setKey(k);//set entry
v->setValue(x);//
n++;//one more entry
return v;//return insert position
}
template <typename E>// insert (k,x)
typename SearchTree<E>::Iterator SearchTree<E>::insert(const K& k, const V& x)
{
TPos v = inserter(k, x);
return Iterator(v);
}
template <typename E>// remove utility
typename SearchTree<E>::TPos SearchTree<E>::eraser(TPos& v)
{
TPos w;
if (v.left().isExternal())
w = v.left();// remove from left
else if (v.right().isExternal())
w = v.right();// remove from right
else
{// both internal?
w = v.right();// go to right subtree
do
{
w = w.left();
}
while (w.isInternal());// get leftmost node
TPos u = w.parent();
v->setKey(u->key());
v->setValue(u->value()); // copy w’s parent to v
}
n--;// one less entry
return T.removeAboveExternal(w);// remove w and parent
}
/* SearchTreehEi :: */
template <typename E>// remove key k entry
void SearchTree<E>::erase(const K& k)
{
TPos v = finder(k, root());// search from virtual root
if (v.isExternal())// not found?
throw NonexistentElement("Erase of nonexistent");
eraser(v);// remove it
}
/* SearchTreehEi :: */
template <typename E>
void SearchTree<E>::erase(const Iterator& p)
{
eraser(p.v);// erase entry at p
}
int main()
{
cout << "Hello world!" << endl;
return 0;
}
| [
"nsikanikpoh@gmail.com"
] | nsikanikpoh@gmail.com |
7b97b4a6434cae2a7518847edf1fb1e924a15771 | 26a98d525b0ce11bab718fe11a1f3c22e6d823f5 | /Source/Engine/Core/Timer.cpp | c47735bd21853ba311f71bbe570cfb1d08b19025 | [
"Apache-2.0",
"BSD-2-Clause",
"MIT",
"Zlib",
"LicenseRef-scancode-khronos",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | pyzhangxiang/Urho3D | dfd1128bb4ebe3eeae07ff49625473002789ba75 | dbb8d077dae00a3b96f9740cfb47c0ab084d19a1 | refs/heads/master | 2021-01-21T05:05:09.383038 | 2014-01-10T09:41:52 | 2014-01-10T09:41:52 | 15,806,907 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,570 | cpp | //
// Copyright (c) 2008-2013 the Urho3D project.
//
// 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 "Precompiled.h"
#include "CoreEvents.h"
#include "Profiler.h"
#include "Timer.h"
#include <ctime>
#ifdef WIN32
#include <windows.h>
#include <mmsystem.h>
#else
#include <sys/time.h>
#include <unistd.h>
#endif
#include "DebugNew.h"
namespace Urho3D
{
bool HiresTimer::supported(false);
long long HiresTimer::frequency(1000);
Time::Time(Context* context) :
Object(context),
frameNumber_(0),
timeStep_(0.0f),
timerPeriod_(0)
{
#ifdef WIN32
LARGE_INTEGER frequency;
if (QueryPerformanceFrequency(&frequency))
{
HiresTimer::frequency = frequency.QuadPart;
HiresTimer::supported = true;
}
#else
HiresTimer::frequency = 1000000;
HiresTimer::supported = true;
#endif
}
Time::~Time()
{
SetTimerPeriod(0);
}
void Time::BeginFrame(float timeStep)
{
++frameNumber_;
if (!frameNumber_)
++frameNumber_;
timeStep_ = timeStep;
Profiler* profiler = GetSubsystem<Profiler>();
if (profiler)
profiler->BeginFrame();
{
PROFILE(BeginFrame);
// Frame begin event
using namespace BeginFrame;
VariantMap eventData;
eventData[P_FRAMENUMBER] = frameNumber_;
eventData[P_TIMESTEP] = timeStep_;
SendEvent(E_BEGINFRAME, eventData);
}
}
void Time::EndFrame()
{
{
PROFILE(EndFrame);
// Frame end event
SendEvent(E_ENDFRAME);
}
Profiler* profiler = GetSubsystem<Profiler>();
if (profiler)
profiler->EndFrame();
}
void Time::SetTimerPeriod(unsigned mSec)
{
#ifdef WIN32
if (timerPeriod_ > 0)
timeEndPeriod(timerPeriod_);
timerPeriod_ = mSec;
if (timerPeriod_ > 0)
timeBeginPeriod(timerPeriod_);
#endif
}
float Time::GetElapsedTime()
{
return elapsedTime_.GetMSec(false) / 1000.0f;
}
unsigned Time::GetSystemTime()
{
#ifdef WIN32
unsigned currentTime = timeGetTime();
#else
struct timeval time;
gettimeofday(&time, NULL);
unsigned currentTime = time.tv_sec * 1000 + time.tv_usec / 1000;
#endif
return currentTime;
}
String Time::GetTimeStamp()
{
time_t sysTime;
time(&sysTime);
const char* dateTime = ctime(&sysTime);
return String(dateTime).Replaced("\n", "");
}
void Time::Sleep(unsigned mSec)
{
#ifdef WIN32
::Sleep(mSec);
#else
usleep(mSec * 1000);
#endif
}
Timer::Timer()
{
Reset();
}
unsigned Timer::GetMSec(bool reset)
{
#ifdef WIN32
unsigned currentTime = timeGetTime();
#else
struct timeval time;
gettimeofday(&time, NULL);
unsigned currentTime = time.tv_sec * 1000 + time.tv_usec / 1000;
#endif
unsigned elapsedTime = currentTime - startTime_;
if (reset)
startTime_ = currentTime;
return elapsedTime;
}
void Timer::Reset()
{
#ifdef WIN32
startTime_ = timeGetTime();
#else
struct timeval time;
gettimeofday(&time, NULL);
startTime_ = time.tv_sec * 1000 + time.tv_usec / 1000;
#endif
}
HiresTimer::HiresTimer()
{
Reset();
}
long long HiresTimer::GetUSec(bool reset)
{
long long currentTime;
#ifdef WIN32
if (supported)
{
LARGE_INTEGER counter;
QueryPerformanceCounter(&counter);
currentTime = counter.QuadPart;
}
else
currentTime = timeGetTime();
#else
struct timeval time;
gettimeofday(&time, NULL);
currentTime = time.tv_sec * 1000000LL + time.tv_usec;
#endif
long long elapsedTime = currentTime - startTime_;
// Correct for possible weirdness with changing internal frequency
if (elapsedTime < 0)
elapsedTime = 0;
if (reset)
startTime_ = currentTime;
return (elapsedTime * 1000000LL) / frequency;
}
void HiresTimer::Reset()
{
#ifdef WIN32
if (supported)
{
LARGE_INTEGER counter;
QueryPerformanceCounter(&counter);
startTime_ = counter.QuadPart;
}
else
startTime_ = timeGetTime();
#else
struct timeval time;
gettimeofday(&time, NULL);
startTime_ = time.tv_sec * 1000000LL + time.tv_usec;
#endif
}
}
| [
"loorni@gmail.com"
] | loorni@gmail.com |
79463a9d34ed1ab826ce7f01f379c290f68bb1e6 | 5c51cbdca581f57404337f8e47ddd972db116ed9 | /APS/naloga11/main.cpp | 8451a66ac039fde35e80afea7ba05e260eea0e88 | [] | no_license | AlexBrence/CLionProjects | 3ec7c45dc32060e16b0e0521e310c5964b2d4d93 | 3ba786184cd07f4abbccf6b01aafb409cccc3547 | refs/heads/main | 2023-05-06T07:36:47.392424 | 2021-06-03T16:55:46 | 2021-06-03T16:55:46 | 373,581,445 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,080 | cpp | #include <chrono>
#include <fstream>
#include <iostream>
#include <memory>
#include <vector>
struct Pot {
int iz_vozlisca, v_vozlisce, cena;
std::vector<bool> mnozica;
};
// Variables
unsigned int steviloVozlisc;
std::vector<int> matrikaSosednosti;
std::vector<Vozlisce> vozlisca;
bool running = true;
void napaka(const std::string& what = "") {
std::cout << "***** NAPAKA: " << what;
}
bool beriIzDatoteke(const std::string& pot) {
unsigned int cena;
std::ifstream f("/home/alex/CLionProjects/APS/naloga11/graf1.txt");
if (!f.is_open()) return false;
f >> steviloVozlisc;
vozlisca.reserve(steviloVozlisc);
matrikaSosednosti.reserve(steviloVozlisc * steviloVozlisc - 1);
for (unsigned int i = 0; i < steviloVozlisc; i++) {
Vozlisce tmp = {i + 1, -1, 0};
vozlisca.push_back(tmp);
}
while (f >> cena) {
matrikaSosednosti.push_back(cena);
}
return true;
}
void meni() {
int choice, input, zacetnoVozlisce, koncnoVozlisce, cena;
std::string potDoDatoteke;
std::cout << "Trgovski potnik - izbira\n\n";
std::cout << "1) Preberi matriko\n";
std::cout << "2) Resi problem trgovskega potnika\n";
std::cout << "3) Izpisi dobljen seznam nivojev\n";
std::cout << "4) Rekonstrukcija poti\n";
std::cout << "5) Izhod\n\n";
std::cout << "Izbira: ";
std::cin >> choice;
std::cout << "\n";
switch(choice) {
case 1:
// std::cout << "Vpisi pot do datoteke: ";
// std::cin >> potDoDatoteke;
if (!beriIzDatoteke(potDoDatoteke)) {
napaka("Datoteka ne obstaja!");
}
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
std::cout << "Program se je zakljucil.";
running = false;
break;
default:
napaka("Napačna izbira");
break;
}
std::cout << "\n\n";
}
int main() {
while (running) {
meni();
}
return 0;
}
| [
"alexbrence10@gmail.com"
] | alexbrence10@gmail.com |
41435859ce8499152af74c2937d207a282249b13 | 522a944acfc5798d6fb70d7a032fbee39cc47343 | /d6k/trunk/src/advapp/powerprediction/proportionalgorithm.cpp | 7bf21e2ec2b1d50e47928d57d6fde14faa77f7e0 | [] | no_license | liuning587/D6k2.0master | 50275acf1cb0793a3428e203ac7ff1e04a328a50 | 254de973a0fbdd3d99b651ec1414494fe2f6b80f | refs/heads/master | 2020-12-30T08:21:32.993147 | 2018-03-30T08:20:50 | 2018-03-30T08:20:50 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 8,352 | cpp | #include "proportionalgorithm.h"
#include "predictdatabase.h"
#include <QDebug>
CProportionAlgorithm::CProportionAlgorithm()
{
a_Alias.append(DaqoWeather_TotalRadiation);
a_Alias.append(DaqoPower_TotalPower);
a_Info = GetAnaloguesInfo(a_Alias);
QVector<data_type> vec_4h(Power_Predict_4h_Points);
QVector<data_type> vec_72h(Power_Predict_72h_Points);
for each (const QString & str in a_Alias)
{
map_yesterday_4h.insert(str, vec_4h);
map_yesterday_72h.insert(str, vec_72h);
}
QList<Weather_Type> listType;
listType.append(Weather_Total_Radiation);
InsertWeatherType4h(map_predict_weather_4h, listType);
InsetWeatherType72h(map_predict_weather_72h, listType);
map_weather_analogues_alias.insert(Weather_Total_Radiation, DaqoWeather_TotalRadiation);
}
CProportionAlgorithm::~CProportionAlgorithm()
{
}
void CProportionAlgorithm::InsertWeatherType4h(QMap<Weather_Type, Weather_Predict_Data> & map, Weather_Type type)
{
Weather_Predict_Data weatherPredictData4h(Weather_Predict_4h_Points);
map.insert(type, weatherPredictData4h);
}
void CProportionAlgorithm::InsertWeatherType4h(QMap<Weather_Type, Weather_Predict_Data> & map, QList<Weather_Type> listType)
{
Weather_Predict_Data weatherPredictData4h(Weather_Predict_4h_Points);
for each (Weather_Type type in listType)
{
map.insert(type, weatherPredictData4h);
}
}
void CProportionAlgorithm::InsetWeatherType72h(QMap<Weather_Type, Weather_Predict_Data> & map, Weather_Type type)
{
Weather_Predict_Data weatherPredictData72h(Weather_Predict_72h_Points);
map.insert(type, weatherPredictData72h);
}
void CProportionAlgorithm::InsetWeatherType72h(QMap<Weather_Type, Weather_Predict_Data> & map, QList<Weather_Type> listType)
{
Weather_Predict_Data weatherPredictData72h(Weather_Predict_72h_Points);
for each (Weather_Type type in listType)
{
map.insert(type, weatherPredictData72h);
}
}
/*! \fn void CProportionAlgorithm::PowerPredict4h(const QDateTime &currTime)
********************************************************************************************************************************
** \brief PowerPredict4h
** \details 4h功率预测算法
** \return void
** \author GuoHaijun
** \date 2016年1月12日
** \note
*******************************************************************************************************************************/
void CProportionAlgorithm::PowerPredict4h(const QDateTime &currTime)
{
QDateTime predictStartTime, predictEndTime;
QVector<data_type> maintenanceValues;
QString strTime;
bool isFind4h = false;
predictStartTime = currTime.addSecs(15 * 60);
int hour = predictStartTime.time().hour();
int minu = (predictStartTime.time().minute() / 15) * 15;
strTime = QString("%1 %2:%3:00").arg(predictStartTime.toString("yyyy-MM-dd")).arg(hour, 2, 10, QChar('0')).arg(minu, 2, 10, QChar('0'));
predictStartTime = QDateTime::fromString(strTime, "yyyy-MM-dd hh:mm:ss");
predictEndTime = predictStartTime.addSecs(60 * 60 * 4 - 15 * 60);
if ((currTime.time().hour() <= PREDICTDAQO::Power_Predict_Morning_Hour) || (currTime.time().hour() >= PREDICTDAQO::Power_Predict_Afternon_Hour))
{
for (int i = 0; i < Power_Predict_4h_Points; i++)
{
power_predict_data_4h.data[i] = 0;
}
CPredictDatabase::GetInstance().InsertDataPowerPredict4h(power_predict_data_4h, currTime);
return;
}
QDateTime time = currTime.addDays(-1).addSecs(15 * 60);
if (CPredictDatabase::GetInstance().GetYesterday_Value_4h(time,a_Info,map_yesterday_4h))
{
if (CPredictDatabase::GetInstance().GetData_WeatherPredict4h(map_predict_weather_4h, predictStartTime))
{
maintenanceValues = CPredictDatabase::GetInstance().GetMaintenanceValue(predictStartTime, predictEndTime);
for (int i = 0; i < Power_Predict_4h_Points; i++)
{
if ( map_yesterday_4h[DaqoWeather_TotalRadiation][i] != 0 )
{
power_predict_data_4h.data[i] = map_predict_weather_4h[Weather_Total_Radiation][i] / map_yesterday_4h[DaqoWeather_TotalRadiation][i] * map_yesterday_4h[DaqoPower_TotalPower][i];
power_predict_data_4h.data[i] = power_predict_data_4h.data[i] - maintenanceValues[i];
if (power_predict_data_4h.data[i] < 0)
{
power_predict_data_4h.data[i] = 0;
}
if (power_predict_data_4h.data[i] > capacity)
{
power_predict_data_4h.data[i] = capacity;
}
}
else
{
for (int j = 0; j < Power_Predict_4h_Points; j++)
{
if (map_yesterday_4h[DaqoWeather_TotalRadiation][j] != 0)
{
power_predict_data_4h.data[i] = map_predict_weather_4h[Weather_Total_Radiation][i] / map_yesterday_4h[DaqoWeather_TotalRadiation][j] * map_yesterday_4h[DaqoPower_TotalPower][j];
power_predict_data_4h.data[i] = power_predict_data_4h.data[i] - maintenanceValues[i];
if (power_predict_data_4h.data[i] < 0)
{
power_predict_data_4h.data[i] = 0;
}
if (power_predict_data_4h.data[i] > capacity)
{
power_predict_data_4h.data[i] = capacity;
}
isFind4h = true;
break;
}
}
if (!isFind4h)
{
power_predict_data_4h.data[i] = 0;
}
}
}
CPredictDatabase::GetInstance().InsertDataPowerPredict4h(power_predict_data_4h, predictStartTime);
}
else
{
qDebug() << "get_4h_weather_predict_data error!";
return;
}
}
else
{
qDebug() << "get_yesterday_4h_data error!";
return;
}
qDebug() << "4h proportion algorithm success...";
return;
}
/*! \fn void CProportionAlgorithm::PowerPredict72h(const QDateTime &currTime)
********************************************************************************************************************************
** \brief PowerPredict72h
** \details 72h功率预测算法
** \return void
** \author GuoHaijun
** \date 2016年1月12日
** \note
*******************************************************************************************************************************/
void CProportionAlgorithm::PowerPredict72h(const QDateTime &currTime)
{
QDateTime predictStartTime, predictEndTime;
QVector<data_type> maintenanceValues;
bool isFind72h = false;
QDateTime time = QDateTime::fromString(currTime.toString("yyyy-MM-dd 00:00:00"), "yyyy-MM-dd hh:mm:ss");
predictStartTime = time.addDays(1);
predictEndTime = time.addDays(4);
if (CPredictDatabase::GetInstance().GetYesterday_Value_72h(time, a_Info, map_yesterday_72h))
{
if (CPredictDatabase::GetInstance().GetData_WeatherPredict72h(map_predict_weather_72h, currTime))
{
maintenanceValues = CPredictDatabase::GetInstance().GetMaintenanceValue(predictStartTime, predictEndTime);
for (int i = 0; i < Power_Predict_72h_Points; i++ )
{
if ( map_yesterday_72h[DaqoWeather_TotalRadiation][i] != 0 )
{
power_predict_data_72h.data[i] = map_predict_weather_72h[Weather_Total_Radiation][i] / map_yesterday_72h[DaqoWeather_TotalRadiation][i] * map_yesterday_72h[DaqoPower_TotalPower][i];
power_predict_data_72h.data[i] = power_predict_data_72h.data[i] - maintenanceValues[i];
if (power_predict_data_72h.data[i] < 0)
{
power_predict_data_72h.data[i] = 0;
}
if (power_predict_data_72h.data[i] > capacity)
{
power_predict_data_72h.data[i] = capacity;
}
}
else
{
for (int j = 0; j < Power_Predict_72h_Points; j++)
{
if (map_yesterday_72h[DaqoWeather_TotalRadiation][j] != 0)
{
power_predict_data_72h.data[i] = map_predict_weather_72h[Weather_Total_Radiation][i]/map_yesterday_72h[DaqoWeather_TotalRadiation][j] * map_yesterday_72h[DaqoPower_TotalPower][j];
power_predict_data_72h.data[i] = power_predict_data_72h.data[i] - maintenanceValues[i];
if (power_predict_data_72h.data[i] < 0)
{
power_predict_data_72h.data[i] = 0;
}
if (power_predict_data_72h.data[i] > capacity)
{
power_predict_data_72h.data[i] = capacity;
}
isFind72h = true;
break;
}
}
if (!isFind72h)
{
power_predict_data_72h.data[i] = 0;
}
}
}
CPredictDatabase::GetInstance().InsertDataPowerPredict72h(power_predict_data_72h, currTime);
}
else
{
qDebug() << "get_72h_weather_predict_data error!";
return;
}
}
else
{
qDebug()<< "get_yesterday_72h_data error!";
return;
}
qDebug()<< "72h proportion algorithm success...";
return;
} | [
"xingzhibing_ab@hotmail.com"
] | xingzhibing_ab@hotmail.com |
f392d19a66be2c803cef968b310e06cfcc600918 | 140d78334109e02590f04769ec154180b2eaf78d | /aws-cpp-sdk-resourcegroupstaggingapi/include/aws/resourcegroupstaggingapi/model/ResourceTagMapping.h | 4fc9c82195fe841095d81ae6851a2cce344d38d6 | [
"Apache-2.0",
"MIT",
"JSON"
] | permissive | coderTong/aws-sdk-cpp | da140feb7e5495366a8d2a6a02cf8b28ba820ff6 | 5cd0c0a03b667c5a0bd17394924abe73d4b3754a | refs/heads/master | 2021-07-08T07:04:40.181622 | 2017-08-22T21:50:00 | 2017-08-22T21:50:00 | 101,145,374 | 0 | 1 | Apache-2.0 | 2021-05-04T21:06:36 | 2017-08-23T06:24:37 | C++ | UTF-8 | C++ | false | false | 4,383 | h | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#pragma once
#include <aws/resourcegroupstaggingapi/ResourceGroupsTaggingAPI_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/resourcegroupstaggingapi/model/Tag.h>
#include <utility>
namespace Aws
{
namespace Utils
{
namespace Json
{
class JsonValue;
} // namespace Json
} // namespace Utils
namespace ResourceGroupsTaggingAPI
{
namespace Model
{
/**
* <p>A list of resource ARNs and the tags (keys and values) that are associated
* with each.</p><p><h3>See Also:</h3> <a
* href="http://docs.aws.amazon.com/goto/WebAPI/resourcegroupstaggingapi-2017-01-26/ResourceTagMapping">AWS
* API Reference</a></p>
*/
class AWS_RESOURCEGROUPSTAGGINGAPI_API ResourceTagMapping
{
public:
ResourceTagMapping();
ResourceTagMapping(const Aws::Utils::Json::JsonValue& jsonValue);
ResourceTagMapping& operator=(const Aws::Utils::Json::JsonValue& jsonValue);
Aws::Utils::Json::JsonValue Jsonize() const;
/**
* <p>An array of resource ARN(s).</p>
*/
inline const Aws::String& GetResourceARN() const{ return m_resourceARN; }
/**
* <p>An array of resource ARN(s).</p>
*/
inline void SetResourceARN(const Aws::String& value) { m_resourceARNHasBeenSet = true; m_resourceARN = value; }
/**
* <p>An array of resource ARN(s).</p>
*/
inline void SetResourceARN(Aws::String&& value) { m_resourceARNHasBeenSet = true; m_resourceARN = std::move(value); }
/**
* <p>An array of resource ARN(s).</p>
*/
inline void SetResourceARN(const char* value) { m_resourceARNHasBeenSet = true; m_resourceARN.assign(value); }
/**
* <p>An array of resource ARN(s).</p>
*/
inline ResourceTagMapping& WithResourceARN(const Aws::String& value) { SetResourceARN(value); return *this;}
/**
* <p>An array of resource ARN(s).</p>
*/
inline ResourceTagMapping& WithResourceARN(Aws::String&& value) { SetResourceARN(std::move(value)); return *this;}
/**
* <p>An array of resource ARN(s).</p>
*/
inline ResourceTagMapping& WithResourceARN(const char* value) { SetResourceARN(value); return *this;}
/**
* <p>The tags that have been applied to one or more AWS resources.</p>
*/
inline const Aws::Vector<Tag>& GetTags() const{ return m_tags; }
/**
* <p>The tags that have been applied to one or more AWS resources.</p>
*/
inline void SetTags(const Aws::Vector<Tag>& value) { m_tagsHasBeenSet = true; m_tags = value; }
/**
* <p>The tags that have been applied to one or more AWS resources.</p>
*/
inline void SetTags(Aws::Vector<Tag>&& value) { m_tagsHasBeenSet = true; m_tags = std::move(value); }
/**
* <p>The tags that have been applied to one or more AWS resources.</p>
*/
inline ResourceTagMapping& WithTags(const Aws::Vector<Tag>& value) { SetTags(value); return *this;}
/**
* <p>The tags that have been applied to one or more AWS resources.</p>
*/
inline ResourceTagMapping& WithTags(Aws::Vector<Tag>&& value) { SetTags(std::move(value)); return *this;}
/**
* <p>The tags that have been applied to one or more AWS resources.</p>
*/
inline ResourceTagMapping& AddTags(const Tag& value) { m_tagsHasBeenSet = true; m_tags.push_back(value); return *this; }
/**
* <p>The tags that have been applied to one or more AWS resources.</p>
*/
inline ResourceTagMapping& AddTags(Tag&& value) { m_tagsHasBeenSet = true; m_tags.push_back(std::move(value)); return *this; }
private:
Aws::String m_resourceARN;
bool m_resourceARNHasBeenSet;
Aws::Vector<Tag> m_tags;
bool m_tagsHasBeenSet;
};
} // namespace Model
} // namespace ResourceGroupsTaggingAPI
} // namespace Aws
| [
"henso@amazon.com"
] | henso@amazon.com |
fdcbdcf5a6adbed9a99cfc3282ac4bcf544b43a9 | b3279f2ee83f7e0f77be7a30073b4d790a930d30 | /PacMan/PacMan/Mapa.h | 1a90c74a52dcb1ed8d81e1b4412fc871a91810da | [] | no_license | DawidSiuda/Pac-Man | 8d7ebb6527fc90ee3c49a3503afa2a879294321a | aba4a4064b199c45ad4023b17c812cd120cc0463 | refs/heads/master | 2021-06-20T22:29:51.749516 | 2017-05-31T21:27:55 | 2017-05-31T21:27:55 | 91,239,086 | 1 | 0 | null | null | null | null | WINDOWS-1250 | C++ | false | false | 1,465 | h | #pragma once
#include "Kolizja.h"
#include "PacMan.h"
#include "Struktury.cpp"
#include "Napis.h"
#include <SFML/Graphics.hpp>
#include <string>
#include <iostream>
#include <fstream>
#include <conio.h>
using namespace sf;
using namespace std;
class Mapa
{
public:
const short pozycja_x; // x w którym rozpoczyna się mapa w oknie głównym
const short pozycja_y; // y w którym rozpoczyna się mapa w oknie głównym
int wczytajMapeZPliku(string = "mapa.txt");
int iloscKolizji(); //zwraca ilosc kolizji zdefiniowanych na mapie
void rysuj_kolizje(RenderWindow *okno); //rysuje punkty kolizyjne mapy, w oknie do którego podano mu wskażnik
bool WczytanoMape(); //zwraca wartosc bool "WczytywanieZakonczonePowodzeniem"
Kolizja *dajMapeKolizji(); //zwraca mape kolizji planszy
Sprite rysuj(); //zwraca wielokąt w którym wyswietlana jest mapa
Wektor dajStartPacMan(); //zwraca pozycje startową pacmana pobrana z pliku .txt z mapa
Mapa(int pozycja_poczatkowa_x = 0,
int pozycja_poczatkowa_y = 0);
~Mapa();
friend class Kolizja;
private:
int rozmiarMapyX;
int rozmiarMapyY;
int ileKolizji;
float StartBohateraX;
float StartBohateraY;
bool WczytywanieZakonczonePowodzeniem;
Sprite Obraz; //wielokąt w którym wyswietlana jest mapa
Texture tekstura;//obraz mapy pobierany z pliku jpg
string nazwaMapy;
Kolizja *mapaKolizjiZPliku;
bool sprawdzCzyliczba(string);//sprawdza czy string przechowuje liczbe
};
| [
"dawid.siuda@onet.eu"
] | dawid.siuda@onet.eu |
9c27399774dfd690f84d8f207142d9ecf2919545 | 8d5ca7e9f9b1f8c1878298a9e6876a346a5db72f | /space_racers/original_version/sr_src/include/Mesh/FpsCamera.h | dd8fca5212675f37c95eae07beace23939305e5f | [
"LicenseRef-scancode-public-domain",
"Zlib"
] | permissive | fallahn/osgc | 102914dc740796cdc53cbc225038eee8695716ec | 8a2f7745bd767e68da2b0771ecf3e7d50e59e725 | refs/heads/master | 2021-06-20T11:33:04.473998 | 2021-02-11T13:16:53 | 2021-02-11T13:16:53 | 178,931,498 | 23 | 3 | null | 2020-04-21T10:39:17 | 2019-04-01T19:18:19 | C++ | UTF-8 | C++ | false | false | 1,563 | h | ///a camera with realtime input which creates an first person style view///
// controllable with configurable mouse / keyboard
#ifndef FPS_CAMERA_H_
#define FPS_CAMERA_H_
#include <Mesh/Camera.h>
#include <SFML/Graphics/RenderWindow.hpp>
#include <SFML/Window.hpp>
namespace ml
{
class FpsCamera final : public Camera
{
public:
enum Input
{
FORWARD,
BACKWARD,
STRAFE_LEFT,
STRAFE_RIGHT,
PITCH_UP,
PITCH_DOWN,
YAW_LEFT,
YAW_RIGHT
};
//represents a first person camera by adding keyboard input to camera class
FpsCamera(sf::RenderWindow& renderWindow);
void StrafeLeft();
void StrafeRight();
//moves into the scene
void MoveForward();
//moves out of the scene
void MoveBackward();
void Pitch(float amount = 1.f);
void Yaw(float amount = 1.f);
void Roll(float amount = 1.f);
//updates controller input
void Update(float dt);
//sets mouse speed multiplier
void SetMouseSpeed(float);
//allows assigning keys for control
void SetKey(FpsCamera::Input input, sf::Keyboard::Key key);
//enable / disable mouse input so we can override using a ui or something
void SetInputEnabled(bool b);
bool GetInputEnabled() const{return m_inputEnabled;};
private:
sf::RenderWindow& m_renderWindow;
sf::Vector2f m_screenCentre;
float m_mouseSpeed;
sf::Keyboard::Key m_keyForward, m_keyBackward;
sf::Keyboard::Key m_strafeLeft, m_strafeRight;
sf::Keyboard::Key m_pitchUp, m_pitchDown, m_yawLeft, m_yawRight;
bool m_inputEnabled;
};
}
#endif | [
"matty_styles@hotmail.com"
] | matty_styles@hotmail.com |
7efa831cd635dd2a5f6f6f931beeda6ecf955610 | 7b6935ce633d8df97ac45fad0cc5b388bedf3a03 | /Disjoint_set.cpp/uva.10685.d_set.cpp | c4a5d9fcdf9c538f56e25f6a9de99a64d570a34f | [] | no_license | rakib-ruet-13/Algorithms-and-Codes | 8f422dc5bf0a58ae699acb42d8a1ded6e250fd7d | 83a4e4d6580cd270d0b3a45ca188f8cbf8f62234 | refs/heads/master | 2020-04-25T01:09:29.894413 | 2019-02-24T22:47:34 | 2019-02-24T22:47:34 | 172,400,148 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,035 | cpp | #include<iostream>
#include<bits/stdc++.h>
using namespace std;
map<string,string>par;
map<string,int>cnt;
string find(string str)
{
if(par[str]==str)
return str;
return par[str]=find(par[str]);
}
int main()
{
map<string,string>str;
map<string,string>::iterator it;
int n,t;
while(scanf("%d %d",&n,&t)==2)
{
if(n==0)
break;
for(int i=1;i<=n;i++)
{
string s;
cin>>s;
par[s]=s;
cnt[s]=1;
}
string str1,str2;
for(int i=1; i<=t ;i++)
{
cin>>str1>>str2;
string u=find(str1);
string v=find(str2);
if(u!=v)
{
par[u]=v;
cnt[v]=cnt[u]+cnt[v];
}
}
int mx=-1111;
for( it=par.begin(); it!=par.end();it++)
{
mx=max(mx,cnt[it->first]);
}
printf("%d\n",mx);
par.clear();
cnt.clear();
}
}
| [
"ruet.rakib.cse13@gmail.com"
] | ruet.rakib.cse13@gmail.com |
fc9789b707206187058ad8baecb3f79862af0fc8 | 57ac1261f06a461c636d6ccc7aa7881f024eb6c7 | /spaceship/spaceship.ino | 2df8a11b6ef71249f56c8ccdf4c3381bb6d3df93 | [] | no_license | rwbot/arduino | 8c57767efcbb3795847f59c907f5cfc1f9fd5807 | e9d5ad531f9acbee5551c56ab30e9908ea97a622 | refs/heads/master | 2020-03-07T15:30:33.252927 | 2018-03-31T17:53:27 | 2018-03-31T17:53:27 | 127,556,724 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 725 | ino | const int greenLed=3;
const int redLed1=4;
const int redLed2=5;
const int switchPin=2;
void setup() {
// put your setup code here, to run once:
pinMode(greenLed,OUTPUT);
pinMode(redLed1,OUTPUT);
pinMode(redLed2,OUTPUT);
pinMode(switchPin, INPUT);
}
void loop() {
// put your main code here, to run repeatedly:
int switchState;
switchState=digitalRead(switchPin);
if(switchState == LOW){
digitalWrite(greenLed, LOW);
digitalWrite(redLed1, HIGH);
digitalWrite(redLed2, LOW);
delay(250);
digitalWrite(redLed1, LOW);
digitalWrite(redLed2, HIGH);
delay(250);
} else {
digitalWrite(redLed1, LOW);
digitalWrite(redLed2, LOW);
digitalWrite(greenLed, HIGH);
}
}
| [
"christopher.rowe@trincoll.edu"
] | christopher.rowe@trincoll.edu |
2e321aabeb0d5d1762f78642ef4ab0dad92ccc73 | c9b02ab1612c8b436c1de94069b139137657899b | /server/app/pb/ProtoWeapon.pb.h | f0650d6d62590ccbf9df0f8dcba988d00758b37f | [] | no_license | colinblack/game_server | a7ee95ec4e1def0220ab71f5f4501c9a26ab61ab | a7724f93e0be5c43e323972da30e738e5fbef54f | refs/heads/master | 2020-03-21T19:25:02.879552 | 2020-03-01T08:57:07 | 2020-03-01T08:57:07 | 138,948,382 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | true | 27,117 | h | // Generated by the protocol buffer compiler. DO NOT EDIT!
// source: ProtoWeapon.proto
#ifndef PROTOBUF_ProtoWeapon_2eproto__INCLUDED
#define PROTOBUF_ProtoWeapon_2eproto__INCLUDED
#include <string>
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 2006000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 2006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/unknown_field_set.h>
#include "DataCommon.pb.h"
// @@protoc_insertion_point(includes)
namespace ProtoWeapon {
// Internal implementation detail -- do not call these.
void protobuf_AddDesc_ProtoWeapon_2eproto();
void protobuf_AssignDesc_ProtoWeapon_2eproto();
void protobuf_ShutdownFile_ProtoWeapon_2eproto();
class WeaponInfoCPP;
class WeaponUnlockReq;
class WeaponUnlockResp;
class WeaponCastReq;
class WeaponCastResp;
// ===================================================================
class WeaponInfoCPP : public ::google::protobuf::Message {
public:
WeaponInfoCPP();
virtual ~WeaponInfoCPP();
WeaponInfoCPP(const WeaponInfoCPP& from);
inline WeaponInfoCPP& operator=(const WeaponInfoCPP& from) {
CopyFrom(from);
return *this;
}
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _unknown_fields_;
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return &_unknown_fields_;
}
static const ::google::protobuf::Descriptor* descriptor();
static const WeaponInfoCPP& default_instance();
void Swap(WeaponInfoCPP* other);
// implements Message ----------------------------------------------
WeaponInfoCPP* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const WeaponInfoCPP& from);
void MergeFrom(const WeaponInfoCPP& from);
void Clear();
bool IsInitialized() const;
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
int GetCachedSize() const { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
public:
::google::protobuf::Metadata GetMetadata() const;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// required uint32 id = 1;
inline bool has_id() const;
inline void clear_id();
static const int kIdFieldNumber = 1;
inline ::google::protobuf::uint32 id() const;
inline void set_id(::google::protobuf::uint32 value);
// required uint32 level = 2;
inline bool has_level() const;
inline void clear_level();
static const int kLevelFieldNumber = 2;
inline ::google::protobuf::uint32 level() const;
inline void set_level(::google::protobuf::uint32 value);
// required uint32 cast = 3;
inline bool has_cast() const;
inline void clear_cast();
static const int kCastFieldNumber = 3;
inline ::google::protobuf::uint32 cast() const;
inline void set_cast(::google::protobuf::uint32 value);
// @@protoc_insertion_point(class_scope:ProtoWeapon.WeaponInfoCPP)
private:
inline void set_has_id();
inline void clear_has_id();
inline void set_has_level();
inline void clear_has_level();
inline void set_has_cast();
inline void clear_has_cast();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::uint32 _has_bits_[1];
mutable int _cached_size_;
::google::protobuf::uint32 id_;
::google::protobuf::uint32 level_;
::google::protobuf::uint32 cast_;
friend void protobuf_AddDesc_ProtoWeapon_2eproto();
friend void protobuf_AssignDesc_ProtoWeapon_2eproto();
friend void protobuf_ShutdownFile_ProtoWeapon_2eproto();
void InitAsDefaultInstance();
static WeaponInfoCPP* default_instance_;
};
// -------------------------------------------------------------------
class WeaponUnlockReq : public ::google::protobuf::Message {
public:
WeaponUnlockReq();
virtual ~WeaponUnlockReq();
WeaponUnlockReq(const WeaponUnlockReq& from);
inline WeaponUnlockReq& operator=(const WeaponUnlockReq& from) {
CopyFrom(from);
return *this;
}
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _unknown_fields_;
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return &_unknown_fields_;
}
static const ::google::protobuf::Descriptor* descriptor();
static const WeaponUnlockReq& default_instance();
void Swap(WeaponUnlockReq* other);
// implements Message ----------------------------------------------
WeaponUnlockReq* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const WeaponUnlockReq& from);
void MergeFrom(const WeaponUnlockReq& from);
void Clear();
bool IsInitialized() const;
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
int GetCachedSize() const { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
public:
::google::protobuf::Metadata GetMetadata() const;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// required uint32 id = 1;
inline bool has_id() const;
inline void clear_id();
static const int kIdFieldNumber = 1;
inline ::google::protobuf::uint32 id() const;
inline void set_id(::google::protobuf::uint32 value);
// @@protoc_insertion_point(class_scope:ProtoWeapon.WeaponUnlockReq)
private:
inline void set_has_id();
inline void clear_has_id();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::uint32 _has_bits_[1];
mutable int _cached_size_;
::google::protobuf::uint32 id_;
friend void protobuf_AddDesc_ProtoWeapon_2eproto();
friend void protobuf_AssignDesc_ProtoWeapon_2eproto();
friend void protobuf_ShutdownFile_ProtoWeapon_2eproto();
void InitAsDefaultInstance();
static WeaponUnlockReq* default_instance_;
};
// -------------------------------------------------------------------
class WeaponUnlockResp : public ::google::protobuf::Message {
public:
WeaponUnlockResp();
virtual ~WeaponUnlockResp();
WeaponUnlockResp(const WeaponUnlockResp& from);
inline WeaponUnlockResp& operator=(const WeaponUnlockResp& from) {
CopyFrom(from);
return *this;
}
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _unknown_fields_;
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return &_unknown_fields_;
}
static const ::google::protobuf::Descriptor* descriptor();
static const WeaponUnlockResp& default_instance();
void Swap(WeaponUnlockResp* other);
// implements Message ----------------------------------------------
WeaponUnlockResp* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const WeaponUnlockResp& from);
void MergeFrom(const WeaponUnlockResp& from);
void Clear();
bool IsInitialized() const;
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
int GetCachedSize() const { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
public:
::google::protobuf::Metadata GetMetadata() const;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// required .ProtoWeapon.WeaponInfoCPP item = 1;
inline bool has_item() const;
inline void clear_item();
static const int kItemFieldNumber = 1;
inline const ::ProtoWeapon::WeaponInfoCPP& item() const;
inline ::ProtoWeapon::WeaponInfoCPP* mutable_item();
inline ::ProtoWeapon::WeaponInfoCPP* release_item();
inline void set_allocated_item(::ProtoWeapon::WeaponInfoCPP* item);
// required .DataCommon.UserResourceCPP resource = 2;
inline bool has_resource() const;
inline void clear_resource();
static const int kResourceFieldNumber = 2;
inline const ::DataCommon::UserResourceCPP& resource() const;
inline ::DataCommon::UserResourceCPP* mutable_resource();
inline ::DataCommon::UserResourceCPP* release_resource();
inline void set_allocated_resource(::DataCommon::UserResourceCPP* resource);
// @@protoc_insertion_point(class_scope:ProtoWeapon.WeaponUnlockResp)
private:
inline void set_has_item();
inline void clear_has_item();
inline void set_has_resource();
inline void clear_has_resource();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::uint32 _has_bits_[1];
mutable int _cached_size_;
::ProtoWeapon::WeaponInfoCPP* item_;
::DataCommon::UserResourceCPP* resource_;
friend void protobuf_AddDesc_ProtoWeapon_2eproto();
friend void protobuf_AssignDesc_ProtoWeapon_2eproto();
friend void protobuf_ShutdownFile_ProtoWeapon_2eproto();
void InitAsDefaultInstance();
static WeaponUnlockResp* default_instance_;
};
// -------------------------------------------------------------------
class WeaponCastReq : public ::google::protobuf::Message {
public:
WeaponCastReq();
virtual ~WeaponCastReq();
WeaponCastReq(const WeaponCastReq& from);
inline WeaponCastReq& operator=(const WeaponCastReq& from) {
CopyFrom(from);
return *this;
}
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _unknown_fields_;
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return &_unknown_fields_;
}
static const ::google::protobuf::Descriptor* descriptor();
static const WeaponCastReq& default_instance();
void Swap(WeaponCastReq* other);
// implements Message ----------------------------------------------
WeaponCastReq* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const WeaponCastReq& from);
void MergeFrom(const WeaponCastReq& from);
void Clear();
bool IsInitialized() const;
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
int GetCachedSize() const { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
public:
::google::protobuf::Metadata GetMetadata() const;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// required uint32 id = 1;
inline bool has_id() const;
inline void clear_id();
static const int kIdFieldNumber = 1;
inline ::google::protobuf::uint32 id() const;
inline void set_id(::google::protobuf::uint32 value);
// @@protoc_insertion_point(class_scope:ProtoWeapon.WeaponCastReq)
private:
inline void set_has_id();
inline void clear_has_id();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::uint32 _has_bits_[1];
mutable int _cached_size_;
::google::protobuf::uint32 id_;
friend void protobuf_AddDesc_ProtoWeapon_2eproto();
friend void protobuf_AssignDesc_ProtoWeapon_2eproto();
friend void protobuf_ShutdownFile_ProtoWeapon_2eproto();
void InitAsDefaultInstance();
static WeaponCastReq* default_instance_;
};
// -------------------------------------------------------------------
class WeaponCastResp : public ::google::protobuf::Message {
public:
WeaponCastResp();
virtual ~WeaponCastResp();
WeaponCastResp(const WeaponCastResp& from);
inline WeaponCastResp& operator=(const WeaponCastResp& from) {
CopyFrom(from);
return *this;
}
inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
return _unknown_fields_;
}
inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
return &_unknown_fields_;
}
static const ::google::protobuf::Descriptor* descriptor();
static const WeaponCastResp& default_instance();
void Swap(WeaponCastResp* other);
// implements Message ----------------------------------------------
WeaponCastResp* New() const;
void CopyFrom(const ::google::protobuf::Message& from);
void MergeFrom(const ::google::protobuf::Message& from);
void CopyFrom(const WeaponCastResp& from);
void MergeFrom(const WeaponCastResp& from);
void Clear();
bool IsInitialized() const;
int ByteSize() const;
bool MergePartialFromCodedStream(
::google::protobuf::io::CodedInputStream* input);
void SerializeWithCachedSizes(
::google::protobuf::io::CodedOutputStream* output) const;
::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
int GetCachedSize() const { return _cached_size_; }
private:
void SharedCtor();
void SharedDtor();
void SetCachedSize(int size) const;
public:
::google::protobuf::Metadata GetMetadata() const;
// nested types ----------------------------------------------------
// accessors -------------------------------------------------------
// required .ProtoWeapon.WeaponInfoCPP item = 1;
inline bool has_item() const;
inline void clear_item();
static const int kItemFieldNumber = 1;
inline const ::ProtoWeapon::WeaponInfoCPP& item() const;
inline ::ProtoWeapon::WeaponInfoCPP* mutable_item();
inline ::ProtoWeapon::WeaponInfoCPP* release_item();
inline void set_allocated_item(::ProtoWeapon::WeaponInfoCPP* item);
// required uint32 multiple = 2;
inline bool has_multiple() const;
inline void clear_multiple();
static const int kMultipleFieldNumber = 2;
inline ::google::protobuf::uint32 multiple() const;
inline void set_multiple(::google::protobuf::uint32 value);
// required .DataCommon.UserResourceCPP resource = 3;
inline bool has_resource() const;
inline void clear_resource();
static const int kResourceFieldNumber = 3;
inline const ::DataCommon::UserResourceCPP& resource() const;
inline ::DataCommon::UserResourceCPP* mutable_resource();
inline ::DataCommon::UserResourceCPP* release_resource();
inline void set_allocated_resource(::DataCommon::UserResourceCPP* resource);
// @@protoc_insertion_point(class_scope:ProtoWeapon.WeaponCastResp)
private:
inline void set_has_item();
inline void clear_has_item();
inline void set_has_multiple();
inline void clear_has_multiple();
inline void set_has_resource();
inline void clear_has_resource();
::google::protobuf::UnknownFieldSet _unknown_fields_;
::google::protobuf::uint32 _has_bits_[1];
mutable int _cached_size_;
::ProtoWeapon::WeaponInfoCPP* item_;
::DataCommon::UserResourceCPP* resource_;
::google::protobuf::uint32 multiple_;
friend void protobuf_AddDesc_ProtoWeapon_2eproto();
friend void protobuf_AssignDesc_ProtoWeapon_2eproto();
friend void protobuf_ShutdownFile_ProtoWeapon_2eproto();
void InitAsDefaultInstance();
static WeaponCastResp* default_instance_;
};
// ===================================================================
// ===================================================================
// WeaponInfoCPP
// required uint32 id = 1;
inline bool WeaponInfoCPP::has_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WeaponInfoCPP::set_has_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void WeaponInfoCPP::clear_has_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void WeaponInfoCPP::clear_id() {
id_ = 0u;
clear_has_id();
}
inline ::google::protobuf::uint32 WeaponInfoCPP::id() const {
// @@protoc_insertion_point(field_get:ProtoWeapon.WeaponInfoCPP.id)
return id_;
}
inline void WeaponInfoCPP::set_id(::google::protobuf::uint32 value) {
set_has_id();
id_ = value;
// @@protoc_insertion_point(field_set:ProtoWeapon.WeaponInfoCPP.id)
}
// required uint32 level = 2;
inline bool WeaponInfoCPP::has_level() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void WeaponInfoCPP::set_has_level() {
_has_bits_[0] |= 0x00000002u;
}
inline void WeaponInfoCPP::clear_has_level() {
_has_bits_[0] &= ~0x00000002u;
}
inline void WeaponInfoCPP::clear_level() {
level_ = 0u;
clear_has_level();
}
inline ::google::protobuf::uint32 WeaponInfoCPP::level() const {
// @@protoc_insertion_point(field_get:ProtoWeapon.WeaponInfoCPP.level)
return level_;
}
inline void WeaponInfoCPP::set_level(::google::protobuf::uint32 value) {
set_has_level();
level_ = value;
// @@protoc_insertion_point(field_set:ProtoWeapon.WeaponInfoCPP.level)
}
// required uint32 cast = 3;
inline bool WeaponInfoCPP::has_cast() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void WeaponInfoCPP::set_has_cast() {
_has_bits_[0] |= 0x00000004u;
}
inline void WeaponInfoCPP::clear_has_cast() {
_has_bits_[0] &= ~0x00000004u;
}
inline void WeaponInfoCPP::clear_cast() {
cast_ = 0u;
clear_has_cast();
}
inline ::google::protobuf::uint32 WeaponInfoCPP::cast() const {
// @@protoc_insertion_point(field_get:ProtoWeapon.WeaponInfoCPP.cast)
return cast_;
}
inline void WeaponInfoCPP::set_cast(::google::protobuf::uint32 value) {
set_has_cast();
cast_ = value;
// @@protoc_insertion_point(field_set:ProtoWeapon.WeaponInfoCPP.cast)
}
// -------------------------------------------------------------------
// WeaponUnlockReq
// required uint32 id = 1;
inline bool WeaponUnlockReq::has_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WeaponUnlockReq::set_has_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void WeaponUnlockReq::clear_has_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void WeaponUnlockReq::clear_id() {
id_ = 0u;
clear_has_id();
}
inline ::google::protobuf::uint32 WeaponUnlockReq::id() const {
// @@protoc_insertion_point(field_get:ProtoWeapon.WeaponUnlockReq.id)
return id_;
}
inline void WeaponUnlockReq::set_id(::google::protobuf::uint32 value) {
set_has_id();
id_ = value;
// @@protoc_insertion_point(field_set:ProtoWeapon.WeaponUnlockReq.id)
}
// -------------------------------------------------------------------
// WeaponUnlockResp
// required .ProtoWeapon.WeaponInfoCPP item = 1;
inline bool WeaponUnlockResp::has_item() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WeaponUnlockResp::set_has_item() {
_has_bits_[0] |= 0x00000001u;
}
inline void WeaponUnlockResp::clear_has_item() {
_has_bits_[0] &= ~0x00000001u;
}
inline void WeaponUnlockResp::clear_item() {
if (item_ != NULL) item_->::ProtoWeapon::WeaponInfoCPP::Clear();
clear_has_item();
}
inline const ::ProtoWeapon::WeaponInfoCPP& WeaponUnlockResp::item() const {
// @@protoc_insertion_point(field_get:ProtoWeapon.WeaponUnlockResp.item)
return item_ != NULL ? *item_ : *default_instance_->item_;
}
inline ::ProtoWeapon::WeaponInfoCPP* WeaponUnlockResp::mutable_item() {
set_has_item();
if (item_ == NULL) item_ = new ::ProtoWeapon::WeaponInfoCPP;
// @@protoc_insertion_point(field_mutable:ProtoWeapon.WeaponUnlockResp.item)
return item_;
}
inline ::ProtoWeapon::WeaponInfoCPP* WeaponUnlockResp::release_item() {
clear_has_item();
::ProtoWeapon::WeaponInfoCPP* temp = item_;
item_ = NULL;
return temp;
}
inline void WeaponUnlockResp::set_allocated_item(::ProtoWeapon::WeaponInfoCPP* item) {
delete item_;
item_ = item;
if (item) {
set_has_item();
} else {
clear_has_item();
}
// @@protoc_insertion_point(field_set_allocated:ProtoWeapon.WeaponUnlockResp.item)
}
// required .DataCommon.UserResourceCPP resource = 2;
inline bool WeaponUnlockResp::has_resource() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void WeaponUnlockResp::set_has_resource() {
_has_bits_[0] |= 0x00000002u;
}
inline void WeaponUnlockResp::clear_has_resource() {
_has_bits_[0] &= ~0x00000002u;
}
inline void WeaponUnlockResp::clear_resource() {
if (resource_ != NULL) resource_->::DataCommon::UserResourceCPP::Clear();
clear_has_resource();
}
inline const ::DataCommon::UserResourceCPP& WeaponUnlockResp::resource() const {
// @@protoc_insertion_point(field_get:ProtoWeapon.WeaponUnlockResp.resource)
return resource_ != NULL ? *resource_ : *default_instance_->resource_;
}
inline ::DataCommon::UserResourceCPP* WeaponUnlockResp::mutable_resource() {
set_has_resource();
if (resource_ == NULL) resource_ = new ::DataCommon::UserResourceCPP;
// @@protoc_insertion_point(field_mutable:ProtoWeapon.WeaponUnlockResp.resource)
return resource_;
}
inline ::DataCommon::UserResourceCPP* WeaponUnlockResp::release_resource() {
clear_has_resource();
::DataCommon::UserResourceCPP* temp = resource_;
resource_ = NULL;
return temp;
}
inline void WeaponUnlockResp::set_allocated_resource(::DataCommon::UserResourceCPP* resource) {
delete resource_;
resource_ = resource;
if (resource) {
set_has_resource();
} else {
clear_has_resource();
}
// @@protoc_insertion_point(field_set_allocated:ProtoWeapon.WeaponUnlockResp.resource)
}
// -------------------------------------------------------------------
// WeaponCastReq
// required uint32 id = 1;
inline bool WeaponCastReq::has_id() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WeaponCastReq::set_has_id() {
_has_bits_[0] |= 0x00000001u;
}
inline void WeaponCastReq::clear_has_id() {
_has_bits_[0] &= ~0x00000001u;
}
inline void WeaponCastReq::clear_id() {
id_ = 0u;
clear_has_id();
}
inline ::google::protobuf::uint32 WeaponCastReq::id() const {
// @@protoc_insertion_point(field_get:ProtoWeapon.WeaponCastReq.id)
return id_;
}
inline void WeaponCastReq::set_id(::google::protobuf::uint32 value) {
set_has_id();
id_ = value;
// @@protoc_insertion_point(field_set:ProtoWeapon.WeaponCastReq.id)
}
// -------------------------------------------------------------------
// WeaponCastResp
// required .ProtoWeapon.WeaponInfoCPP item = 1;
inline bool WeaponCastResp::has_item() const {
return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void WeaponCastResp::set_has_item() {
_has_bits_[0] |= 0x00000001u;
}
inline void WeaponCastResp::clear_has_item() {
_has_bits_[0] &= ~0x00000001u;
}
inline void WeaponCastResp::clear_item() {
if (item_ != NULL) item_->::ProtoWeapon::WeaponInfoCPP::Clear();
clear_has_item();
}
inline const ::ProtoWeapon::WeaponInfoCPP& WeaponCastResp::item() const {
// @@protoc_insertion_point(field_get:ProtoWeapon.WeaponCastResp.item)
return item_ != NULL ? *item_ : *default_instance_->item_;
}
inline ::ProtoWeapon::WeaponInfoCPP* WeaponCastResp::mutable_item() {
set_has_item();
if (item_ == NULL) item_ = new ::ProtoWeapon::WeaponInfoCPP;
// @@protoc_insertion_point(field_mutable:ProtoWeapon.WeaponCastResp.item)
return item_;
}
inline ::ProtoWeapon::WeaponInfoCPP* WeaponCastResp::release_item() {
clear_has_item();
::ProtoWeapon::WeaponInfoCPP* temp = item_;
item_ = NULL;
return temp;
}
inline void WeaponCastResp::set_allocated_item(::ProtoWeapon::WeaponInfoCPP* item) {
delete item_;
item_ = item;
if (item) {
set_has_item();
} else {
clear_has_item();
}
// @@protoc_insertion_point(field_set_allocated:ProtoWeapon.WeaponCastResp.item)
}
// required uint32 multiple = 2;
inline bool WeaponCastResp::has_multiple() const {
return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void WeaponCastResp::set_has_multiple() {
_has_bits_[0] |= 0x00000002u;
}
inline void WeaponCastResp::clear_has_multiple() {
_has_bits_[0] &= ~0x00000002u;
}
inline void WeaponCastResp::clear_multiple() {
multiple_ = 0u;
clear_has_multiple();
}
inline ::google::protobuf::uint32 WeaponCastResp::multiple() const {
// @@protoc_insertion_point(field_get:ProtoWeapon.WeaponCastResp.multiple)
return multiple_;
}
inline void WeaponCastResp::set_multiple(::google::protobuf::uint32 value) {
set_has_multiple();
multiple_ = value;
// @@protoc_insertion_point(field_set:ProtoWeapon.WeaponCastResp.multiple)
}
// required .DataCommon.UserResourceCPP resource = 3;
inline bool WeaponCastResp::has_resource() const {
return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void WeaponCastResp::set_has_resource() {
_has_bits_[0] |= 0x00000004u;
}
inline void WeaponCastResp::clear_has_resource() {
_has_bits_[0] &= ~0x00000004u;
}
inline void WeaponCastResp::clear_resource() {
if (resource_ != NULL) resource_->::DataCommon::UserResourceCPP::Clear();
clear_has_resource();
}
inline const ::DataCommon::UserResourceCPP& WeaponCastResp::resource() const {
// @@protoc_insertion_point(field_get:ProtoWeapon.WeaponCastResp.resource)
return resource_ != NULL ? *resource_ : *default_instance_->resource_;
}
inline ::DataCommon::UserResourceCPP* WeaponCastResp::mutable_resource() {
set_has_resource();
if (resource_ == NULL) resource_ = new ::DataCommon::UserResourceCPP;
// @@protoc_insertion_point(field_mutable:ProtoWeapon.WeaponCastResp.resource)
return resource_;
}
inline ::DataCommon::UserResourceCPP* WeaponCastResp::release_resource() {
clear_has_resource();
::DataCommon::UserResourceCPP* temp = resource_;
resource_ = NULL;
return temp;
}
inline void WeaponCastResp::set_allocated_resource(::DataCommon::UserResourceCPP* resource) {
delete resource_;
resource_ = resource;
if (resource) {
set_has_resource();
} else {
clear_has_resource();
}
// @@protoc_insertion_point(field_set_allocated:ProtoWeapon.WeaponCastResp.resource)
}
// @@protoc_insertion_point(namespace_scope)
} // namespace ProtoWeapon
#ifndef SWIG
namespace google {
namespace protobuf {
} // namespace google
} // namespace protobuf
#endif // SWIG
// @@protoc_insertion_point(global_scope)
#endif // PROTOBUF_ProtoWeapon_2eproto__INCLUDED
| [
"178370407@qq.com"
] | 178370407@qq.com |
2fbed55d84b070817198014cf3cdb2d6f459a9af | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/httpd/gumtree/httpd_old_hunk_4725.cpp | 59afadf7c826fe30906bc91cc7e523721110b188 | [] | 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 | 603 | cpp |
child = child->next;
}
if (ret != OK) {
ap_log_error(APLOG_MARK, APLOG_ERR | APLOG_STARTUP, APR_SUCCESS, s, APLOGNO(01624)
"%s",
apr_pstrcat(p, (is_conf
? "<Directory>, <Location>, or similar"
: format_authz_command(p, section)),
" directive contains only negative "
"authorization directives", NULL));
}
return ret;
}
static int authz_core_pre_config(apr_pool_t *p, apr_pool_t *plog,
| [
"993273596@qq.com"
] | 993273596@qq.com |
bdd75025fc379c35cfc37457720dc39ced7974d2 | bffda3ac406905848eb1f14c9e47e47eb154437d | /BBManagerLean/src/vm/virtualmachinepanel.cpp | cd42343c91452816c1124985ba6b4383dbcc3a7b | [] | no_license | SingularSound/openbbm | 5bf3f3a87b50221128488347d51a46e1b5c33a74 | 133bb0b87d983df2c90ae15db155c8c70ba84f76 | refs/heads/master | 2023-02-13T10:39:29.246843 | 2020-11-20T21:15:36 | 2020-11-20T21:15:36 | 246,878,370 | 31 | 9 | null | 2020-11-20T21:15:38 | 2020-03-12T16:13:48 | C++ | UTF-8 | C++ | false | false | 7,023 | cpp | /*
This software and the content provided for use with it is Copyright © 2014-2020 Singular Sound
BeatBuddy Manager is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License version 2 as published by
the Free Software Foundation.
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 <https://www.gnu.org/licenses/>.
*/
#include <QLabel>
#include <QFrame>
#include <QVBoxLayout>
#include <QStyleOption>
#include <QPainter>
#include <QPushButton>
#include <QResizeEvent>
#include <QDebug>
#include "virtualmachinepanel.h"
VirtualMachinePanel::VirtualMachinePanel(QWidget *parent) :
QWidget(parent)
{
//this->setStyleSheet("{ background-color: red;}");
mp_ParentContainer = parent;
QVBoxLayout * p_VBoxLayout = new QVBoxLayout();
setLayout(p_VBoxLayout);
p_VBoxLayout->setContentsMargins(0,0,0,0);
QLabel * p_Title = new QLabel(this);
p_Title->setText(tr("Virtual Machine"));
p_Title->setObjectName("titleBar");
p_VBoxLayout->addWidget(p_Title, 0);
QWidget *p_MainContainer = new QWidget(this);
p_VBoxLayout->addWidget(p_MainContainer, Qt::AlignCenter);
p_MainContainer->setLayout(new QGridLayout());
p_MainContainer->setObjectName("VirtualMachine");
QFrame *p_Dummy = new QFrame(p_MainContainer);
QImage vm(":/images/images/VM.png");
m_aspectRatio = double(vm.height())/double(vm.width());
m_lastHeight = this->height();
m_lastWidth = this->width();
m_minHeight = vm.height()/ 8;
m_maxHeight = vm.height();
m_minWidth = vm.width()/8;
m_maxWidth = vm.width();
p_Dummy->setMinimumWidth(m_minWidth);
p_Dummy->setMaximumWidth(m_maxWidth);
p_Dummy->setMinimumHeight(m_minHeight);
p_Dummy->setMaximumHeight(m_maxHeight);
static_cast<QGridLayout*>(p_MainContainer->layout())->addWidget(p_Dummy,0,0);
static_cast<QGridLayout*>(p_MainContainer->layout())->setRowStretch(0,false);
static_cast<QGridLayout*>(p_MainContainer->layout())->setRowStretch(1,false);
static_cast<QGridLayout*>(p_MainContainer->layout())->setColumnStretch(0,false);
static_cast<QGridLayout*>(p_MainContainer->layout())->setColumnStretch(1,false);
// Pedal control push button
mp_Pedal = new QPushButton(this);
mp_Pedal->setObjectName(QStringLiteral("VMPedal"));
mp_Pedal->setFlat(true);
mp_Pedal->setAutoFillBackground(false);
mp_Pedal->setText(nullptr);
mp_Pedal->setToolTip(tr("Press pedal"));
mp_Pedal->move(VM_PEDAL_POS_X, VM_PEDAL_POS_Y);
mp_Pedal->show();
connect(mp_Pedal, SIGNAL(pressed()), this, SLOT(pedalPressed()));
connect(mp_Pedal, SIGNAL(released()), this, SLOT(pedalReleased()));
// Special effect push button creation
mp_Effect = new QPushButton(this);
mp_Effect->setObjectName(QStringLiteral("VMEffect"));
mp_Effect->setFlat(true);
mp_Effect->setAutoFillBackground(false);
mp_Effect->setText(nullptr);
mp_Effect->setToolTip(tr("Play Accent Hit"));
mp_Effect->move(VM_EFFECT_POS_X, VM_EFFECT_POS_Y);
mp_Effect->show();
connect(mp_Effect, SIGNAL(pressed()), this, SLOT(effect()));
mp_Screen = new VMScreen(this);
mp_Screen->setObjectName(QStringLiteral("VMScreen"));
mp_Screen->move(VM_SCREEN_POS_X, VM_SCREEN_POS_X);
mp_Screen->show();
this->resize(width() * 4,height());
}
// Required to apply stylesheet
void VirtualMachinePanel::paintEvent(QPaintEvent *event)
{
QPainter painter(this);
painter.fillRect(0,0,this->size().width(),this->size().height(),Qt::white);
int h = height() - (2 * VM_Y_BORDER_SIZE + VM_Y_HEADER_OFFSET);
int w = width() - (2 * VM_X_BORDER_SIZE);
int y_offset;
int x_offset;
double sizeRatio;
double newAspectRatio = double(h)/ double(w);
if (newAspectRatio >= m_aspectRatio){
x_offset = 0;
y_offset = (newAspectRatio - m_aspectRatio) * width() / 2;
// Calculation based on the current width
sizeRatio = double(w) / double(m_maxWidth);
painter.drawPixmap(VM_X_BORDER_SIZE,
y_offset + VM_Y_BORDER_SIZE + VM_Y_HEADER_OFFSET,
QPixmap(":/images/images/VM.png").scaledToWidth(
w,
Qt::SmoothTransformation));
} else {
// Calculation based on the current height
sizeRatio = double(h)/double(m_maxHeight);
x_offset = ((m_aspectRatio - newAspectRatio) * double(width())) / 4;
y_offset = 0;
painter.drawPixmap(x_offset + VM_X_BORDER_SIZE,
VM_Y_BORDER_SIZE + VM_Y_HEADER_OFFSET,
QPixmap(":/images/images/VM.png").scaledToHeight(
h,
Qt::SmoothTransformation));
}
/* Resize and move the pedal press button */
mp_Pedal->resize(sizeRatio * double(VM_PEDAL_WIDTH),sizeRatio * double(VM_PEDAL_HEIGHT));
mp_Pedal->move(
x_offset + VM_X_BORDER_SIZE + sizeRatio * VM_PEDAL_POS_X,
y_offset + VM_Y_BORDER_SIZE + VM_Y_HEADER_OFFSET + sizeRatio * VM_PEDAL_POS_Y);
/* Resize and remove the effect switch button */
mp_Effect->resize(sizeRatio * double(VM_EFFECT_WIDTH),sizeRatio * double(VM_EFFECT_HEIGHT));
mp_Effect->move(
x_offset + VM_X_BORDER_SIZE + sizeRatio * VM_EFFECT_POS_X,
y_offset + VM_Y_BORDER_SIZE + VM_Y_HEADER_OFFSET + sizeRatio * VM_EFFECT_POS_Y);
mp_Screen->resize(sizeRatio * double(VM_SCREEN_WIDTH),sizeRatio * double(VM_SCREEN_HEIGHT));
mp_Screen->move(
x_offset + VM_X_BORDER_SIZE + sizeRatio * VM_SCREEN_POS_X,
y_offset + VM_Y_BORDER_SIZE + VM_Y_HEADER_OFFSET + sizeRatio * VM_SCREEN_POS_Y);
QWidget::paintEvent(event);
}
void VirtualMachinePanel::pedalPressed(void)
{
// If less than 250ms since release of button, it's a double tap
// Need to stop timer before emitting signal because emit is blocking
if (m_pedalTimer.isActive() && m_pedalCounter == 1) {
m_pedalTimer.stop();
emit sigPedalDoubleTap();
} else {
m_pedalTimer.stop();
emit sigPedalPress();
}
m_pedalCounter = 0;
connect(&m_pedalTimer, SIGNAL(timeout()), this, SLOT(pedalLongPress()));
m_pedalTimer.setSingleShot(true);
m_pedalTimer.start(250);
}
void VirtualMachinePanel::pedalReleased(void)
{
if (m_pedalTimer.isActive()) {
m_pedalCounter++;
}
m_pedalTimer.stop();
disconnect(&m_pedalTimer, SIGNAL(timeout()), this, SLOT(pedalLongPress()));
emit sigPedalRelease();
m_pedalTimer.setSingleShot(true);
m_pedalTimer.start(250);
}
void VirtualMachinePanel::pedalLongPress(void)
{
emit sigPedalLongPress();
}
void VirtualMachinePanel::effect(void)
{
emit sigEffect();
}
| [
"julissa@singularsound.com"
] | julissa@singularsound.com |
423633ca1bc9eda14540e4d34f0c47243e60c00a | 2a26923028c995cc21550c02e68a358a49783ec7 | /core/PhysiCell_cell.h | 97bef2215348cf384257abd1b84244101b129a77 | [] | no_license | olaurino/PhysiCell | dcce77bc6b15e53b00002fe1600e2497665326bb | 8fcd79b8fc37b6c086ec983453a3ffa4f7cf90c2 | refs/heads/master | 2021-08-06T10:01:46.574922 | 2017-11-05T00:56:47 | 2017-11-05T00:56:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,458 | h | /*
###############################################################################
# If you use PhysiCell in your project, please cite PhysiCell and the version #
# number, such as below: #
# #
# We implemented and solved the model using PhysiCell (Version 1.2.2) [1]. #
# #
# [1] A Ghaffarizadeh, R Heiland, SH Friedman, SM Mumenthaler, and P Macklin, #
# PhysiCell: an Open Source Physics-Based Cell Simulator for Multicellu- #
# lar Systems, PLoS Comput. Biol. 2017 (in review). #
# preprint DOI: 10.1101/088773 #
# #
# Because PhysiCell extensively uses BioFVM, we suggest you also cite BioFVM #
# as below: #
# #
# We implemented and solved the model using PhysiCell (Version 1.2.2) [1], #
# with BioFVM [2] to solve the transport equations. #
# #
# [1] A Ghaffarizadeh, R Heiland, SH Friedman, SM Mumenthaler, and P Macklin, #
# PhysiCell: an Open Source Physics-Based Cell Simulator for Multicellu- #
# lar Systems, PLoS Comput. Biol. 2017 (in review). #
# preprint DOI: 10.1101/088773 #
# #
# [2] A Ghaffarizadeh, SH Friedman, and P Macklin, BioFVM: an efficient para- #
# llelized diffusive transport solver for 3-D biological simulations, #
# Bioinformatics 32(8): 1256-8, 2016. DOI: 10.1093/bioinformatics/btv730 #
# #
###############################################################################
# #
# BSD 3-Clause License (see https://opensource.org/licenses/BSD-3-Clause) #
# #
# Copyright (c) 2015-2017, Paul Macklin and the PhysiCell Project #
# All rights reserved. #
# #
# Redistribution and use in source and binary forms, with or without #
# modification, are permitted provided that the following conditions are met: #
# #
# 1. Redistributions of source code must retain the above copyright notice, #
# this list of conditions and the following disclaimer. #
# #
# 2. Redistributions in binary form must reproduce the above copyright #
# notice, this list of conditions and the following disclaimer in the #
# documentation and/or other materials provided with the distribution. #
# #
# 3. Neither the name of the copyright holder nor the names of its #
# contributors may be used to endorse or promote products derived from this #
# software without specific prior written permission. #
# #
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" #
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE #
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE #
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE #
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR #
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF #
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS #
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN #
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) #
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE #
# POSSIBILITY OF SUCH DAMAGE. #
# #
###############################################################################
*/
#ifndef __PhysiCell_cell_h__
#define __PhysiCell_cell_h__
#include "./PhysiCell_custom.h"
#include "../BioFVM/BioFVM.h"
#include "./PhysiCell_phenotype.h"
#include "./PhysiCell_cell_container.h"
#include "./PhysiCell_constants.h"
using namespace BioFVM;
namespace PhysiCell{
class Cell_Container;
class Cell_Parameters
{
private:
public:
// oxygen values (in mmHg) for critical phenotype changes
double o2_hypoxic_threshold; // value at which hypoxic signaling starts
double o2_hypoxic_response; // value at which omics changes are observed
double o2_hypoxic_saturation; // value at which hypoxic signalign saturates
// o2_hypoxic_saturation < o2_hypoxic_threshold
double o2_proliferation_saturation; // value at which extra o2 does not increase proliferation
double o2_proliferation_threshold; // value at which o2 is sufficient for proliferation
double o2_reference; // physioxic reference value, in the linked reference Phenotype
// o2_proliferation_threshold < o2_reference < o2_proliferation_saturation;
double o2_necrosis_threshold; // value at which cells start experiencing necrotic death
double o2_necrosis_max; // value at which necrosis reaches its maximum rate
// o2_necrosis_max < o2_necrosis_threshold
Phenotype* pReference_live_phenotype; // reference live phenotype (typically physioxic)
// Phenotype* pReference_necrotic_phenotype; // reference live phenotype (typically physioxic)
// necrosis parameters (may evenually be moved into a reference necrotic phenotype
double max_necrosis_rate; // deprecate
int necrosis_type; // deprecate
Cell_Parameters();
};
class Cell_Definition
{
private:
public:
int type;
std::string name;
Microenvironment* pMicroenvironment;
Cell_Parameters parameters;
Custom_Cell_Data custom_data;
Cell_Functions functions;
Phenotype phenotype;
Cell_Definition(); // done
Cell_Definition( Cell_Definition& cd ); // copy constructor
Cell_Definition& operator=( const Cell_Definition& cd ); // copy assignment
};
extern Cell_Definition cell_defaults;
class Cell_State
{
public:
std::vector<Cell*> neighbors; // not currently tracked!
std::vector<double> orientation;
double simple_pressure;
Cell_State();
};
class Cell : public Basic_Agent
{
private:
Cell_Container * container;
int current_mechanics_voxel_index;
int updated_current_mechanics_voxel_index; // keeps the updated voxel index for later adjusting of current voxel index
public:
std::string type_name;
Custom_Cell_Data custom_data;
Cell_Parameters parameters;
Cell_Functions functions;
Cell_State state;
Phenotype phenotype;
void update_motility_vector( double dt_ );
void advance_bundled_phenotype_functions( double dt_ );
void add_potentials(Cell*); // Add repulsive and adhesive forces.
void set_previous_velocity(double xV, double yV, double zV);
int get_current_mechanics_voxel_index();
void turn_off_reactions(double); // Turn off all the reactions of the cell
bool is_out_of_domain;
bool is_movable;
void flag_for_division( void ); // done
void flag_for_removal( void ); // done
void start_death( int death_model_index );
Cell* divide( void );
void die( void );
void step(double dt);
Cell();
bool assign_position(std::vector<double> new_position);
bool assign_position(double, double, double);
void set_total_volume(double);
double& get_total_volume(void); // NEW
// mechanics
void update_position( double dt ); //
std::vector<double> displacement; // this should be moved to state, or made private
void assign_orientation(); // if set_orientaion is defined, uses it to assign the orientation
// otherwise, it assigns a random orientation to the cell.
void copy_function_pointers(Cell*);
void update_voxel_in_container(void);
void copy_data(Cell *);
// I want to eventually deprecate this, by ensuring that
// critical BioFVM and PhysiCell data elements are synced when they are needed
void set_phenotype( Phenotype& phenotype ); // no longer needed?
void update_radius();
Cell_Container * get_container();
std::vector<Cell*>& cells_in_my_container( void );
void convert_to_cell_definition( Cell_Definition& cd );
};
Cell* create_cell( void );
Cell* create_cell( Cell_Definition& cd );
void delete_cell( int );
void delete_cell( Cell* );
void save_all_cells_to_matlab( std::string filename );
//function to check if a neighbor voxel contains any cell that can interact with me
bool is_neighbor_voxel(Cell* pCell, std::vector<double> myVoxelCenter, std::vector<double> otherVoxelCenter, int otherVoxelIndex);
};
#endif | [
"Paul.Macklin@MathCancer.org"
] | Paul.Macklin@MathCancer.org |
5f5c735dce3a5f869a3c1c550f7ca700a458a24d | 91a882547e393d4c4946a6c2c99186b5f72122dd | /Source/XPSP1/NT/net/config/netcfg/engine/lockdown.cpp | 06cb4d0d7f4f9f8138c83b965bec412259b2caf3 | [] | no_license | IAmAnubhavSaini/cryptoAlgorithm-nt5src | 94f9b46f101b983954ac6e453d0cf8d02aa76fc7 | d9e1cdeec650b9d6d3ce63f9f0abe50dabfaf9e2 | refs/heads/master | 2023-09-02T10:14:14.795579 | 2021-11-20T13:47:06 | 2021-11-20T13:47:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,663 | cpp | //+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1999.
//
// File: L O C K D O W N . C P P
//
// Contents: Routines to get and set components that are in a lockdown
// state. A component goes into lockdown when it requires a
// reboot on removal. When a component is locked down, it
// cannot be installed until after the next reboot.
//
// Notes: Because a component comes out of lockdown after a reboot,
// a natural choice for implementation is to use a volatile
// registry key to keep track of the state. Each component
// that is locked down is represented by a volatile registry
// key the name of which is the same as the INF ID of the
// component. These keys exist under
// SYSTEM\CurrentControlSet\Control\Network\Lockdown.
//
// Author: shaunco 24 May 1999
//
//----------------------------------------------------------------------------
#include "pch.h"
#pragma hdrstop
#include "diagctx.h"
#include "lockdown.h"
#include "ncreg.h"
#define REGSTR_KEY_LOCKDOWN \
L"SYSTEM\\CurrentControlSet\\Control\\Network\\Lockdown"
//+---------------------------------------------------------------------------
//
// Function: EnumLockedDownComponents
//
// Purpose: Enumerate the currently locked down components via a
// caller-supplied callback.
//
// Arguments:
// pfnCallback [in] pointer to callback function
// OPTIONAL [in] optional caller-supplied data to pass back
//
// Returns: nothing
//
// Author: shaunco 24 May 1999
//
VOID
EnumLockedDownComponents (
IN PFN_ELDC_CALLBACK pfnCallback,
IN PVOID pvCallerData OPTIONAL)
{
HRESULT hr;
HKEY hkey;
hr = HrRegOpenKeyEx (
HKEY_LOCAL_MACHINE,
REGSTR_KEY_LOCKDOWN,
KEY_READ,
&hkey);
if (S_OK == hr)
{
WCHAR szInfId [_MAX_PATH];
FILETIME ft;
DWORD dwSize;
DWORD dwRegIndex;
for (dwRegIndex = 0, dwSize = celems(szInfId);
S_OK == HrRegEnumKeyEx(hkey, dwRegIndex, szInfId,
&dwSize, NULL, NULL, &ft);
dwRegIndex++, dwSize = celems(szInfId))
{
pfnCallback (szInfId, pvCallerData);
}
RegCloseKey (hkey);;
}
}
//+---------------------------------------------------------------------------
//
// Function: FGetOrSetComponentLockDown
//
// Purpose: Gets or sets the state of whether a component is locked down.
//
// Arguments:
// fSet [in] TRUE to set into the lockdown state, FALSE to get.
// pszInfId [in] the INF ID of the component in question.
//
// Returns: TRUE if non-zero fSet and component is locked down.
// FALSE otherwise.
//
// Author: shaunco 24 May 1999
//
BOOL
FGetOrSetComponentLockDown (
IN BOOL fSet,
IN PCWSTR pszInfId)
{
Assert (pszInfId);
HRESULT hr;
HKEY hkey;
BOOL fRet;
WCHAR szKey [_MAX_PATH];
fRet = FALSE;
hkey = NULL;
wcscpy (szKey, REGSTR_KEY_LOCKDOWN);
wcscat (szKey, L"\\");
wcscat (szKey, pszInfId);
if (fSet)
{
g_pDiagCtx->Printf (ttidBeDiag, " %S is being locked "
"down to prevent re-install until the next reboot\n",
pszInfId);
hr = HrRegCreateKeyEx (
HKEY_LOCAL_MACHINE,
szKey,
REG_OPTION_VOLATILE,
KEY_WRITE,
NULL,
&hkey,
NULL);
}
else
{
hr = HrRegOpenKeyEx (
HKEY_LOCAL_MACHINE,
szKey,
KEY_READ,
&hkey);
if (S_OK == hr)
{
fRet = TRUE;
}
}
RegSafeCloseKey (hkey);
return fRet;
}
BOOL
FIsComponentLockedDown (
IN PCWSTR pszInfId)
{
return FGetOrSetComponentLockDown (FALSE, pszInfId);
}
struct LOCKDOWN_DEPENDENCY_ENTRY
{
PCWSTR pszInfId;
const PCWSTR* ppszDependentInfIds;
};
extern const WCHAR c_szInfId_MS_NWIPX[];
extern const WCHAR c_szInfId_MS_FPNW[];
extern const WCHAR c_szInfId_MS_NWClient[];
extern const WCHAR c_szInfId_MS_NwSapAgent[];
static const PCWSTR c_apszNwlnkIpxDependentInfIds [] =
{
c_szInfId_MS_FPNW,
c_szInfId_MS_NWClient,
c_szInfId_MS_NwSapAgent,
NULL,
};
static const LOCKDOWN_DEPENDENCY_ENTRY c_LockdownDependencyMap [] =
{
{ c_szInfId_MS_NWIPX, c_apszNwlnkIpxDependentInfIds },
{ NULL, NULL }
};
VOID
LockdownComponentUntilNextReboot (
IN PCWSTR pszInfId)
{
(VOID) FGetOrSetComponentLockDown (TRUE, pszInfId);
// Lock down dependents of the component as well.
//
const LOCKDOWN_DEPENDENCY_ENTRY* pEntry;
UINT ipsz;
// Search for the matching entry in c_LockdownDependencyMap.
//
for (pEntry = c_LockdownDependencyMap;
pEntry->pszInfId;
pEntry++)
{
if (0 != _wcsicmp (pEntry->pszInfId, pszInfId))
{
continue;
}
// Found a matching entry. Now lock down all of its
// dependent INF ids. The array of const PCWSTR pointers is
// terminated with a NULL pointer.
//
Assert (pEntry->ppszDependentInfIds);
for (ipsz = 0;
pEntry->ppszDependentInfIds [ipsz];
ipsz++)
{
(VOID) FGetOrSetComponentLockDown (
TRUE, pEntry->ppszDependentInfIds [ipsz]);
}
break;
}
}
| [
"support@cryptoalgo.cf"
] | support@cryptoalgo.cf |
5885e1b586980ebbdd685d3d359ea0bf8c1729be | 016a92c438ff3286608f43a211699f1681ff4543 | /Dev_class2_handout/Motor2D/j1App.cpp | 91df6684032e6b32d95957159c2823bed132716f | [] | no_license | EricJPbunny/Development-TODOSS | f755a5ea49ca4b51ed99098d4fe9ddd062b96f5c | a55cfa71229b1d0fdebe6ce94911a0f79d7beb93 | refs/heads/master | 2020-03-29T07:35:24.098259 | 2018-10-31T10:55:59 | 2018-10-31T10:55:59 | 149,671,519 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,204 | cpp | #include "p2Defs.h"
#include "p2Log.h"
#include "j1Window.h"
#include "j1Input.h"
#include "j1Render.h"
#include "j1Textures.h"
#include "j1Audio.h"
#include "j1Scene.h"
#include "j1App.h"
// Constructor
j1App::j1App(int argc, char* args[]) : argc(argc), args(args)
{
frames = 0;
input = new j1Input();
win = new j1Window();
render = new j1Render();
tex = new j1Textures();
audio = new j1Audio();
scene = new j1Scene();
// Ordered for awake / Start / Update
// Reverse order of CleanUp
AddModule(input);
AddModule(win);
AddModule(tex);
AddModule(audio);
AddModule(scene);
// render last to swap buffer
AddModule(render);
}
// Destructor
j1App::~j1App()
{
// release modules
p2List_item<j1Module*>* item = modules.end;
while(item != NULL)
{
RELEASE(item->data);
item = item->prev;
}
modules.clear();
}
void j1App::AddModule(j1Module* module)
{
module->Init();
modules.add(module);
}
// Called before render is available
bool j1App::Awake()
{
// TODO 3: Load config.xml file using load_file() method from the xml_document class.
// If everything goes well, load the top tag inside the xml_node property
// created in the last TODO
p2List_item<j1Module*>* item;
item = modules.start;
pugi::xml_parse_result result = document.load_file("xml_files/config.xml");
if (!result)
{
LOG("Parse error: ", result.description());
}
LOG("%s", node.name());
bool ret = true;
while(item != NULL && ret == true)
{
// TODO 6: Add a new argument to the Awake method to receive a pointer to a xml node.
// If the section with the module name exist in config.xml, fill the pointer with the address of a valid xml_node
// that can be used to read all variables from that section. Send nullptr if the section does not exist in config.xml
node = document.child("config").child(item->data->name.GetString());
ret = item->data->Awake(node);
item = item->next;
}
return ret;
}
// Called before the first frame
bool j1App::Start()
{
bool ret = true;
p2List_item<j1Module*>* item;
item = modules.start;
while(item != NULL && ret == true)
{
ret = item->data->Start();
item = item->next;
}
return ret;
}
// Called each loop iteration
bool j1App::Update()
{
bool ret = true;
PrepareUpdate();
if(input->GetWindowEvent(WE_QUIT) == true)
ret = false;
if(ret == true)
ret = PreUpdate();
if(ret == true)
ret = DoUpdate();
if(ret == true)
ret = PostUpdate();
FinishUpdate();
return ret;
}
// ---------------------------------------------
void j1App::PrepareUpdate()
{
}
// ---------------------------------------------
void j1App::FinishUpdate()
{
}
// Call modules before each loop iteration
bool j1App::PreUpdate()
{
bool ret = true;
p2List_item<j1Module*>* item;
item = modules.start;
j1Module* pModule = NULL;
for(item = modules.start; item != NULL && ret == true; item = item->next)
{
pModule = item->data;
if(pModule->active == false) {
continue;
}
ret = item->data->PreUpdate();
}
return ret;
}
// Call modules on each loop iteration
bool j1App::DoUpdate()
{
bool ret = true;
p2List_item<j1Module*>* item;
item = modules.start;
j1Module* pModule = NULL;
for(item = modules.start; item != NULL && ret == true; item = item->next)
{
pModule = item->data;
if(pModule->active == false) {
continue;
}
ret = item->data->Update(dt);
}
return ret;
}
// Call modules after each loop iteration
bool j1App::PostUpdate()
{
bool ret = true;
p2List_item<j1Module*>* item;
j1Module* pModule = NULL;
for(item = modules.start; item != NULL && ret == true; item = item->next)
{
pModule = item->data;
if(pModule->active == false) {
continue;
}
ret = item->data->PostUpdate();
}
return ret;
}
// Called before quitting
bool j1App::CleanUp()
{
bool ret = true;
p2List_item<j1Module*>* item;
item = modules.end;
while(item != NULL && ret == true)
{
ret = item->data->CleanUp();
item = item->prev;
}
return ret;
}
// ---------------------------------------
int j1App::GetArgc() const
{
return argc;
}
// ---------------------------------------
const char* j1App::GetArgv(int index) const
{
if(index < argc)
return args[index];
else
return NULL;
}
| [
"36155506+EricJPbunny@users.noreply.github.com"
] | 36155506+EricJPbunny@users.noreply.github.com |
df6070bbeae3f6b2148f50db7dece8af711a8398 | 0aa317f9489faa0a242bbd23aeea3ff57e499ce3 | /multi_C/y.tab.hpp | fc610008e683cc053419ecbe35c7132bf529c91d | [] | no_license | drdrpyan/compiler | c90479790fdedc275482b4eaa3b7a23dffcb726c | da0be40b5f3624da25a900c1d0767148712ccc19 | refs/heads/master | 2016-09-16T03:34:24.535420 | 2015-09-17T12:48:12 | 2015-09-17T12:48:12 | 42,655,065 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,372 | hpp | /* A Bison parser, made by GNU Bison 2.4.2. */
/* Skeleton interface for Bison's Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2006, 2009-2010 Free Software
Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
/* Tokens. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
/* Put the tokens into the symbol table, so that GDB and other debuggers
know about them. */
enum yytokentype {
num = 258,
id = 259,
shiftL = 260,
shiftR = 261,
equal = 262,
nEqual = 263,
lEqual = 264,
gEqual = 265,
_and = 266,
_or = 267,
addAcc = 268,
subAcc = 269,
mulAcc = 270,
divAcc = 271,
modAcc = 272,
bAndAcc = 273,
bOrAcc = 274,
bXOrAcc = 275,
shlAcc = 276,
shrAcc = 277,
tInt = 278,
tChar = 279,
tVoid = 280,
tStr = 281,
_if = 282,
_else = 283,
_for = 284,
_while = 285,
_do = 286,
_return = 287,
bOpen = 288,
bClose = 289,
_ifx = 290
};
#endif
/* Tokens. */
#define num 258
#define id 259
#define shiftL 260
#define shiftR 261
#define equal 262
#define nEqual 263
#define lEqual 264
#define gEqual 265
#define _and 266
#define _or 267
#define addAcc 268
#define subAcc 269
#define mulAcc 270
#define divAcc 271
#define modAcc 272
#define bAndAcc 273
#define bOrAcc 274
#define bXOrAcc 275
#define shlAcc 276
#define shrAcc 277
#define tInt 278
#define tChar 279
#define tVoid 280
#define tStr 281
#define _if 282
#define _else 283
#define _for 284
#define _while 285
#define _do 286
#define _return 287
#define bOpen 288
#define bClose 289
#define _ifx 290
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef union YYSTYPE
{
/* Line 1685 of yacc.c */
#line 34 "multiC.y"
struct _node* pVal;
char cVal;
int iVal;
char *sVal;
/* Line 1685 of yacc.c */
#line 130 "y.tab.hpp"
} YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
#endif
extern YYSTYPE yylval;
| [
"drdrpyan@gmail.com"
] | drdrpyan@gmail.com |
28036a4d0ed5960a6919b958725a15d0cd3b1a00 | 7a5c9171daa19d444f72aaa66e33bd39a4fbb052 | /bastoul_phw1/p4.cpp | 3c9ac25958b9e75053eb4e505689b463068e36da | [] | no_license | kaycbas/parallel-computing-practice | dfafa1f94639eac0dfea231585a4da6c1ecbe58f | b403fa28c4f9983c960a2c0545431a0d6b84dd24 | refs/heads/master | 2021-05-03T10:21:51.142933 | 2018-02-06T22:44:19 | 2018-02-06T22:44:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,251 | cpp | #include <iostream>
#include <string>
#include <stdlib.h>
#include <stdio.h>
#include <cmath>
#include <chrono>
using namespace std::chrono;
struct pt {
double x;
double y;
};
int main(int argc, char *argv[]){
int NUM_OF_POINTS = 100;
//std::cout << ((double) rand() / (RAND_MAX)) << "\n";
for ( ; NUM_OF_POINTS<=1000000; NUM_OF_POINTS*=10 ) {
pt *points = new pt[NUM_OF_POINTS];
high_resolution_clock::time_point t1 = high_resolution_clock::now();
for (int i = 0; i < NUM_OF_POINTS; ++i) {
points[i].x = ((double) rand() / (RAND_MAX));
points[i].y = ((double) rand() / (RAND_MAX));
}
int numInCircle = 0;
for (int i = 0; i < NUM_OF_POINTS; ++i) {
if ( sqrt( pow((points[i].x - 0.5), 2) + pow((points[i].y - 0.5), 2) ) <= 0.5 ) {
numInCircle++;
}
}
double area = (double) numInCircle/NUM_OF_POINTS;
double pi = area/0.25;
std::cout << "With " << NUM_OF_POINTS << " points...\n";
high_resolution_clock::time_point t2 = high_resolution_clock::now();
auto duration = duration_cast<nanoseconds>( t2 - t1 ).count();
double timeSec = (double) duration/1000000000;
std::cout << "Execution time = " << duration << " nanosecs\n";
std::cout << "Pi ~ " << pi << "\n\n";
}
return 0;
} | [
"kaycbas@outlook.com"
] | kaycbas@outlook.com |
6626473064ea8d94525e30cc6a77d5424b4aa43c | cd0afa40fc68d5f26c22551e6167ff0b74864933 | /src/Camera.h | aec640ba9759b23a5d4edaa53d76f1927ebb39c0 | [
"MIT"
] | permissive | elekezem/VirtualMapper | 06050301256fac712020e42205b34ba93ea32b1a | 4ed831548b18c3ba266b30d2e19941592b9f9b39 | refs/heads/master | 2021-01-24T23:00:50.394417 | 2015-04-01T17:09:23 | 2015-04-01T17:09:23 | 37,765,912 | 1 | 1 | null | 2015-06-20T10:18:33 | 2015-06-20T10:18:31 | null | UTF-8 | C++ | false | false | 360 | h | //
// Camera.h
// videoMappingPreview
//
// Created by 麦 on 1/23/15.
//
//
#ifndef __videoMappingPreview__Camera__
#define __videoMappingPreview__Camera__
#include <stdio.h>
#include <iostream>
#include <string>
#include "ofMain.h"
using namespace std;
class Camera {
public:
string name;
ofVec3f position;
ofVec3f euler;
float fov;
};
#endif | [
"mail@baku89.com"
] | mail@baku89.com |
3b17f3b599ed07e1724c995ff66680ab75ae1b68 | c41589bc3918dc58159edd0ca38319ba7c707c03 | /Project1/practica BT/params.h | 64f6a13cb2607de8ca62f382d72fad4c9d2af8a4 | [] | no_license | godilopa/AI | 084330a23527198a9fec9391e7f715eb41fb1914 | aa202fa3e5b4b0ad4956b6538576ebdae154f8f0 | refs/heads/master | 2021-01-23T12:15:40.807956 | 2016-07-29T22:24:53 | 2016-07-29T22:24:53 | 64,512,059 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 615 | h | #ifndef __PARAMS_H__
#define __PARAMS_H__
#include "../include/Path.h"
#include <list>
struct Obstacle
{
USVec2D center;
float radius;
};
struct Params
{
USVec2D targetPosition;
float max_velocity;
float max_acceleration;
float dest_radius;
float arrive_radius;
float max_angular_velocity;
float max_angular_acceleration;
float angular_dest_radius;
float angular_arrive_radius;
float targetRotation;
Path path;
float lookAhead;
std::list<Obstacle> obstacles;
};
bool ReadParams(const char* filename, Params& params);
bool ReadObstacles(const char* filename, Params& params);
#endif | [
"limpb@LAPTOP-8AP6FQEG"
] | limpb@LAPTOP-8AP6FQEG |
c52cb5c47286db620dcd5dc9672580269bde1ae7 | c776476e9d06b3779d744641e758ac3a2c15cddc | /examples/litmus/c/run-scripts/tmp_1/SB+dmb.sy+rfi-addr-pos-ctrlisb.c.cbmc_out.cpp | 32575226c4005e4fcd72a0cb7fe1075e23c76839 | [] | no_license | ashutosh0gupta/llvm_bmc | aaac7961c723ba6f7ffd77a39559e0e52432eade | 0287c4fb180244e6b3c599a9902507f05c8a7234 | refs/heads/master | 2023-08-02T17:14:06.178723 | 2023-07-31T10:46:53 | 2023-07-31T10:46:53 | 143,100,825 | 3 | 4 | null | 2023-05-25T05:50:55 | 2018-08-01T03:47:00 | C++ | UTF-8 | C++ | false | false | 43,659 | cpp | // 0:vars:3
// 3:atom_0_X2_0:1
// 4:atom_1_X2_1:1
// 5:atom_1_X7_0:1
// 6:thr0:1
// 7:thr1:1
#define ADDRSIZE 8
#define NPROC 3
#define NCONTEXT 1
#define ASSUME(stmt) __CPROVER_assume(stmt)
#define ASSERT(stmt) __CPROVER_assert(stmt, "error")
#define max(a,b) (a>b?a:b)
char __get_rng();
char get_rng( char from, char to ) {
char ret = __get_rng();
ASSUME(ret >= from && ret <= to);
return ret;
}
char get_rng_th( char from, char to ) {
char ret = __get_rng();
ASSUME(ret >= from && ret <= to);
return ret;
}
int main(int argc, char **argv) {
// declare arrays for intial value version in contexts
int meminit_[ADDRSIZE*NCONTEXT];
#define meminit(x,k) meminit_[(x)*NCONTEXT+k]
int coinit_[ADDRSIZE*NCONTEXT];
#define coinit(x,k) coinit_[(x)*NCONTEXT+k]
int deltainit_[ADDRSIZE*NCONTEXT];
#define deltainit(x,k) deltainit_[(x)*NCONTEXT+k]
// declare arrays for running value version in contexts
int mem_[ADDRSIZE*NCONTEXT];
#define mem(x,k) mem_[(x)*NCONTEXT+k]
int co_[ADDRSIZE*NCONTEXT];
#define co(x,k) co_[(x)*NCONTEXT+k]
int delta_[ADDRSIZE*NCONTEXT];
#define delta(x,k) delta_[(x)*NCONTEXT+k]
// declare arrays for local buffer and observed writes
int buff_[NPROC*ADDRSIZE];
#define buff(x,k) buff_[(x)*ADDRSIZE+k]
int pw_[NPROC*ADDRSIZE];
#define pw(x,k) pw_[(x)*ADDRSIZE+k]
// declare arrays for context stamps
char cr_[NPROC*ADDRSIZE];
#define cr(x,k) cr_[(x)*ADDRSIZE+k]
char iw_[NPROC*ADDRSIZE];
#define iw(x,k) iw_[(x)*ADDRSIZE+k]
char cw_[NPROC*ADDRSIZE];
#define cw(x,k) cw_[(x)*ADDRSIZE+k]
char cx_[NPROC*ADDRSIZE];
#define cx(x,k) cx_[(x)*ADDRSIZE+k]
char is_[NPROC*ADDRSIZE];
#define is(x,k) is_[(x)*ADDRSIZE+k]
char cs_[NPROC*ADDRSIZE];
#define cs(x,k) cs_[(x)*ADDRSIZE+k]
char crmax_[NPROC*ADDRSIZE];
#define crmax(x,k) crmax_[(x)*ADDRSIZE+k]
char sforbid_[ADDRSIZE*NCONTEXT];
#define sforbid(x,k) sforbid_[(x)*NCONTEXT+k]
// declare arrays for synchronizations
int cl[NPROC];
int cdy[NPROC];
int cds[NPROC];
int cdl[NPROC];
int cisb[NPROC];
int caddr[NPROC];
int cctrl[NPROC];
int cstart[NPROC];
int creturn[NPROC];
// declare arrays for contexts activity
int active[NCONTEXT];
int ctx_used[NCONTEXT];
int r0= 0;
char creg_r0;
int r1= 0;
char creg_r1;
int r2= 0;
char creg_r2;
int r3= 0;
char creg_r3;
int r4= 0;
char creg_r4;
int r5= 0;
char creg_r5;
int r6= 0;
char creg_r6;
int r7= 0;
char creg_r7;
int r8= 0;
char creg_r8;
int r9= 0;
char creg_r9;
int r10= 0;
char creg_r10;
int r11= 0;
char creg_r11;
int r12= 0;
char creg_r12;
int r13= 0;
char creg_r13;
int r14= 0;
char creg_r14;
int r15= 0;
char creg_r15;
int r16= 0;
char creg_r16;
int r17= 0;
char creg_r17;
int r18= 0;
char creg_r18;
int r19= 0;
char creg_r19;
int r20= 0;
char creg_r20;
char old_cctrl= 0;
char old_cr= 0;
char old_cdy= 0;
char old_cw= 0;
char new_creg= 0;
buff(0,0) = 0;
pw(0,0) = 0;
cr(0,0) = 0;
iw(0,0) = 0;
cw(0,0) = 0;
cx(0,0) = 0;
is(0,0) = 0;
cs(0,0) = 0;
crmax(0,0) = 0;
buff(0,1) = 0;
pw(0,1) = 0;
cr(0,1) = 0;
iw(0,1) = 0;
cw(0,1) = 0;
cx(0,1) = 0;
is(0,1) = 0;
cs(0,1) = 0;
crmax(0,1) = 0;
buff(0,2) = 0;
pw(0,2) = 0;
cr(0,2) = 0;
iw(0,2) = 0;
cw(0,2) = 0;
cx(0,2) = 0;
is(0,2) = 0;
cs(0,2) = 0;
crmax(0,2) = 0;
buff(0,3) = 0;
pw(0,3) = 0;
cr(0,3) = 0;
iw(0,3) = 0;
cw(0,3) = 0;
cx(0,3) = 0;
is(0,3) = 0;
cs(0,3) = 0;
crmax(0,3) = 0;
buff(0,4) = 0;
pw(0,4) = 0;
cr(0,4) = 0;
iw(0,4) = 0;
cw(0,4) = 0;
cx(0,4) = 0;
is(0,4) = 0;
cs(0,4) = 0;
crmax(0,4) = 0;
buff(0,5) = 0;
pw(0,5) = 0;
cr(0,5) = 0;
iw(0,5) = 0;
cw(0,5) = 0;
cx(0,5) = 0;
is(0,5) = 0;
cs(0,5) = 0;
crmax(0,5) = 0;
buff(0,6) = 0;
pw(0,6) = 0;
cr(0,6) = 0;
iw(0,6) = 0;
cw(0,6) = 0;
cx(0,6) = 0;
is(0,6) = 0;
cs(0,6) = 0;
crmax(0,6) = 0;
buff(0,7) = 0;
pw(0,7) = 0;
cr(0,7) = 0;
iw(0,7) = 0;
cw(0,7) = 0;
cx(0,7) = 0;
is(0,7) = 0;
cs(0,7) = 0;
crmax(0,7) = 0;
cl[0] = 0;
cdy[0] = 0;
cds[0] = 0;
cdl[0] = 0;
cisb[0] = 0;
caddr[0] = 0;
cctrl[0] = 0;
cstart[0] = get_rng(0,NCONTEXT-1);
creturn[0] = get_rng(0,NCONTEXT-1);
buff(1,0) = 0;
pw(1,0) = 0;
cr(1,0) = 0;
iw(1,0) = 0;
cw(1,0) = 0;
cx(1,0) = 0;
is(1,0) = 0;
cs(1,0) = 0;
crmax(1,0) = 0;
buff(1,1) = 0;
pw(1,1) = 0;
cr(1,1) = 0;
iw(1,1) = 0;
cw(1,1) = 0;
cx(1,1) = 0;
is(1,1) = 0;
cs(1,1) = 0;
crmax(1,1) = 0;
buff(1,2) = 0;
pw(1,2) = 0;
cr(1,2) = 0;
iw(1,2) = 0;
cw(1,2) = 0;
cx(1,2) = 0;
is(1,2) = 0;
cs(1,2) = 0;
crmax(1,2) = 0;
buff(1,3) = 0;
pw(1,3) = 0;
cr(1,3) = 0;
iw(1,3) = 0;
cw(1,3) = 0;
cx(1,3) = 0;
is(1,3) = 0;
cs(1,3) = 0;
crmax(1,3) = 0;
buff(1,4) = 0;
pw(1,4) = 0;
cr(1,4) = 0;
iw(1,4) = 0;
cw(1,4) = 0;
cx(1,4) = 0;
is(1,4) = 0;
cs(1,4) = 0;
crmax(1,4) = 0;
buff(1,5) = 0;
pw(1,5) = 0;
cr(1,5) = 0;
iw(1,5) = 0;
cw(1,5) = 0;
cx(1,5) = 0;
is(1,5) = 0;
cs(1,5) = 0;
crmax(1,5) = 0;
buff(1,6) = 0;
pw(1,6) = 0;
cr(1,6) = 0;
iw(1,6) = 0;
cw(1,6) = 0;
cx(1,6) = 0;
is(1,6) = 0;
cs(1,6) = 0;
crmax(1,6) = 0;
buff(1,7) = 0;
pw(1,7) = 0;
cr(1,7) = 0;
iw(1,7) = 0;
cw(1,7) = 0;
cx(1,7) = 0;
is(1,7) = 0;
cs(1,7) = 0;
crmax(1,7) = 0;
cl[1] = 0;
cdy[1] = 0;
cds[1] = 0;
cdl[1] = 0;
cisb[1] = 0;
caddr[1] = 0;
cctrl[1] = 0;
cstart[1] = get_rng(0,NCONTEXT-1);
creturn[1] = get_rng(0,NCONTEXT-1);
buff(2,0) = 0;
pw(2,0) = 0;
cr(2,0) = 0;
iw(2,0) = 0;
cw(2,0) = 0;
cx(2,0) = 0;
is(2,0) = 0;
cs(2,0) = 0;
crmax(2,0) = 0;
buff(2,1) = 0;
pw(2,1) = 0;
cr(2,1) = 0;
iw(2,1) = 0;
cw(2,1) = 0;
cx(2,1) = 0;
is(2,1) = 0;
cs(2,1) = 0;
crmax(2,1) = 0;
buff(2,2) = 0;
pw(2,2) = 0;
cr(2,2) = 0;
iw(2,2) = 0;
cw(2,2) = 0;
cx(2,2) = 0;
is(2,2) = 0;
cs(2,2) = 0;
crmax(2,2) = 0;
buff(2,3) = 0;
pw(2,3) = 0;
cr(2,3) = 0;
iw(2,3) = 0;
cw(2,3) = 0;
cx(2,3) = 0;
is(2,3) = 0;
cs(2,3) = 0;
crmax(2,3) = 0;
buff(2,4) = 0;
pw(2,4) = 0;
cr(2,4) = 0;
iw(2,4) = 0;
cw(2,4) = 0;
cx(2,4) = 0;
is(2,4) = 0;
cs(2,4) = 0;
crmax(2,4) = 0;
buff(2,5) = 0;
pw(2,5) = 0;
cr(2,5) = 0;
iw(2,5) = 0;
cw(2,5) = 0;
cx(2,5) = 0;
is(2,5) = 0;
cs(2,5) = 0;
crmax(2,5) = 0;
buff(2,6) = 0;
pw(2,6) = 0;
cr(2,6) = 0;
iw(2,6) = 0;
cw(2,6) = 0;
cx(2,6) = 0;
is(2,6) = 0;
cs(2,6) = 0;
crmax(2,6) = 0;
buff(2,7) = 0;
pw(2,7) = 0;
cr(2,7) = 0;
iw(2,7) = 0;
cw(2,7) = 0;
cx(2,7) = 0;
is(2,7) = 0;
cs(2,7) = 0;
crmax(2,7) = 0;
cl[2] = 0;
cdy[2] = 0;
cds[2] = 0;
cdl[2] = 0;
cisb[2] = 0;
caddr[2] = 0;
cctrl[2] = 0;
cstart[2] = get_rng(0,NCONTEXT-1);
creturn[2] = get_rng(0,NCONTEXT-1);
// Dumping initializations
mem(0+0,0) = 0;
mem(0+1,0) = 0;
mem(0+2,0) = 0;
mem(3+0,0) = 0;
mem(4+0,0) = 0;
mem(5+0,0) = 0;
mem(6+0,0) = 0;
mem(7+0,0) = 0;
// Dumping context matching equalities
co(0,0) = 0;
delta(0,0) = -1;
co(1,0) = 0;
delta(1,0) = -1;
co(2,0) = 0;
delta(2,0) = -1;
co(3,0) = 0;
delta(3,0) = -1;
co(4,0) = 0;
delta(4,0) = -1;
co(5,0) = 0;
delta(5,0) = -1;
co(6,0) = 0;
delta(6,0) = -1;
co(7,0) = 0;
delta(7,0) = -1;
// Dumping thread 1
int ret_thread_1 = 0;
cdy[1] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[1] >= cstart[1]);
T1BLOCK0:
// call void @llvm.dbg.value(metadata i8* %arg, metadata !37, metadata !DIExpression()), !dbg !52
// br label %label_1, !dbg !53
goto T1BLOCK1;
T1BLOCK1:
// call void @llvm.dbg.label(metadata !51), !dbg !54
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0), metadata !38, metadata !DIExpression()), !dbg !55
// call void @llvm.dbg.value(metadata i64 1, metadata !41, metadata !DIExpression()), !dbg !55
// store atomic i64 1, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !56
// ST: Guess
iw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STIW
old_cw = cw(1,0);
cw(1,0) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STCOM
// Check
ASSUME(active[iw(1,0)] == 1);
ASSUME(active[cw(1,0)] == 1);
ASSUME(sforbid(0,cw(1,0))== 0);
ASSUME(iw(1,0) >= 0);
ASSUME(iw(1,0) >= 0);
ASSUME(cw(1,0) >= iw(1,0));
ASSUME(cw(1,0) >= old_cw);
ASSUME(cw(1,0) >= cr(1,0));
ASSUME(cw(1,0) >= cl[1]);
ASSUME(cw(1,0) >= cisb[1]);
ASSUME(cw(1,0) >= cdy[1]);
ASSUME(cw(1,0) >= cdl[1]);
ASSUME(cw(1,0) >= cds[1]);
ASSUME(cw(1,0) >= cctrl[1]);
ASSUME(cw(1,0) >= caddr[1]);
// Update
caddr[1] = max(caddr[1],0);
buff(1,0) = 1;
mem(0,cw(1,0)) = 1;
co(0,cw(1,0))+=1;
delta(0,cw(1,0)) = -1;
ASSUME(creturn[1] >= cw(1,0));
// call void (...) @dmbsy(), !dbg !57
// dumbsy: Guess
old_cdy = cdy[1];
cdy[1] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[1] >= old_cdy);
ASSUME(cdy[1] >= cisb[1]);
ASSUME(cdy[1] >= cdl[1]);
ASSUME(cdy[1] >= cds[1]);
ASSUME(cdy[1] >= cctrl[1]);
ASSUME(cdy[1] >= cw(1,0+0));
ASSUME(cdy[1] >= cw(1,0+1));
ASSUME(cdy[1] >= cw(1,0+2));
ASSUME(cdy[1] >= cw(1,3+0));
ASSUME(cdy[1] >= cw(1,4+0));
ASSUME(cdy[1] >= cw(1,5+0));
ASSUME(cdy[1] >= cw(1,6+0));
ASSUME(cdy[1] >= cw(1,7+0));
ASSUME(cdy[1] >= cr(1,0+0));
ASSUME(cdy[1] >= cr(1,0+1));
ASSUME(cdy[1] >= cr(1,0+2));
ASSUME(cdy[1] >= cr(1,3+0));
ASSUME(cdy[1] >= cr(1,4+0));
ASSUME(cdy[1] >= cr(1,5+0));
ASSUME(cdy[1] >= cr(1,6+0));
ASSUME(cdy[1] >= cr(1,7+0));
ASSUME(creturn[1] >= cdy[1]);
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1), metadata !44, metadata !DIExpression()), !dbg !58
// %0 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !59
// LD: Guess
old_cr = cr(1,0+1*1);
cr(1,0+1*1) = get_rng(0,NCONTEXT-1);// 1 ASSIGN LDCOM
// Check
ASSUME(active[cr(1,0+1*1)] == 1);
ASSUME(cr(1,0+1*1) >= iw(1,0+1*1));
ASSUME(cr(1,0+1*1) >= 0);
ASSUME(cr(1,0+1*1) >= cdy[1]);
ASSUME(cr(1,0+1*1) >= cisb[1]);
ASSUME(cr(1,0+1*1) >= cdl[1]);
ASSUME(cr(1,0+1*1) >= cl[1]);
// Update
creg_r0 = cr(1,0+1*1);
crmax(1,0+1*1) = max(crmax(1,0+1*1),cr(1,0+1*1));
caddr[1] = max(caddr[1],0);
if(cr(1,0+1*1) < cw(1,0+1*1)) {
r0 = buff(1,0+1*1);
} else {
if(pw(1,0+1*1) != co(0+1*1,cr(1,0+1*1))) {
ASSUME(cr(1,0+1*1) >= old_cr);
}
pw(1,0+1*1) = co(0+1*1,cr(1,0+1*1));
r0 = mem(0+1*1,cr(1,0+1*1));
}
ASSUME(creturn[1] >= cr(1,0+1*1));
// call void @llvm.dbg.value(metadata i64 %0, metadata !46, metadata !DIExpression()), !dbg !58
// %conv = trunc i64 %0 to i32, !dbg !60
// call void @llvm.dbg.value(metadata i32 %conv, metadata !42, metadata !DIExpression()), !dbg !52
// %cmp = icmp eq i32 %conv, 0, !dbg !61
// %conv1 = zext i1 %cmp to i32, !dbg !61
// call void @llvm.dbg.value(metadata i32 %conv1, metadata !47, metadata !DIExpression()), !dbg !52
// call void @llvm.dbg.value(metadata i64* @atom_0_X2_0, metadata !48, metadata !DIExpression()), !dbg !62
// %1 = zext i32 %conv1 to i64
// call void @llvm.dbg.value(metadata i64 %1, metadata !50, metadata !DIExpression()), !dbg !62
// store atomic i64 %1, i64* @atom_0_X2_0 seq_cst, align 8, !dbg !63
// ST: Guess
iw(1,3) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STIW
old_cw = cw(1,3);
cw(1,3) = get_rng(0,NCONTEXT-1);// 1 ASSIGN STCOM
// Check
ASSUME(active[iw(1,3)] == 1);
ASSUME(active[cw(1,3)] == 1);
ASSUME(sforbid(3,cw(1,3))== 0);
ASSUME(iw(1,3) >= max(creg_r0,0));
ASSUME(iw(1,3) >= 0);
ASSUME(cw(1,3) >= iw(1,3));
ASSUME(cw(1,3) >= old_cw);
ASSUME(cw(1,3) >= cr(1,3));
ASSUME(cw(1,3) >= cl[1]);
ASSUME(cw(1,3) >= cisb[1]);
ASSUME(cw(1,3) >= cdy[1]);
ASSUME(cw(1,3) >= cdl[1]);
ASSUME(cw(1,3) >= cds[1]);
ASSUME(cw(1,3) >= cctrl[1]);
ASSUME(cw(1,3) >= caddr[1]);
// Update
caddr[1] = max(caddr[1],0);
buff(1,3) = (r0==0);
mem(3,cw(1,3)) = (r0==0);
co(3,cw(1,3))+=1;
delta(3,cw(1,3)) = -1;
ASSUME(creturn[1] >= cw(1,3));
// ret i8* null, !dbg !64
ret_thread_1 = (- 1);
// Dumping thread 2
int ret_thread_2 = 0;
cdy[2] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[2] >= cstart[2]);
T2BLOCK0:
// call void @llvm.dbg.value(metadata i8* %arg, metadata !67, metadata !DIExpression()), !dbg !98
// br label %label_2, !dbg !71
goto T2BLOCK1;
T2BLOCK1:
// call void @llvm.dbg.label(metadata !96), !dbg !100
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1), metadata !68, metadata !DIExpression()), !dbg !101
// call void @llvm.dbg.value(metadata i64 1, metadata !70, metadata !DIExpression()), !dbg !101
// store atomic i64 1, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !74
// ST: Guess
iw(2,0+1*1) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW
old_cw = cw(2,0+1*1);
cw(2,0+1*1) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM
// Check
ASSUME(active[iw(2,0+1*1)] == 2);
ASSUME(active[cw(2,0+1*1)] == 2);
ASSUME(sforbid(0+1*1,cw(2,0+1*1))== 0);
ASSUME(iw(2,0+1*1) >= 0);
ASSUME(iw(2,0+1*1) >= 0);
ASSUME(cw(2,0+1*1) >= iw(2,0+1*1));
ASSUME(cw(2,0+1*1) >= old_cw);
ASSUME(cw(2,0+1*1) >= cr(2,0+1*1));
ASSUME(cw(2,0+1*1) >= cl[2]);
ASSUME(cw(2,0+1*1) >= cisb[2]);
ASSUME(cw(2,0+1*1) >= cdy[2]);
ASSUME(cw(2,0+1*1) >= cdl[2]);
ASSUME(cw(2,0+1*1) >= cds[2]);
ASSUME(cw(2,0+1*1) >= cctrl[2]);
ASSUME(cw(2,0+1*1) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,0+1*1) = 1;
mem(0+1*1,cw(2,0+1*1)) = 1;
co(0+1*1,cw(2,0+1*1))+=1;
delta(0+1*1,cw(2,0+1*1)) = -1;
ASSUME(creturn[2] >= cw(2,0+1*1));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1), metadata !72, metadata !DIExpression()), !dbg !103
// %0 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !76
// LD: Guess
old_cr = cr(2,0+1*1);
cr(2,0+1*1) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM
// Check
ASSUME(active[cr(2,0+1*1)] == 2);
ASSUME(cr(2,0+1*1) >= iw(2,0+1*1));
ASSUME(cr(2,0+1*1) >= 0);
ASSUME(cr(2,0+1*1) >= cdy[2]);
ASSUME(cr(2,0+1*1) >= cisb[2]);
ASSUME(cr(2,0+1*1) >= cdl[2]);
ASSUME(cr(2,0+1*1) >= cl[2]);
// Update
creg_r1 = cr(2,0+1*1);
crmax(2,0+1*1) = max(crmax(2,0+1*1),cr(2,0+1*1));
caddr[2] = max(caddr[2],0);
if(cr(2,0+1*1) < cw(2,0+1*1)) {
r1 = buff(2,0+1*1);
} else {
if(pw(2,0+1*1) != co(0+1*1,cr(2,0+1*1))) {
ASSUME(cr(2,0+1*1) >= old_cr);
}
pw(2,0+1*1) = co(0+1*1,cr(2,0+1*1));
r1 = mem(0+1*1,cr(2,0+1*1));
}
ASSUME(creturn[2] >= cr(2,0+1*1));
// call void @llvm.dbg.value(metadata i64 %0, metadata !74, metadata !DIExpression()), !dbg !103
// %conv = trunc i64 %0 to i32, !dbg !77
// call void @llvm.dbg.value(metadata i32 %conv, metadata !71, metadata !DIExpression()), !dbg !98
// %xor = xor i32 %conv, %conv, !dbg !78
creg_r2 = max(creg_r1,creg_r1);
ASSUME(active[creg_r2] == 2);
r2 = r1 ^ r1;
// call void @llvm.dbg.value(metadata i32 %xor, metadata !75, metadata !DIExpression()), !dbg !98
// %add = add nsw i32 2, %xor, !dbg !79
creg_r3 = max(0,creg_r2);
ASSUME(active[creg_r3] == 2);
r3 = 2 + r2;
// %idxprom = sext i32 %add to i64, !dbg !79
// %arrayidx = getelementptr inbounds [3 x i64], [3 x i64]* @vars, i64 0, i64 %idxprom, !dbg !79
r4 = 0+r3*1;
ASSUME(creg_r4 >= 0);
ASSUME(creg_r4 >= creg_r3);
ASSUME(active[creg_r4] == 2);
// call void @llvm.dbg.value(metadata i64* %arrayidx, metadata !77, metadata !DIExpression()), !dbg !108
// %1 = load atomic i64, i64* %arrayidx monotonic, align 8, !dbg !79
// LD: Guess
old_cr = cr(2,r4);
cr(2,r4) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM
// Check
ASSUME(active[cr(2,r4)] == 2);
ASSUME(cr(2,r4) >= iw(2,r4));
ASSUME(cr(2,r4) >= creg_r4);
ASSUME(cr(2,r4) >= cdy[2]);
ASSUME(cr(2,r4) >= cisb[2]);
ASSUME(cr(2,r4) >= cdl[2]);
ASSUME(cr(2,r4) >= cl[2]);
// Update
creg_r5 = cr(2,r4);
crmax(2,r4) = max(crmax(2,r4),cr(2,r4));
caddr[2] = max(caddr[2],creg_r4);
if(cr(2,r4) < cw(2,r4)) {
r5 = buff(2,r4);
} else {
if(pw(2,r4) != co(r4,cr(2,r4))) {
ASSUME(cr(2,r4) >= old_cr);
}
pw(2,r4) = co(r4,cr(2,r4));
r5 = mem(r4,cr(2,r4));
}
ASSUME(creturn[2] >= cr(2,r4));
// call void @llvm.dbg.value(metadata i64 %1, metadata !79, metadata !DIExpression()), !dbg !108
// %conv4 = trunc i64 %1 to i32, !dbg !81
// call void @llvm.dbg.value(metadata i32 %conv4, metadata !76, metadata !DIExpression()), !dbg !98
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2), metadata !81, metadata !DIExpression()), !dbg !110
// %2 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2) monotonic, align 8, !dbg !83
// LD: Guess
old_cr = cr(2,0+2*1);
cr(2,0+2*1) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM
// Check
ASSUME(active[cr(2,0+2*1)] == 2);
ASSUME(cr(2,0+2*1) >= iw(2,0+2*1));
ASSUME(cr(2,0+2*1) >= 0);
ASSUME(cr(2,0+2*1) >= cdy[2]);
ASSUME(cr(2,0+2*1) >= cisb[2]);
ASSUME(cr(2,0+2*1) >= cdl[2]);
ASSUME(cr(2,0+2*1) >= cl[2]);
// Update
creg_r6 = cr(2,0+2*1);
crmax(2,0+2*1) = max(crmax(2,0+2*1),cr(2,0+2*1));
caddr[2] = max(caddr[2],0);
if(cr(2,0+2*1) < cw(2,0+2*1)) {
r6 = buff(2,0+2*1);
} else {
if(pw(2,0+2*1) != co(0+2*1,cr(2,0+2*1))) {
ASSUME(cr(2,0+2*1) >= old_cr);
}
pw(2,0+2*1) = co(0+2*1,cr(2,0+2*1));
r6 = mem(0+2*1,cr(2,0+2*1));
}
ASSUME(creturn[2] >= cr(2,0+2*1));
// call void @llvm.dbg.value(metadata i64 %2, metadata !83, metadata !DIExpression()), !dbg !110
// %conv8 = trunc i64 %2 to i32, !dbg !84
// call void @llvm.dbg.value(metadata i32 %conv8, metadata !80, metadata !DIExpression()), !dbg !98
// %tobool = icmp ne i32 %conv8, 0, !dbg !85
// br i1 %tobool, label %if.then, label %if.else, !dbg !87
old_cctrl = cctrl[2];
cctrl[2] = get_rng(0,NCONTEXT-1);
ASSUME(cctrl[2] >= old_cctrl);
ASSUME(cctrl[2] >= creg_r6);
ASSUME(cctrl[2] >= 0);
if((r6!=0)) {
goto T2BLOCK2;
} else {
goto T2BLOCK3;
}
T2BLOCK2:
// br label %lbl_LC00, !dbg !88
goto T2BLOCK4;
T2BLOCK3:
// br label %lbl_LC00, !dbg !89
goto T2BLOCK4;
T2BLOCK4:
// call void @llvm.dbg.label(metadata !97), !dbg !118
// call void (...) @isb(), !dbg !91
// isb: Guess
cisb[2] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cisb[2] >= cdy[2]);
ASSUME(cisb[2] >= cctrl[2]);
ASSUME(cisb[2] >= caddr[2]);
ASSUME(creturn[2] >= cisb[2]);
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0), metadata !85, metadata !DIExpression()), !dbg !120
// %3 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !93
// LD: Guess
old_cr = cr(2,0);
cr(2,0) = get_rng(0,NCONTEXT-1);// 2 ASSIGN LDCOM
// Check
ASSUME(active[cr(2,0)] == 2);
ASSUME(cr(2,0) >= iw(2,0));
ASSUME(cr(2,0) >= 0);
ASSUME(cr(2,0) >= cdy[2]);
ASSUME(cr(2,0) >= cisb[2]);
ASSUME(cr(2,0) >= cdl[2]);
ASSUME(cr(2,0) >= cl[2]);
// Update
creg_r7 = cr(2,0);
crmax(2,0) = max(crmax(2,0),cr(2,0));
caddr[2] = max(caddr[2],0);
if(cr(2,0) < cw(2,0)) {
r7 = buff(2,0);
} else {
if(pw(2,0) != co(0,cr(2,0))) {
ASSUME(cr(2,0) >= old_cr);
}
pw(2,0) = co(0,cr(2,0));
r7 = mem(0,cr(2,0));
}
ASSUME(creturn[2] >= cr(2,0));
// call void @llvm.dbg.value(metadata i64 %3, metadata !87, metadata !DIExpression()), !dbg !120
// %conv12 = trunc i64 %3 to i32, !dbg !94
// call void @llvm.dbg.value(metadata i32 %conv12, metadata !84, metadata !DIExpression()), !dbg !98
// %cmp = icmp eq i32 %conv, 1, !dbg !95
// %conv13 = zext i1 %cmp to i32, !dbg !95
// call void @llvm.dbg.value(metadata i32 %conv13, metadata !88, metadata !DIExpression()), !dbg !98
// call void @llvm.dbg.value(metadata i64* @atom_1_X2_1, metadata !89, metadata !DIExpression()), !dbg !124
// %4 = zext i32 %conv13 to i64
// call void @llvm.dbg.value(metadata i64 %4, metadata !91, metadata !DIExpression()), !dbg !124
// store atomic i64 %4, i64* @atom_1_X2_1 seq_cst, align 8, !dbg !97
// ST: Guess
iw(2,4) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW
old_cw = cw(2,4);
cw(2,4) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM
// Check
ASSUME(active[iw(2,4)] == 2);
ASSUME(active[cw(2,4)] == 2);
ASSUME(sforbid(4,cw(2,4))== 0);
ASSUME(iw(2,4) >= max(creg_r1,0));
ASSUME(iw(2,4) >= 0);
ASSUME(cw(2,4) >= iw(2,4));
ASSUME(cw(2,4) >= old_cw);
ASSUME(cw(2,4) >= cr(2,4));
ASSUME(cw(2,4) >= cl[2]);
ASSUME(cw(2,4) >= cisb[2]);
ASSUME(cw(2,4) >= cdy[2]);
ASSUME(cw(2,4) >= cdl[2]);
ASSUME(cw(2,4) >= cds[2]);
ASSUME(cw(2,4) >= cctrl[2]);
ASSUME(cw(2,4) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,4) = (r1==1);
mem(4,cw(2,4)) = (r1==1);
co(4,cw(2,4))+=1;
delta(4,cw(2,4)) = -1;
ASSUME(creturn[2] >= cw(2,4));
// %cmp17 = icmp eq i32 %conv12, 0, !dbg !98
// %conv18 = zext i1 %cmp17 to i32, !dbg !98
// call void @llvm.dbg.value(metadata i32 %conv18, metadata !92, metadata !DIExpression()), !dbg !98
// call void @llvm.dbg.value(metadata i64* @atom_1_X7_0, metadata !93, metadata !DIExpression()), !dbg !127
// %5 = zext i32 %conv18 to i64
// call void @llvm.dbg.value(metadata i64 %5, metadata !95, metadata !DIExpression()), !dbg !127
// store atomic i64 %5, i64* @atom_1_X7_0 seq_cst, align 8, !dbg !100
// ST: Guess
iw(2,5) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STIW
old_cw = cw(2,5);
cw(2,5) = get_rng(0,NCONTEXT-1);// 2 ASSIGN STCOM
// Check
ASSUME(active[iw(2,5)] == 2);
ASSUME(active[cw(2,5)] == 2);
ASSUME(sforbid(5,cw(2,5))== 0);
ASSUME(iw(2,5) >= max(creg_r7,0));
ASSUME(iw(2,5) >= 0);
ASSUME(cw(2,5) >= iw(2,5));
ASSUME(cw(2,5) >= old_cw);
ASSUME(cw(2,5) >= cr(2,5));
ASSUME(cw(2,5) >= cl[2]);
ASSUME(cw(2,5) >= cisb[2]);
ASSUME(cw(2,5) >= cdy[2]);
ASSUME(cw(2,5) >= cdl[2]);
ASSUME(cw(2,5) >= cds[2]);
ASSUME(cw(2,5) >= cctrl[2]);
ASSUME(cw(2,5) >= caddr[2]);
// Update
caddr[2] = max(caddr[2],0);
buff(2,5) = (r7==0);
mem(5,cw(2,5)) = (r7==0);
co(5,cw(2,5))+=1;
delta(5,cw(2,5)) = -1;
ASSUME(creturn[2] >= cw(2,5));
// ret i8* null, !dbg !101
ret_thread_2 = (- 1);
// Dumping thread 0
int ret_thread_0 = 0;
cdy[0] = get_rng(0,NCONTEXT-1);
ASSUME(cdy[0] >= cstart[0]);
T0BLOCK0:
// %thr0 = alloca i64, align 8
// %thr1 = alloca i64, align 8
// call void @llvm.dbg.value(metadata i32 %argc, metadata !137, metadata !DIExpression()), !dbg !188
// call void @llvm.dbg.value(metadata i8** %argv, metadata !138, metadata !DIExpression()), !dbg !188
// %0 = bitcast i64* %thr0 to i8*, !dbg !94
// call void @llvm.lifetime.start.p0i8(i64 8, i8* %0) #6, !dbg !94
// call void @llvm.dbg.declare(metadata i64* %thr0, metadata !139, metadata !DIExpression()), !dbg !190
// %1 = bitcast i64* %thr1 to i8*, !dbg !96
// call void @llvm.lifetime.start.p0i8(i64 8, i8* %1) #6, !dbg !96
// call void @llvm.dbg.declare(metadata i64* %thr1, metadata !143, metadata !DIExpression()), !dbg !192
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2), metadata !144, metadata !DIExpression()), !dbg !193
// call void @llvm.dbg.value(metadata i64 0, metadata !146, metadata !DIExpression()), !dbg !193
// store atomic i64 0, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 2) monotonic, align 8, !dbg !99
// ST: Guess
iw(0,0+2*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,0+2*1);
cw(0,0+2*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,0+2*1)] == 0);
ASSUME(active[cw(0,0+2*1)] == 0);
ASSUME(sforbid(0+2*1,cw(0,0+2*1))== 0);
ASSUME(iw(0,0+2*1) >= 0);
ASSUME(iw(0,0+2*1) >= 0);
ASSUME(cw(0,0+2*1) >= iw(0,0+2*1));
ASSUME(cw(0,0+2*1) >= old_cw);
ASSUME(cw(0,0+2*1) >= cr(0,0+2*1));
ASSUME(cw(0,0+2*1) >= cl[0]);
ASSUME(cw(0,0+2*1) >= cisb[0]);
ASSUME(cw(0,0+2*1) >= cdy[0]);
ASSUME(cw(0,0+2*1) >= cdl[0]);
ASSUME(cw(0,0+2*1) >= cds[0]);
ASSUME(cw(0,0+2*1) >= cctrl[0]);
ASSUME(cw(0,0+2*1) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,0+2*1) = 0;
mem(0+2*1,cw(0,0+2*1)) = 0;
co(0+2*1,cw(0,0+2*1))+=1;
delta(0+2*1,cw(0,0+2*1)) = -1;
ASSUME(creturn[0] >= cw(0,0+2*1));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1), metadata !147, metadata !DIExpression()), !dbg !195
// call void @llvm.dbg.value(metadata i64 0, metadata !149, metadata !DIExpression()), !dbg !195
// store atomic i64 0, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1) monotonic, align 8, !dbg !101
// ST: Guess
iw(0,0+1*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,0+1*1);
cw(0,0+1*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,0+1*1)] == 0);
ASSUME(active[cw(0,0+1*1)] == 0);
ASSUME(sforbid(0+1*1,cw(0,0+1*1))== 0);
ASSUME(iw(0,0+1*1) >= 0);
ASSUME(iw(0,0+1*1) >= 0);
ASSUME(cw(0,0+1*1) >= iw(0,0+1*1));
ASSUME(cw(0,0+1*1) >= old_cw);
ASSUME(cw(0,0+1*1) >= cr(0,0+1*1));
ASSUME(cw(0,0+1*1) >= cl[0]);
ASSUME(cw(0,0+1*1) >= cisb[0]);
ASSUME(cw(0,0+1*1) >= cdy[0]);
ASSUME(cw(0,0+1*1) >= cdl[0]);
ASSUME(cw(0,0+1*1) >= cds[0]);
ASSUME(cw(0,0+1*1) >= cctrl[0]);
ASSUME(cw(0,0+1*1) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,0+1*1) = 0;
mem(0+1*1,cw(0,0+1*1)) = 0;
co(0+1*1,cw(0,0+1*1))+=1;
delta(0+1*1,cw(0,0+1*1)) = -1;
ASSUME(creturn[0] >= cw(0,0+1*1));
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0), metadata !150, metadata !DIExpression()), !dbg !197
// call void @llvm.dbg.value(metadata i64 0, metadata !152, metadata !DIExpression()), !dbg !197
// store atomic i64 0, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0) monotonic, align 8, !dbg !103
// ST: Guess
iw(0,0) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,0);
cw(0,0) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,0)] == 0);
ASSUME(active[cw(0,0)] == 0);
ASSUME(sforbid(0,cw(0,0))== 0);
ASSUME(iw(0,0) >= 0);
ASSUME(iw(0,0) >= 0);
ASSUME(cw(0,0) >= iw(0,0));
ASSUME(cw(0,0) >= old_cw);
ASSUME(cw(0,0) >= cr(0,0));
ASSUME(cw(0,0) >= cl[0]);
ASSUME(cw(0,0) >= cisb[0]);
ASSUME(cw(0,0) >= cdy[0]);
ASSUME(cw(0,0) >= cdl[0]);
ASSUME(cw(0,0) >= cds[0]);
ASSUME(cw(0,0) >= cctrl[0]);
ASSUME(cw(0,0) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,0) = 0;
mem(0,cw(0,0)) = 0;
co(0,cw(0,0))+=1;
delta(0,cw(0,0)) = -1;
ASSUME(creturn[0] >= cw(0,0));
// call void @llvm.dbg.value(metadata i64* @atom_0_X2_0, metadata !153, metadata !DIExpression()), !dbg !199
// call void @llvm.dbg.value(metadata i64 0, metadata !155, metadata !DIExpression()), !dbg !199
// store atomic i64 0, i64* @atom_0_X2_0 monotonic, align 8, !dbg !105
// ST: Guess
iw(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,3);
cw(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,3)] == 0);
ASSUME(active[cw(0,3)] == 0);
ASSUME(sforbid(3,cw(0,3))== 0);
ASSUME(iw(0,3) >= 0);
ASSUME(iw(0,3) >= 0);
ASSUME(cw(0,3) >= iw(0,3));
ASSUME(cw(0,3) >= old_cw);
ASSUME(cw(0,3) >= cr(0,3));
ASSUME(cw(0,3) >= cl[0]);
ASSUME(cw(0,3) >= cisb[0]);
ASSUME(cw(0,3) >= cdy[0]);
ASSUME(cw(0,3) >= cdl[0]);
ASSUME(cw(0,3) >= cds[0]);
ASSUME(cw(0,3) >= cctrl[0]);
ASSUME(cw(0,3) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,3) = 0;
mem(3,cw(0,3)) = 0;
co(3,cw(0,3))+=1;
delta(3,cw(0,3)) = -1;
ASSUME(creturn[0] >= cw(0,3));
// call void @llvm.dbg.value(metadata i64* @atom_1_X2_1, metadata !156, metadata !DIExpression()), !dbg !201
// call void @llvm.dbg.value(metadata i64 0, metadata !158, metadata !DIExpression()), !dbg !201
// store atomic i64 0, i64* @atom_1_X2_1 monotonic, align 8, !dbg !107
// ST: Guess
iw(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,4);
cw(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,4)] == 0);
ASSUME(active[cw(0,4)] == 0);
ASSUME(sforbid(4,cw(0,4))== 0);
ASSUME(iw(0,4) >= 0);
ASSUME(iw(0,4) >= 0);
ASSUME(cw(0,4) >= iw(0,4));
ASSUME(cw(0,4) >= old_cw);
ASSUME(cw(0,4) >= cr(0,4));
ASSUME(cw(0,4) >= cl[0]);
ASSUME(cw(0,4) >= cisb[0]);
ASSUME(cw(0,4) >= cdy[0]);
ASSUME(cw(0,4) >= cdl[0]);
ASSUME(cw(0,4) >= cds[0]);
ASSUME(cw(0,4) >= cctrl[0]);
ASSUME(cw(0,4) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,4) = 0;
mem(4,cw(0,4)) = 0;
co(4,cw(0,4))+=1;
delta(4,cw(0,4)) = -1;
ASSUME(creturn[0] >= cw(0,4));
// call void @llvm.dbg.value(metadata i64* @atom_1_X7_0, metadata !159, metadata !DIExpression()), !dbg !203
// call void @llvm.dbg.value(metadata i64 0, metadata !161, metadata !DIExpression()), !dbg !203
// store atomic i64 0, i64* @atom_1_X7_0 monotonic, align 8, !dbg !109
// ST: Guess
iw(0,5) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STIW
old_cw = cw(0,5);
cw(0,5) = get_rng(0,NCONTEXT-1);// 0 ASSIGN STCOM
// Check
ASSUME(active[iw(0,5)] == 0);
ASSUME(active[cw(0,5)] == 0);
ASSUME(sforbid(5,cw(0,5))== 0);
ASSUME(iw(0,5) >= 0);
ASSUME(iw(0,5) >= 0);
ASSUME(cw(0,5) >= iw(0,5));
ASSUME(cw(0,5) >= old_cw);
ASSUME(cw(0,5) >= cr(0,5));
ASSUME(cw(0,5) >= cl[0]);
ASSUME(cw(0,5) >= cisb[0]);
ASSUME(cw(0,5) >= cdy[0]);
ASSUME(cw(0,5) >= cdl[0]);
ASSUME(cw(0,5) >= cds[0]);
ASSUME(cw(0,5) >= cctrl[0]);
ASSUME(cw(0,5) >= caddr[0]);
// Update
caddr[0] = max(caddr[0],0);
buff(0,5) = 0;
mem(5,cw(0,5)) = 0;
co(5,cw(0,5))+=1;
delta(5,cw(0,5)) = -1;
ASSUME(creturn[0] >= cw(0,5));
// %call = call i32 @pthread_create(i64* noundef %thr0, %union.pthread_attr_t* noundef null, i8* (i8*)* noundef @t0, i8* noundef null) #6, !dbg !110
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,0+2));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,0+2));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cstart[1] >= cdy[0]);
// %call11 = call i32 @pthread_create(i64* noundef %thr1, %union.pthread_attr_t* noundef null, i8* (i8*)* noundef @t1, i8* noundef null) #6, !dbg !111
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,0+2));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,0+2));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cstart[2] >= cdy[0]);
// %2 = load i64, i64* %thr0, align 8, !dbg !112, !tbaa !113
// LD: Guess
old_cr = cr(0,6);
cr(0,6) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,6)] == 0);
ASSUME(cr(0,6) >= iw(0,6));
ASSUME(cr(0,6) >= 0);
ASSUME(cr(0,6) >= cdy[0]);
ASSUME(cr(0,6) >= cisb[0]);
ASSUME(cr(0,6) >= cdl[0]);
ASSUME(cr(0,6) >= cl[0]);
// Update
creg_r9 = cr(0,6);
crmax(0,6) = max(crmax(0,6),cr(0,6));
caddr[0] = max(caddr[0],0);
if(cr(0,6) < cw(0,6)) {
r9 = buff(0,6);
} else {
if(pw(0,6) != co(6,cr(0,6))) {
ASSUME(cr(0,6) >= old_cr);
}
pw(0,6) = co(6,cr(0,6));
r9 = mem(6,cr(0,6));
}
ASSUME(creturn[0] >= cr(0,6));
// %call12 = call i32 @pthread_join(i64 noundef %2, i8** noundef null), !dbg !117
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,0+2));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,0+2));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cdy[0] >= creturn[1]);
// %3 = load i64, i64* %thr1, align 8, !dbg !118, !tbaa !113
// LD: Guess
old_cr = cr(0,7);
cr(0,7) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,7)] == 0);
ASSUME(cr(0,7) >= iw(0,7));
ASSUME(cr(0,7) >= 0);
ASSUME(cr(0,7) >= cdy[0]);
ASSUME(cr(0,7) >= cisb[0]);
ASSUME(cr(0,7) >= cdl[0]);
ASSUME(cr(0,7) >= cl[0]);
// Update
creg_r10 = cr(0,7);
crmax(0,7) = max(crmax(0,7),cr(0,7));
caddr[0] = max(caddr[0],0);
if(cr(0,7) < cw(0,7)) {
r10 = buff(0,7);
} else {
if(pw(0,7) != co(7,cr(0,7))) {
ASSUME(cr(0,7) >= old_cr);
}
pw(0,7) = co(7,cr(0,7));
r10 = mem(7,cr(0,7));
}
ASSUME(creturn[0] >= cr(0,7));
// %call13 = call i32 @pthread_join(i64 noundef %3, i8** noundef null), !dbg !119
// dumbsy: Guess
old_cdy = cdy[0];
cdy[0] = get_rng(0,NCONTEXT-1);
// Check
ASSUME(cdy[0] >= old_cdy);
ASSUME(cdy[0] >= cisb[0]);
ASSUME(cdy[0] >= cdl[0]);
ASSUME(cdy[0] >= cds[0]);
ASSUME(cdy[0] >= cctrl[0]);
ASSUME(cdy[0] >= cw(0,0+0));
ASSUME(cdy[0] >= cw(0,0+1));
ASSUME(cdy[0] >= cw(0,0+2));
ASSUME(cdy[0] >= cw(0,3+0));
ASSUME(cdy[0] >= cw(0,4+0));
ASSUME(cdy[0] >= cw(0,5+0));
ASSUME(cdy[0] >= cw(0,6+0));
ASSUME(cdy[0] >= cw(0,7+0));
ASSUME(cdy[0] >= cr(0,0+0));
ASSUME(cdy[0] >= cr(0,0+1));
ASSUME(cdy[0] >= cr(0,0+2));
ASSUME(cdy[0] >= cr(0,3+0));
ASSUME(cdy[0] >= cr(0,4+0));
ASSUME(cdy[0] >= cr(0,5+0));
ASSUME(cdy[0] >= cr(0,6+0));
ASSUME(cdy[0] >= cr(0,7+0));
ASSUME(creturn[0] >= cdy[0]);
ASSUME(cdy[0] >= creturn[2]);
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0), metadata !163, metadata !DIExpression()), !dbg !215
// %4 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 0) seq_cst, align 8, !dbg !121
// LD: Guess
old_cr = cr(0,0);
cr(0,0) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,0)] == 0);
ASSUME(cr(0,0) >= iw(0,0));
ASSUME(cr(0,0) >= 0);
ASSUME(cr(0,0) >= cdy[0]);
ASSUME(cr(0,0) >= cisb[0]);
ASSUME(cr(0,0) >= cdl[0]);
ASSUME(cr(0,0) >= cl[0]);
// Update
creg_r11 = cr(0,0);
crmax(0,0) = max(crmax(0,0),cr(0,0));
caddr[0] = max(caddr[0],0);
if(cr(0,0) < cw(0,0)) {
r11 = buff(0,0);
} else {
if(pw(0,0) != co(0,cr(0,0))) {
ASSUME(cr(0,0) >= old_cr);
}
pw(0,0) = co(0,cr(0,0));
r11 = mem(0,cr(0,0));
}
ASSUME(creturn[0] >= cr(0,0));
// call void @llvm.dbg.value(metadata i64 %4, metadata !165, metadata !DIExpression()), !dbg !215
// %conv = trunc i64 %4 to i32, !dbg !122
// call void @llvm.dbg.value(metadata i32 %conv, metadata !162, metadata !DIExpression()), !dbg !188
// %cmp = icmp eq i32 %conv, 1, !dbg !123
// %conv14 = zext i1 %cmp to i32, !dbg !123
// call void @llvm.dbg.value(metadata i32 %conv14, metadata !166, metadata !DIExpression()), !dbg !188
// call void @llvm.dbg.value(metadata i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1), metadata !168, metadata !DIExpression()), !dbg !219
// %5 = load atomic i64, i64* getelementptr inbounds ([3 x i64], [3 x i64]* @vars, i64 0, i64 1) seq_cst, align 8, !dbg !125
// LD: Guess
old_cr = cr(0,0+1*1);
cr(0,0+1*1) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,0+1*1)] == 0);
ASSUME(cr(0,0+1*1) >= iw(0,0+1*1));
ASSUME(cr(0,0+1*1) >= 0);
ASSUME(cr(0,0+1*1) >= cdy[0]);
ASSUME(cr(0,0+1*1) >= cisb[0]);
ASSUME(cr(0,0+1*1) >= cdl[0]);
ASSUME(cr(0,0+1*1) >= cl[0]);
// Update
creg_r12 = cr(0,0+1*1);
crmax(0,0+1*1) = max(crmax(0,0+1*1),cr(0,0+1*1));
caddr[0] = max(caddr[0],0);
if(cr(0,0+1*1) < cw(0,0+1*1)) {
r12 = buff(0,0+1*1);
} else {
if(pw(0,0+1*1) != co(0+1*1,cr(0,0+1*1))) {
ASSUME(cr(0,0+1*1) >= old_cr);
}
pw(0,0+1*1) = co(0+1*1,cr(0,0+1*1));
r12 = mem(0+1*1,cr(0,0+1*1));
}
ASSUME(creturn[0] >= cr(0,0+1*1));
// call void @llvm.dbg.value(metadata i64 %5, metadata !170, metadata !DIExpression()), !dbg !219
// %conv18 = trunc i64 %5 to i32, !dbg !126
// call void @llvm.dbg.value(metadata i32 %conv18, metadata !167, metadata !DIExpression()), !dbg !188
// %cmp19 = icmp eq i32 %conv18, 1, !dbg !127
// %conv20 = zext i1 %cmp19 to i32, !dbg !127
// call void @llvm.dbg.value(metadata i32 %conv20, metadata !171, metadata !DIExpression()), !dbg !188
// call void @llvm.dbg.value(metadata i64* @atom_0_X2_0, metadata !173, metadata !DIExpression()), !dbg !223
// %6 = load atomic i64, i64* @atom_0_X2_0 seq_cst, align 8, !dbg !129
// LD: Guess
old_cr = cr(0,3);
cr(0,3) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,3)] == 0);
ASSUME(cr(0,3) >= iw(0,3));
ASSUME(cr(0,3) >= 0);
ASSUME(cr(0,3) >= cdy[0]);
ASSUME(cr(0,3) >= cisb[0]);
ASSUME(cr(0,3) >= cdl[0]);
ASSUME(cr(0,3) >= cl[0]);
// Update
creg_r13 = cr(0,3);
crmax(0,3) = max(crmax(0,3),cr(0,3));
caddr[0] = max(caddr[0],0);
if(cr(0,3) < cw(0,3)) {
r13 = buff(0,3);
} else {
if(pw(0,3) != co(3,cr(0,3))) {
ASSUME(cr(0,3) >= old_cr);
}
pw(0,3) = co(3,cr(0,3));
r13 = mem(3,cr(0,3));
}
ASSUME(creturn[0] >= cr(0,3));
// call void @llvm.dbg.value(metadata i64 %6, metadata !175, metadata !DIExpression()), !dbg !223
// %conv24 = trunc i64 %6 to i32, !dbg !130
// call void @llvm.dbg.value(metadata i32 %conv24, metadata !172, metadata !DIExpression()), !dbg !188
// call void @llvm.dbg.value(metadata i64* @atom_1_X2_1, metadata !177, metadata !DIExpression()), !dbg !226
// %7 = load atomic i64, i64* @atom_1_X2_1 seq_cst, align 8, !dbg !132
// LD: Guess
old_cr = cr(0,4);
cr(0,4) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,4)] == 0);
ASSUME(cr(0,4) >= iw(0,4));
ASSUME(cr(0,4) >= 0);
ASSUME(cr(0,4) >= cdy[0]);
ASSUME(cr(0,4) >= cisb[0]);
ASSUME(cr(0,4) >= cdl[0]);
ASSUME(cr(0,4) >= cl[0]);
// Update
creg_r14 = cr(0,4);
crmax(0,4) = max(crmax(0,4),cr(0,4));
caddr[0] = max(caddr[0],0);
if(cr(0,4) < cw(0,4)) {
r14 = buff(0,4);
} else {
if(pw(0,4) != co(4,cr(0,4))) {
ASSUME(cr(0,4) >= old_cr);
}
pw(0,4) = co(4,cr(0,4));
r14 = mem(4,cr(0,4));
}
ASSUME(creturn[0] >= cr(0,4));
// call void @llvm.dbg.value(metadata i64 %7, metadata !179, metadata !DIExpression()), !dbg !226
// %conv28 = trunc i64 %7 to i32, !dbg !133
// call void @llvm.dbg.value(metadata i32 %conv28, metadata !176, metadata !DIExpression()), !dbg !188
// call void @llvm.dbg.value(metadata i64* @atom_1_X7_0, metadata !181, metadata !DIExpression()), !dbg !229
// %8 = load atomic i64, i64* @atom_1_X7_0 seq_cst, align 8, !dbg !135
// LD: Guess
old_cr = cr(0,5);
cr(0,5) = get_rng(0,NCONTEXT-1);// 0 ASSIGN LDCOM
// Check
ASSUME(active[cr(0,5)] == 0);
ASSUME(cr(0,5) >= iw(0,5));
ASSUME(cr(0,5) >= 0);
ASSUME(cr(0,5) >= cdy[0]);
ASSUME(cr(0,5) >= cisb[0]);
ASSUME(cr(0,5) >= cdl[0]);
ASSUME(cr(0,5) >= cl[0]);
// Update
creg_r15 = cr(0,5);
crmax(0,5) = max(crmax(0,5),cr(0,5));
caddr[0] = max(caddr[0],0);
if(cr(0,5) < cw(0,5)) {
r15 = buff(0,5);
} else {
if(pw(0,5) != co(5,cr(0,5))) {
ASSUME(cr(0,5) >= old_cr);
}
pw(0,5) = co(5,cr(0,5));
r15 = mem(5,cr(0,5));
}
ASSUME(creturn[0] >= cr(0,5));
// call void @llvm.dbg.value(metadata i64 %8, metadata !183, metadata !DIExpression()), !dbg !229
// %conv32 = trunc i64 %8 to i32, !dbg !136
// call void @llvm.dbg.value(metadata i32 %conv32, metadata !180, metadata !DIExpression()), !dbg !188
// %and = and i32 %conv28, %conv32, !dbg !137
creg_r16 = max(creg_r14,creg_r15);
ASSUME(active[creg_r16] == 0);
r16 = r14 & r15;
// call void @llvm.dbg.value(metadata i32 %and, metadata !184, metadata !DIExpression()), !dbg !188
// %and33 = and i32 %conv24, %and, !dbg !138
creg_r17 = max(creg_r13,creg_r16);
ASSUME(active[creg_r17] == 0);
r17 = r13 & r16;
// call void @llvm.dbg.value(metadata i32 %and33, metadata !185, metadata !DIExpression()), !dbg !188
// %and34 = and i32 %conv20, %and33, !dbg !139
creg_r18 = max(max(creg_r12,0),creg_r17);
ASSUME(active[creg_r18] == 0);
r18 = (r12==1) & r17;
// call void @llvm.dbg.value(metadata i32 %and34, metadata !186, metadata !DIExpression()), !dbg !188
// %and35 = and i32 %conv14, %and34, !dbg !140
creg_r19 = max(max(creg_r11,0),creg_r18);
ASSUME(active[creg_r19] == 0);
r19 = (r11==1) & r18;
// call void @llvm.dbg.value(metadata i32 %and35, metadata !187, metadata !DIExpression()), !dbg !188
// %cmp36 = icmp eq i32 %and35, 1, !dbg !141
// br i1 %cmp36, label %if.then, label %if.end, !dbg !143
old_cctrl = cctrl[0];
cctrl[0] = get_rng(0,NCONTEXT-1);
ASSUME(cctrl[0] >= old_cctrl);
ASSUME(cctrl[0] >= creg_r19);
ASSUME(cctrl[0] >= 0);
if((r19==1)) {
goto T0BLOCK1;
} else {
goto T0BLOCK2;
}
T0BLOCK1:
// call void @__assert_fail(i8* noundef getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i8* noundef getelementptr inbounds ([115 x i8], [115 x i8]* @.str.1, i64 0, i64 0), i32 noundef 75, i8* noundef getelementptr inbounds ([23 x i8], [23 x i8]* @__PRETTY_FUNCTION__.main, i64 0, i64 0)) #7, !dbg !144
// unreachable, !dbg !144
r20 = 1;
T0BLOCK2:
// %9 = bitcast i64* %thr1 to i8*, !dbg !147
// call void @llvm.lifetime.end.p0i8(i64 8, i8* %9) #6, !dbg !147
// %10 = bitcast i64* %thr0 to i8*, !dbg !147
// call void @llvm.lifetime.end.p0i8(i64 8, i8* %10) #6, !dbg !147
// ret i32 0, !dbg !148
ret_thread_0 = 0;
ASSERT(r20== 0);
}
| [
"tuan-phong.ngo@it.uu.se"
] | tuan-phong.ngo@it.uu.se |
da84d520608247bfe631bd1013fe1b632392468b | 69957429158cc2baff2b718b8d0e54c4dd4661b8 | /chap08/strcpy_test.cpp | 3db8dd1acda7f79248cb071329f16316efaa6977 | [] | no_license | chc1129/MeikaiCpp | d7bbbab37a7f7ab7de5d467d097ef2dd8b5ad5f4 | 4140133fbb87f9644ce62aa1b2ef470b16afca72 | refs/heads/main | 2023-04-12T13:39:55.451715 | 2021-05-02T02:12:13 | 2021-05-02T02:12:13 | 357,937,061 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 867 | cpp | // strcpy関数とstrncpy関数の利用例
#include <cstring>
#include <iostream>
using namespace std;
int main(void)
{
char tmp[16];
char s1[16], s2[16], s3[16];
cout << "文字列を入力してください：";
cin >> tmp;
strcpy(s1, strcpy(s2, tmp)); // s2にコピーした文字列をs1にもコピー
cout << "文字列s1は\"" << s1 << "\"です。\n";
cout << "文字列s2は\"" << s2 << "\"です。\n";
cout << "文字列s3は\"" << strcpy(s3, tmp) << "\"です。\n";
char* x = "XXXXXXXXX"; // 9個の'X'とナル文字 */
strcpy(s3, x); strncpy(s3, "12345", 3); cout << "s3 = " << s3 << '\n';
strcpy(s3, x); strncpy(s3, "12345", 5); cout << "s3 = " << s3 << '\n';
strcpy(s3, x); strncpy(s3, "12345", 7); cout << "s3 = " << s3 << '\n';
strcpy(s3, x); strncpy(s3, "1234567890", 9); cout << "s3 = " << s3 << '\n';
}
| [
"chc1129@gmail.com"
] | chc1129@gmail.com |
0ea2f9a2cb161a0e89d894263010bea39cab36e6 | 40f73a14d163a8cc33dfde92f1109743d9ecdbe2 | /nandincpp/Power of Four.cpp | f9ee191df6fcb1c55aff561113d98634de1bc7fc | [] | no_license | pravirtual/Leetcode | dc83d09f6fc15f24e05e8fca7546e2f003f45c37 | 7f754f38e507b7f4aaeb267b05873437b1ca5bcf | refs/heads/master | 2023-08-28T07:52:59.019305 | 2021-10-29T14:21:01 | 2021-10-29T14:21:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 222 | cpp | class Solution {
public:
bool isPowerOfFour(int n)
{
if(n == 0)
return 0;
if( ceil(log(n) / log(4)) == floor(log(n) / log(4)))
return 1;
return 0;
}
}; | [
"noreply@github.com"
] | pravirtual.noreply@github.com |
b1909dd846b343e016a2ca6131dd1ee239e4ffc4 | 4d7d429b43f2a30ca7a5657a31ba6bbd8a8608c8 | /Chapter01/Person/Person.cpp | bceee6646f50142d109d9eb77c8db59b6a6af123 | [] | no_license | robintux/Book-Cpp17ByExample | d4bed3ba4b9c9cba456b5cdf021a24243fea3a89 | 671981433192af4cad7367cccd9d56478b993644 | refs/heads/master | 2021-09-23T21:13:23.646204 | 2018-09-27T19:47:34 | 2018-09-27T19:47:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 263 | cpp | //
// Created by Yves Gingras on 18-04-17.
//
#include <String>
#include <iostream>
using namespace std;
#include "Person.h"
Person::Person(string name)
: m_name(name){
/*empty*/
}
void Person::Print() {
cout << "Person " << m_name << endl;
} | [
"yves.gingras@icloud.com"
] | yves.gingras@icloud.com |
758638536c1156b14ee351fa20ecdbb696842e4e | d99f92302c2931313fb6b55333848b66b570a19b | /rocksdb-handle.cpp | ad0b48c0be11bebe49f62278ad15c4605db533a2 | [] | no_license | maierlars/prototype | eff75426bafe149f4dedf321cf0650a44a11a07b | b177bd578cd3644cb41e5af4d813ed71c472774f | refs/heads/main | 2023-02-23T22:21:39.948023 | 2021-02-05T07:38:08 | 2021-02-05T07:38:08 | 314,536,246 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 994 | cpp | #include "rocksdb-handle.h"
std::shared_ptr<RocksDBHandle> OpenRocksDB(std::string const& dbname) {
rocksdb::DB* ptr;
rocksdb::DBOptions opts;
opts.create_if_missing = true;
opts.create_missing_column_families = true;
rocksdb::ColumnFamilyOptions defaultFamily;
rocksdb::ColumnFamilyOptions logFamily;
std::vector<rocksdb::ColumnFamilyDescriptor> families;
families.emplace_back(rocksdb::kDefaultColumnFamilyName, defaultFamily);
families.emplace_back("logs", logFamily);
std::vector<rocksdb::ColumnFamilyHandle*> handles;
auto status = rocksdb::DB::Open(opts, dbname, families, &handles, &ptr);
if (!status.ok()) {
throw std::runtime_error(status.ToString());
}
std::unique_ptr<rocksdb::DB> db_ptr{ptr};
std::unique_ptr<rocksdb::ColumnFamilyHandle> defs_ptr{handles[0]};
std::unique_ptr<rocksdb::ColumnFamilyHandle> logs_ptr{handles[1]};
return std::make_shared<RocksDBHandle>(std::move(db_ptr), std::move(defs_ptr),
std::move(logs_ptr));
}
| [
"lars@arangodb.com"
] | lars@arangodb.com |
18a1fcee2d4f0b3cbcf25a4a824008e33ebea821 | 3ccc204741b0d1b738644dd836fa6dc1d986f6ab | /src/lib/include/configuration.h | 2ea55096eb5575dd4cc6f1e5bba609c21505281b | [] | no_license | vkaytsanov/MinecraftCPP | 69cc5a67b48ce7453de6cb1e9f040e65dbdcbc99 | 770f2146fefd96910cee6f1e93ebd266e21d23f6 | refs/heads/master | 2023-03-26T05:13:29.700581 | 2021-03-23T18:16:44 | 2021-03-23T18:16:44 | 338,855,733 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 485 | h | #ifndef CONFIGURATION
#define CONFIGURATION
#include "SDL.h"
/* Class for application configuration */
class Configuration {
public:
const char* title = nullptr;
int x = SDL_WINDOWPOS_CENTERED;
int y = SDL_WINDOWPOS_CENTERED;
int width = 640;
int height = 480;
SDL_WindowFlags isVisible = SDL_WINDOW_SHOWN;
Configuration();
explicit Configuration(const char* title);
Configuration(const char* title, int width, int height);
Configuration(int width, int height);
};
#endif | [
"vkaytsanov@yahoo.com"
] | vkaytsanov@yahoo.com |
4784a4a7cecf1a4dbde1dd5b44ff723a71e2af96 | cd75abf2d9eff465918b1bb4e9b774cb745158b3 | /dllmain.cpp | 380ed506930c2d1e7e3de4957ccc1cfa769a0b36 | [
"MIT"
] | permissive | CookiePLMonster/TriangleRadar | e276382c9f2f947193c46238799601b67bff0a88 | 669f187bae25a861a90c5d26538aa3a81819bcff | refs/heads/master | 2021-01-18T20:06:17.408679 | 2017-04-01T19:35:10 | 2017-04-01T19:35:10 | 86,937,858 | 6 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,375 | cpp | #define WIN32_LEAN_AND_MEAN
#define NOMINMAX
#include <windows.h>
#include "MemoryMgr.h"
#include "Maths.h"
static void (*const TransformRadarPointToScreenSpace)(CVector2D&,const CVector2D&) = (void(*)(CVector2D&,const CVector2D&))0x583480;
static constexpr float sign (const CVector2D& p1, const CVector2D& p2, const CVector2D& p3)
{
return (p1.x - p3.x) * (p2.y - p3.y) - (p2.x - p3.x) * (p1.y - p3.y);
}
static constexpr float clamp( float v, float lo, float hi )
{
return v < lo ? lo : hi < v ? hi : v;
}
double TriangleRadar(CVector2D& pos)
{
const double dResult = sqrt(pos.x * pos.x + pos.y * pos.y);
constexpr CVector2D pointA( 0.0, 1.0 );
constexpr CVector2D pointB( 1.0, -1.0 );
constexpr CVector2D pointC( -1.0, -1.0 );
const bool bA = sign(pos, pointA, pointB) < 0.0f;
const bool bB = sign(pos, pointB, pointC) < 0.0f;
const bool bC = sign(pos, pointC, pointA) < 0.0f;
if ( bA && bB && bC )
{
// Point is inside the triangle, don't calculate anything
return dResult;
}
if ( !bA )
{
constexpr float m = (pointB.y - pointA.y) / (pointB.x - pointA.x);
constexpr float b = pointA.y - (m * pointA.x);
const float newX = (m * pos.y + pos.x - m * b) / (m * m + 1);
const float newY = (m * m * pos.y + m * pos.x + b) / (m * m + 1);
pos.x = clamp( newX, pointA.x, pointB.x );
pos.y = clamp( newY, pointB.y, pointA.y );
}
else if ( !bC )
{
constexpr float m = (pointA.y - pointC.y) / (pointA.x - pointC.x);
constexpr float b = pointC.y - (m * pointC.x);
const float newX = (m * pos.y + pos.x - m * b) / (m * m + 1);
const float newY = (m * m * pos.y + m * pos.x + b) / (m * m + 1);
pos.x = clamp( newX, pointC.x, pointA.x );
pos.y = clamp( newY, pointC.y, pointA.y );
}
else if ( !bB )
{
constexpr float m = (pointC.y - pointB.y) / (pointC.x - pointB.x);
constexpr float b = pointB.y - (m * pointB.x);
const float newX = (m * pos.y + pos.x - m * b) / (m * m + 1);
pos.x = clamp( newX, pointC.x, pointB.x );
pos.y = pointC.y;
}
return dResult;
}
static void* const TriangleRadarMask_JumpBack = (void*)0x585888;
void __declspec(naked) TriangleRadarMask()
{
static const float fPositions[] = { 0.0, 1.0, 0.0, 1.0, 1.0, -1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0 };
_asm
{
lea eax, [ebx*8+fPositions-8]
lea ecx, [esp+38h]
push eax
push ecx
call TransformRadarPointToScreenSpace
lea eax, [ebx*8+fPositions+8]
lea ecx, [esp+48h]
push eax
push ecx
call TransformRadarPointToScreenSpace
lea eax, [ebx*8+fPositions+18h]
lea ecx, [esp+58h]
push eax
push ecx
call TransformRadarPointToScreenSpace
add esp, 18h
jmp TriangleRadarMask_JumpBack
}
}
BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID lpReserved)
{
if ( reason == DLL_PROCESS_ATTACH)
{
if (*(uint32_t*)DynBaseAddress(0x82457C) == 0x94BF || *(uint32_t*)DynBaseAddress(0x8245BC) == 0x94BF)
{
ScopedUnprotect::Section Protect( GetModuleHandle( nullptr ), ".text" );
using namespace Memory;
// Triangle radar
InjectHook(0x583313, &TriangleRadar, PATCH_JUMP);
// Texture mask
InjectHook(0x585850, &TriangleRadarMask, PATCH_JUMP);
Patch<uint32_t>(0x58581A + 1, 2);
Patch<uint8_t>(0x585894 + 1, 3); // Num of vertices
Patch<uint8_t>(0x58589B + 1, 3);
// No radardisc
InjectHook(0x58A782, 0x58AA2A, PATCH_JUMP );
}
else return FALSE;
}
return TRUE;
} | [
"zdanio95@gmail.com"
] | zdanio95@gmail.com |
0dfe42776a95b533e1505ae69c70b766437e7a9f | 8b100d2e1280d1c4ad02817f0d60645377199c1f | /Ejercicios/Ejercicio08-FacturaConDescuento/main.cpp | f7c5765971284caf798dffdb4346c04a078651b7 | [
"MIT"
] | permissive | AngelaC02/cpp | 350ed3a9ea07958d823d5a9fb8e2a994261c12c9 | 89464b01bc79b91e2229340481e5f9db0621d00c | refs/heads/master | 2022-12-26T23:29:11.139917 | 2020-09-23T02:27:01 | 2020-09-23T02:27:01 | 276,510,778 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 691 | cpp | #include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
//Datos
double subtotal = 0;
double total = 0;
double impuesto = 0.15;
int descuento = 0;
double calculoDescuento = 0;
double calculoImpuesto = 0;
cout << "Ingrese el subtotal de la factura: ";
cin >> subtotal;
cout<< "Ingrese el descuento (0,10,15,20): ";
cin >> descuento;
//Proceso
calculoDescuento = (subtotal + descuento) / 100;
calculoImpuesto = (subtotal - calculoDescuento) * 0.15;
total = subtotal - calculoDescuento + calculoImpuesto;
//Salida
cout << endl;
cout << "Total a pagar es: " << total ;
return 0;
}
| [
"accastros@unah.hn"
] | accastros@unah.hn |
9a6782b1e43ba093906ecce07d0b90f58936db33 | 9a3b9d80afd88e1fa9a24303877d6e130ce22702 | /src/Providers/UNIXProviders/VideoBIOSFeature/UNIX_VideoBIOSFeature_SOLARIS.hxx | 9dc59c546d13b542d60efcbcd7332f699a12641d | [
"MIT"
] | permissive | brunolauze/openpegasus-providers | 3244b76d075bc66a77e4ed135893437a66dd769f | f24c56acab2c4c210a8d165bb499cd1b3a12f222 | refs/heads/master | 2020-04-17T04:27:14.970917 | 2015-01-04T22:08:09 | 2015-01-04T22:08:09 | 19,707,296 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,819 | hxx | //%LICENSE////////////////////////////////////////////////////////////////
//
// Licensed to The Open Group (TOG) under one or more contributor license
// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with
// this work for additional information regarding copyright ownership.
// Each contributor licenses this file to you under the OpenPegasus Open
// Source License; you may not use this file except in compliance with the
// License.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//////////////////////////////////////////////////////////////////////////
//
//%/////////////////////////////////////////////////////////////////////////
#ifdef PEGASUS_OS_SOLARIS
#ifndef __UNIX_VIDEOBIOSFEATURE_PRIVATE_H
#define __UNIX_VIDEOBIOSFEATURE_PRIVATE_H
#endif
#endif
| [
"brunolauze@msn.com"
] | brunolauze@msn.com |
78a90327400242e90730dd0df24a6e64076496ac | bfbe07f8edd3b5b3c1ac2393b8508ced3845219d | /GetGood/CSES/Graph Algorithms/Labyrinth.cpp | 5b70d72e7afa9b9f52eac526e5344473a1494a12 | [] | no_license | srinjoyray/Competitive | 5ee384b446a20aad2cdcea8e08304101a9a92b34 | d6680510462a915756c4835374d2d6a342960f5f | refs/heads/main | 2023-06-16T16:08:10.787883 | 2021-07-14T14:19:17 | 2021-07-14T14:19:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,514 | cpp | #include <bits/stdc++.h>
using namespace std;
//----------------------------------- DEBUG -----------------------------------
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it)
*this << ", " + 2 * (it == d.b) << *it;
ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
// debug & operator << (debug & dd, P p) { dd << "(" << p.x << ", " << p.y << ")"; return dd; }
//----------------------------------- END DEBUG --------------------------------
char a[1001][1001];
int vis[1001][1001];
int ans;
int n,m;
pair<int,int> finish;
vector<char> path;
vector<char> shortest;
int length = 1e9;
void minify() {
if()
}
void dfs(int x, int y) {
vis[x][y] = 1;
debug() << imie(x) imie(y);
if(finish == make_pair(x,y)) {
minify();
return;
}
if(a[x][y] == '#') {
return;
}
if(x + 1 <= n and vis[x + 1][y] == 0) {
path.push_back('D');
dfs(x + 1, y);
path.pop_back();
}
if(y + 1 <= m and vis[x][y + 1] == 0) {
path.push_back('R');
dfs(x, y + 1);
path.pop_back();
}
if(x - 1 >= 1 and vis[x - 1][y] == 0) {
path.push_back('U');
dfs(x - 1, y);
path.pop_back();
}
if(y - 1 >= 1 and vis[x][y - 1] == 0) {
path.push_back('L');
dfs(x, y - 1);
path.pop_back();
}
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
cin >> n >> m;
for(int i=1;i<=n;i++) {
for(int j=1;j<=m;j++) {
cin >> a[i][j];
}
}
pair<int,int> start;
for(int i=1;i<=n;i++) {
for(int j=1;j<=m;j++) {
if(a[i][j] == 'A') {
start = {i, j};
}
if(a[i][j] == 'B') {
finish = {i, j};
}
}
}
dfs(start.first, start.second);
cout << "NO";
} | [
"ankurkayal1234@gmail.com"
] | ankurkayal1234@gmail.com |
d2a628ff2c72fa668b70cf2f33276eb09639b41a | 80fa15e43d6020110ac7729de4303bf3d1c3b78f | /RC CAR/MoveinaSquare/MoveinaSquare.ino | 5026706481ff8e1e9eba0755738a744dc9eb0e94 | [] | no_license | tmau/SCUSolarCar | a9acc13ab8c1ae55ff2693980e234779c2b555d1 | f12cfe636f238c947b5c5014f59e915769d86466 | refs/heads/master | 2021-03-19T11:00:57.635513 | 2017-09-22T21:51:49 | 2017-09-22T21:51:49 | 96,818,606 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,549 | ino | // connect motor controller pins to Arduino digital pins
// motor one
int enA = 10;
int in1 = 9;
int in2 = 8;
//motor two
int in3 = 7;
int in4 = 6;
int enB = 5;
int Speed = 200;
int SpeedB = 255; //Go the maximum ammount you can turn
void Forward();
void Reverse();
void Left();
void Right();
void Brake();
void setup()
{
// set all the motor control pins to outputs
pinMode(enA, OUTPUT);
pinMode(in1, OUTPUT);
pinMode(in2, OUTPUT);
pinMode(enB, OUTPUT);
pinMode(in3, OUTPUT);
pinMode(in4, OUTPUT);
}
void loop()
{
//Part 1
Forward();
delay(5000);
Brake();
delay(2000);
Left();
Forward();
delay(1750);
Brake();
delay(2000);
//Part 2
Forward();
delay(3000);
Brake();
delay(2000);
Left();
Forward();
delay(1750);
Brake();
delay(2000);
// //Part 3
// Forward();
// delay(4000);
//
// Brake();
// delay(2000);
//
// Left();
// delay(1000);
//
// Brake();
// delay(2000);
}
void Left(){
analogWrite(enB, SpeedB);
digitalWrite(in3, LOW);
digitalWrite(in4, HIGH);
}
void Right(){
analogWrite(enB, SpeedB);
digitalWrite(in4, LOW);
digitalWrite(in3, HIGH);
}
void Backward()
{
analogWrite(enA, Speed);
digitalWrite(in1, LOW);
digitalWrite(in2, HIGH);
}
void Forward()
{
analogWrite(enA, Speed);
digitalWrite(in1, HIGH);
digitalWrite(in2, LOW);
}
void Brake()
{
digitalWrite(in1, LOW);
digitalWrite(in2, LOW);
digitalWrite(in3, LOW);
digitalWrite(in4, LOW);
analogWrite(enA, Speed);
analogWrite(enB, Speed);
}
| [
"tmau@scu.edu"
] | tmau@scu.edu |
687acf83bbcfde348976e1eff29c380a538cc6be | bab05e214171b7c12c267e6424f58b263adfffb4 | /1_semestr/4/lines/writeBin.cpp | 4af9185dee8f22d73aa5ff7aacb4f95b53129a43 | [] | no_license | RudenkoDmitriy/MyHomeWorking | 62ba1cd3a0d07c0e92af72eaab20dcc261335df3 | 6f9e5ac04143d87f722363d5e0025b3e42cdea11 | refs/heads/master | 2020-06-05T19:24:22.515039 | 2015-08-20T17:17:07 | 2015-08-20T17:17:07 | 16,886,713 | 0 | 0 | null | null | null | null | WINDOWS-1251 | C++ | false | false | 330 | cpp | #include "writeBin.h"
#include <iostream>
//Выводит на экран представление числа в двоичном виде.
//На вход подается булевый массив.
void myWork::writeBin(bool binary[])
{
for (int i = 0; i < sizeof(short int) * 8; i++)
{
std::cout << binary[i];
}
} | [
"d.rudenko95@mail.ru"
] | d.rudenko95@mail.ru |
a91024410b8d8d106dfc42b389b44a3ef7f32d9d | f7ee3ef1790a17f3b9dc5d8f6a18a78ce6cca1bf | /Vector4.cpp | bd004e16f37c8c0f3405c4615ad19ca9a2700889 | [] | no_license | JFHwang/CSE167 | 31bad0b95a689877fdbdf5e3c915b513d29d93a5 | 88615c91d1abed951db39eb663b0bc95feda7732 | refs/heads/master | 2018-01-08T04:05:52.709365 | 2015-12-04T23:25:26 | 2015-12-04T23:25:26 | 44,151,658 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,613 | cpp | #include "Vector4.h"
#include "Vector3.h"
#include <math.h>
#include <iostream>
#include <cstring>
Vector4::Vector4()
{
std::memset(m, 0, sizeof(m));
}
Vector4::Vector4(float m0, float m1, float m2)
{
m[0] = m0;
m[1] = m1;
m[2] = m2;
m[3] = 1;
}
Vector4::Vector4(float m0, float m1, float m2, float m3)
{
m[0] = m0;
m[1] = m1;
m[2] = m2;
m[3] = m3;
}
float* Vector4::ptr()
{
return &m[0];
}
void Vector4::set(float x, float y, float z, float w)
{
m[0] = x;
m[1] = y;
m[2] = z;
m[3] = w;
}
void Vector4::set(int index, float value) {
m[index] = value;
}
float& Vector4::operator [] (int loc)
{
return m[loc];
}
Vector4 Vector4::add(Vector4& a)
{
Vector4 b;
//
b.set(m[0] + a[0], m[1] + a[1], m[2] + a[2], m[3] + a[3]);
return b;
}
Vector4 Vector4::operator + (Vector4 a)
{
return add(a);
}
Vector4 Vector4::subtract(Vector4& a)
{
Vector4 b;
//
b.set(m[0] - a[0], m[1] - a[1], m[2] - a[2], m[3] - a[3]);
return b;
}
Vector4 Vector4::operator - (Vector4 a)
{
return subtract(a);
}
Vector4 Vector4::dehomogenize()
{
Vector4 b;
//
b.set(m[0] / m[3], m[1] / m[3], m[2] / m[3], 1);
return b;
}
Vector3 Vector4::toVector3()
{
Vector3 b(m[0], m[1], m[2]);
return b;
}
float Vector4::dot(Vector4 a)
{
return (m[0] * a.m[0]) + (m[1] * a.m[1]) + (m[2] * a.m[2]) + (m[3] * a.m[3]);
}
void Vector4::print(std::string comment)
{
std::cout << comment << std::endl;
std::cout << "<x:" << m[0] << ", y:" << m[1] << ", z:" << m[2] << ", w:" << m[3] << ">" << std::endl;
} | [
"jfhwang@ucsd.edu"
] | jfhwang@ucsd.edu |
ce50a4e478438fc8b895cab2b0afd355e4803816 | 89003acbd6282829cdcfb27f7473a33bdf240570 | /src/radar_pi.h | 1831e6b8f7c76f2cb1c74fac56ab0398fc8cdee0 | [] | no_license | biiont/radar_pi | cc87191eef80e88204ff13f90ff05aa9bb62872e | 7764d7af1b9745cca7c038ae92c7f67428ee0a5c | refs/heads/master | 2021-01-16T20:48:05.028151 | 2011-11-06T06:56:44 | 2011-11-06T06:56:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,148 | h | /******************************************************************************
* $Id: $
*
* Project: OpenCPN
* Purpose: Radar Plugin
* Author: Johan van der Sman
*
***************************************************************************
* Copyright (C) 2011 by Johan van der Sman *
* hannes@andcrew.nl *
* *
* 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. *
***************************************************************************
*/
#ifndef _RADARPI_H_
#define _RADARPI_H_
#include "wx/wxprec.h"
#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif //precompiled headers
#define PLUGIN_VERSION_MAJOR 0
#define PLUGIN_VERSION_MINOR 91
#define MY_API_VERSION_MAJOR 1
#define MY_API_VERSION_MINOR 5
#include "../../../include/ocpn_plugin.h"
#include "radar.h"
//----------------------------------------------------------------------------------------------------------
// The PlugIn Class Definition
//----------------------------------------------------------------------------------------------------------
#define RADAR_TOOL_POSITION -1 // Request default positioning of toolbar tool
class radar_pi : public opencpn_plugin
{
public:
radar_pi(void *ppimgr);
~radar_pi();
// The required PlugIn Methods
int Init(void);
bool DeInit(void);
int GetAPIVersionMajor();
int GetAPIVersionMinor();
int GetPlugInVersionMajor();
int GetPlugInVersionMinor();
wxBitmap *GetPlugInBitmap();
wxString GetCommonName();
wxString GetShortDescription();
wxString GetLongDescription();
void SetDefaults(void);
int GetToolbarToolCount(void);
void ShowPreferencesDialog( wxWindow* parent );
void OnToolbarToolCallback(int id);
void SetAISSentence(wxString &sentence);
void SetPositionFix(PlugIn_Position_Fix &pfix);
void SetColorScheme(PI_ColorScheme cs);
// Other public methods
void SetRadarFrameX (int x) { m_radar_frame_x = x; }
void SetRadarFrameY (int x) { m_radar_frame_y = x; }
void SetRadarFrameSizeX(int x) { m_radar_frame_sx = x; }
void SetRadarFrameSizeY(int x) { m_radar_frame_sy = x; }
void SetRadarNorthUp (bool x) { m_radar_north_up = x; }
void SetRadarRange (int x) { m_radar_range = x; }
bool GetRadarNorthUp (void) { return m_radar_north_up;}
int GetRadarRange (void) { return m_radar_range; }
double GetCog (void) { return m_cog; }
double GetSog (void) { return m_sog; }
int GetSats (void) { return m_sats; }
wxFileConfig *GetConfig (void) { return m_pconfig; }
ArrayOfPlugIn_AIS_Targets *GetAisTargets();
void OnRadarFrameClose();
bool ShowMoored (void);
double GetMooredSpeed (void);
bool ShowCogArrows (void);
int GetCogArrowMinutes(void);
private:
bool LoadConfig(void);
bool SaveConfig(void);
private:
wxFileConfig *m_pconfig;
wxWindow *m_parent_window;
RadarFrame *m_pRadarFrame;
ArrayOfPlugIn_AIS_Targets *AisTargets;
PI_ColorScheme m_cs;
int m_display_width, m_display_height;
int m_leftclick_tool_id;
int m_radar_frame_x, m_radar_frame_y;
int m_radar_frame_sx, m_radar_frame_sy;
int m_radar_range;
double m_lat;
double m_lon;
double m_cog;
double m_sog;
int m_sats;
bool m_radar_show_icon;
bool m_radar_use_ais;
bool m_radar_north_up;
wxCheckBox *m_pRadarShowIcon;
wxCheckBox *m_pRadarUseAis;
};
#endif
| [
"hannes@andcrew.nl"
] | hannes@andcrew.nl |
ac3416c98203842356d54a3860bb01d7bcd2ae79 | 88ae8695987ada722184307301e221e1ba3cc2fa | /chrome/browser/ssl/sct_reporting_service_browsertest.cc | 439f088902d3eefbd28cba981aab332ca8ff1570 | [
"BSD-3-Clause"
] | permissive | iridium-browser/iridium-browser | 71d9c5ff76e014e6900b825f67389ab0ccd01329 | 5ee297f53dc7f8e70183031cff62f37b0f19d25f | refs/heads/master | 2023-08-03T16:44:16.844552 | 2023-07-20T15:17:00 | 2023-07-23T16:09:30 | 220,016,632 | 341 | 40 | BSD-3-Clause | 2021-08-13T13:54:45 | 2019-11-06T14:32:31 | null | UTF-8 | C++ | false | false | 47,380 | cc | // Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <memory>
#include <tuple>
#include "base/base64.h"
#include "base/files/file_path_watcher.h"
#include "base/files/file_util.h"
#include "base/functional/callback.h"
#include "base/json/json_writer.h"
#include "base/memory/scoped_refptr.h"
#include "base/synchronization/lock.h"
#include "base/test/bind.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/time/time.h"
#include "base/time/time_to_iso8601.h"
#include "base/values.h"
#include "build/build_config.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/net/system_network_context_manager.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/ssl/cert_verifier_browser_test.h"
#include "chrome/browser/ssl/sct_reporting_service.h"
#include "chrome/browser/ssl/sct_reporting_service_factory.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/common/chrome_features.h"
#include "chrome/common/pref_names.h"
#include "chrome/test/base/ui_test_utils.h"
#include "components/prefs/pref_service.h"
#include "components/safe_browsing/core/common/safe_browsing_prefs.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/browsing_data_remover.h"
#include "content/public/browser/network_service_instance.h"
#include "content/public/browser/storage_partition.h"
#include "content/public/common/network_service_util.h"
#include "content/public/test/browser_test.h"
#include "content/public/test/browser_test_utils.h"
#include "content/public/test/browsing_data_remover_test_util.h"
#include "content/public/test/content_mock_cert_verifier.h"
#include "content/public/test/network_service_test_helper.h"
#include "mojo/public/cpp/bindings/sync_call_restrictions.h"
#include "net/cert/cert_verify_result.h"
#include "net/cert/sct_status_flags.h"
#include "net/cert/signed_certificate_timestamp.h"
#include "net/cert/signed_certificate_timestamp_and_status.h"
#include "net/cert/x509_certificate.h"
#include "net/dns/mock_host_resolver.h"
#include "net/test/cert_test_util.h"
#include "net/test/ct_test_util.h"
#include "net/test/embedded_test_server/embedded_test_server.h"
#include "net/test/embedded_test_server/http_request.h"
#include "net/test/embedded_test_server/http_response.h"
#include "net/test/embedded_test_server/simple_connection_listener.h"
#include "net/test/test_data_directory.h"
#include "net/traffic_annotation/network_traffic_annotation.h"
#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
#include "services/network/public/cpp/features.h"
#include "services/network/public/mojom/network_service.mojom.h"
#include "services/network/public/proto/sct_audit_report.pb.h"
#include "services/network/test/test_url_loader_factory.h"
namespace {
// These LogId constants allow test cases to specify SCTs from both Google and
// non-Google logs, allowing tests to vary how they meet (or don't meet) the
// Chrome CT policy. To be compliant, the cert used by the embedded test server
// currently requires three embedded SCTs, including at least one from a Google
// log and one from a non-Google log.
//
// Google's "Argon2023" log ("6D7Q2j71BjUy51covIlryQPTy9ERa+zraeF3fW0GvW4="):
const uint8_t kTestGoogleLogId[] = {
0xe8, 0x3e, 0xd0, 0xda, 0x3e, 0xf5, 0x06, 0x35, 0x32, 0xe7, 0x57,
0x28, 0xbc, 0x89, 0x6b, 0xc9, 0x03, 0xd3, 0xcb, 0xd1, 0x11, 0x6b,
0xec, 0xeb, 0x69, 0xe1, 0x77, 0x7d, 0x6d, 0x06, 0xbd, 0x6e};
// Cloudflare's "Nimbus2023" log
// ("ejKMVNi3LbYg6jjgUh7phBZwMhOFTTvSK8E6V6NS61I="):
const uint8_t kTestNonGoogleLogId1[] = {
0x7a, 0x32, 0x8c, 0x54, 0xd8, 0xb7, 0x2d, 0xb6, 0x20, 0xea, 0x38,
0xe0, 0x52, 0x1e, 0xe9, 0x84, 0x16, 0x70, 0x32, 0x13, 0x85, 0x4d,
0x3b, 0xd2, 0x2b, 0xc1, 0x3a, 0x57, 0xa3, 0x52, 0xeb, 0x52};
// DigiCert's "Yeti2023" log ("Nc8ZG7+xbFe/D61MbULLu7YnICZR6j/hKu+oA8M71kw="):
const uint8_t kTestNonGoogleLogId2[] = {
0x35, 0xcf, 0x19, 0x1b, 0xbf, 0xb1, 0x6c, 0x57, 0xbf, 0x0f, 0xad,
0x4c, 0x6d, 0x42, 0xcb, 0xbb, 0xb6, 0x27, 0x20, 0x26, 0x51, 0xea,
0x3f, 0xe1, 0x2a, 0xef, 0xa8, 0x03, 0xc3, 0x3b, 0xd6, 0x4c};
// Constructs a net::SignedCertificateTimestampAndStatus with the given
// information and appends it to |sct_list|.
void MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::Origin origin,
const std::string& extensions,
const std::string& signature_data,
const base::Time& timestamp,
const std::string& log_id,
net::ct::SCTVerifyStatus status,
net::SignedCertificateTimestampAndStatusList* sct_list) {
scoped_refptr<net::ct::SignedCertificateTimestamp> sct(
new net::ct::SignedCertificateTimestamp());
sct->version = net::ct::SignedCertificateTimestamp::V1;
sct->log_id = log_id;
sct->extensions = extensions;
sct->timestamp = timestamp;
sct->signature.signature_data = signature_data;
sct->origin = origin;
sct_list->push_back(net::SignedCertificateTimestampAndStatus(sct, status));
}
std::string ExtractRESTURLParameter(std::string url, std::string param) {
size_t length_start = url.find(param) + param.size() + 1;
size_t length_end = url.find('/', length_start);
return url.substr(length_start, length_end - length_start);
}
std::string HexToString(const char* hex) {
std::string result;
bool ok = base::HexStringToString(hex, &result);
DCHECK(ok);
return result;
}
} // namespace
class SCTReportingServiceBrowserTest : public CertVerifierBrowserTest {
public:
SCTReportingServiceBrowserTest() {
// Set sampling rate to 1.0 to ensure deterministic behavior.
scoped_feature_list_.InitWithFeaturesAndParameters(
{{features::kSCTAuditing,
{{features::kSCTAuditingSamplingRate.name, "1.0"}}}},
{});
SystemNetworkContextManager::SetEnableCertificateTransparencyForTesting(
true);
// The report server must be initialized here so the reporting URL can be
// set before the network service is initialized.
std::ignore = report_server()->InitializeAndListen();
SCTReportingService::GetReportURLInstance() = report_server()->GetURL("/");
SCTReportingService::GetHashdanceLookupQueryURLInstance() =
report_server()->GetURL("/hashdance/length/$1/prefix/$2");
}
~SCTReportingServiceBrowserTest() override {
SystemNetworkContextManager::SetEnableCertificateTransparencyForTesting(
absl::nullopt);
}
SCTReportingServiceBrowserTest(const SCTReportingServiceBrowserTest&) =
delete;
const SCTReportingServiceBrowserTest& operator=(
const SCTReportingServiceBrowserTest&) = delete;
void SetUpOnMainThread() override {
DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
// ConnectionListener must be set before the report server is started. Lets
// tests wait for one connection to be made to the report server (e.g. a
// failed connection due to the cert error that won't trigger the
// WaitForRequests() helper from the parent class).
report_connection_listener_ =
std::make_unique<net::test_server::SimpleConnectionListener>(
1, net::test_server::SimpleConnectionListener::
ALLOW_ADDITIONAL_CONNECTIONS);
report_server()->SetConnectionListener(report_connection_listener());
host_resolver()->AddRule("*", "127.0.0.1");
https_server()->AddDefaultHandlers(GetChromeTestDataDir());
report_server()->RegisterRequestHandler(base::BindRepeating(
&SCTReportingServiceBrowserTest::HandleReportRequest,
base::Unretained(this)));
report_server()->StartAcceptingConnections();
ASSERT_TRUE(https_server()->Start());
mock_cert_verifier()->set_default_result(net::OK);
// Mock the cert verify results so that it has valid CT verification
// results.
cert_with_precert_ = CreateCertificateChainFromFile(
net::GetTestCertsDirectory(), "ct-test-embedded-cert.pem",
net::X509Certificate::FORMAT_AUTO);
ASSERT_TRUE(cert_with_precert_);
ASSERT_EQ(1u, cert_with_precert_->intermediate_buffers().size());
net::CertVerifyResult verify_result;
verify_result.verified_cert = cert_with_precert_;
verify_result.is_issued_by_known_root = true;
// Add three "valid" SCTs and mark the certificate as compliant.
// The default test set up is embedded SCTs where one SCT is from a Google
// log and two are from non-Google logs (to meet the Chrome CT policy).
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions1",
"signature1", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestGoogleLogId),
std::size(kTestGoogleLogId)),
net::ct::SCT_STATUS_OK, &verify_result.scts);
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions2",
"signature2", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
std::size(kTestNonGoogleLogId1)),
net::ct::SCT_STATUS_OK, &verify_result.scts);
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions3",
"signature3", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId2),
std::size(kTestNonGoogleLogId2)),
net::ct::SCT_STATUS_OK, &verify_result.scts);
// Set up two test hosts as using publicly-issued certificates for testing.
mock_cert_verifier()->AddResultForCertAndHost(
https_server()->GetCertificate().get(), "a.test", verify_result,
net::OK);
mock_cert_verifier()->AddResultForCertAndHost(
https_server()->GetCertificate().get(), "b.test", verify_result,
net::OK);
// Set up a third (internal) test host for FlushAndCheckZeroReports().
mock_cert_verifier()->AddResultForCertAndHost(
https_server()->GetCertificate().get(),
"flush-and-check-zero-reports.test", verify_result, net::OK);
CertVerifierBrowserTest::SetUpOnMainThread();
// Set up NetworkServiceTest once.
content::GetNetworkService()->BindTestInterfaceForTesting(
network_service_test_.BindNewPipeAndPassReceiver());
// Override the retry delay to 0 so that retries happen immediately.
mojo::ScopedAllowSyncCallForTesting allow_sync_call;
network_service_test_->SetSCTAuditingRetryDelay(base::TimeDelta());
}
void TearDownOnMainThread() override {
// Reset the retry delay override.
mojo::ScopedAllowSyncCallForTesting allow_sync_call;
network_service_test_->SetSCTAuditingRetryDelay(absl::nullopt);
CertVerifierBrowserTest::TearDownOnMainThread();
}
net::test_server::SimpleConnectionListener* report_connection_listener() {
return report_connection_listener_.get();
}
mojo::Remote<network::mojom::NetworkServiceTest>& network_service_test() {
return network_service_test_;
}
protected:
void SetExtendedReportingEnabled(bool enabled) {
browser()->profile()->GetPrefs()->SetBoolean(
prefs::kSafeBrowsingScoutReportingEnabled, enabled);
}
void SetSafeBrowsingEnabled(bool enabled) {
browser()->profile()->GetPrefs()->SetBoolean(prefs::kSafeBrowsingEnabled,
enabled);
}
// |suffix_list| must be sorted lexicographically.
void SetHashdanceSuffixList(std::vector<std::string> suffix_list) {
suffix_list_ = std::move(suffix_list);
}
net::EmbeddedTestServer* https_server() { return &https_server_; }
net::EmbeddedTestServer* report_server() { return &report_server_; }
void WaitForRequests(size_t num_requests) {
// Each loop iteration will account for one request being processed. (This
// simplifies the request handler code below, and reduces the state that
// must be tracked and handled under locks.)
while (true) {
base::RunLoop run_loop;
{
base::AutoLock auto_lock(requests_lock_);
if (requests_seen_ >= num_requests)
return;
requests_closure_ = run_loop.QuitClosure();
}
run_loop.Run();
}
}
size_t requests_seen() {
base::AutoLock auto_lock(requests_lock_);
return requests_seen_;
}
sct_auditing::SCTClientReport GetLastSeenReport() {
base::AutoLock auto_lock(requests_lock_);
sct_auditing::SCTClientReport auditing_report;
if (last_seen_request_.has_content)
auditing_report.ParseFromString(last_seen_request_.content);
return auditing_report;
}
// Checks that no reports have been sent. To do this, opt-in the profile,
// make a new navigation, and check that there is only a single report and it
// was for this new navigation specifically. This should be used at the end of
// any negative tests to reduce the chance of false successes.
bool FlushAndCheckZeroReports(size_t requests_so_far = 0) {
SetSafeBrowsingEnabled(true);
SetExtendedReportingEnabled(true);
EXPECT_TRUE(ui_test_utils::NavigateToURL(
browser(),
https_server()->GetURL("flush-and-check-zero-reports.test", "/")));
WaitForRequests(1);
return (requests_so_far + 1 == requests_seen() &&
"flush-and-check-zero-reports.test" == GetLastSeenReport()
.certificate_report(0)
.context()
.origin()
.hostname());
}
void set_error_count(int error_count) { error_count_ = error_count; }
const std::string& last_seen_length() { return last_seen_length_; }
const std::string& last_seen_prefix() { return last_seen_prefix_; }
const scoped_refptr<net::X509Certificate> certificate() {
return cert_with_precert_;
}
private:
std::unique_ptr<net::test_server::HttpResponse> HandleReportRequest(
const net::test_server::HttpRequest& request) {
base::AutoLock auto_lock(requests_lock_);
last_seen_request_ = request;
++requests_seen_;
if (requests_closure_)
std::move(requests_closure_).Run();
auto http_response =
std::make_unique<net::test_server::BasicHttpResponse>();
if (request.relative_url.find("hashdance") == std::string::npos) {
// Request is a report.
// Check if the server should just return an error for the full report
// request, otherwise just return OK.
if (error_count_ > 0) {
http_response->set_code(net::HTTP_TOO_MANY_REQUESTS);
--error_count_;
} else {
http_response->set_code(net::HTTP_OK);
}
return http_response;
}
// Request is a hashdance lookup query.
// Parse the URL.
DCHECK(!request.has_content);
last_seen_length_ = ExtractRESTURLParameter(request.relative_url, "length");
last_seen_prefix_ = ExtractRESTURLParameter(request.relative_url, "prefix");
// Create a response.
// 2022-01-01 00:00:00 GMT.
base::Time server_time =
base::Time::UnixEpoch() + base::Seconds(1640995200);
base::Value::Dict response;
response.Set("responseStatus", "OK");
response.Set("now", base::TimeToISO8601(server_time));
base::Value::List suffixes;
for (const auto& suffix : suffix_list_) {
suffixes.Append(
base::Base64Encode(base::as_bytes(base::make_span(suffix))));
}
response.Set("hashSuffix", std::move(suffixes));
base::Value::List log_list;
{
base::Value::Dict log_status;
log_status.Set("logId", base::Base64Encode(kTestGoogleLogId));
log_status.Set("ingestedUntil", base::TimeToISO8601(server_time));
log_list.Append(std::move(log_status));
}
{
base::Value::Dict log_status;
log_status.Set("logId", base::Base64Encode(kTestNonGoogleLogId1));
log_status.Set("ingestedUntil", base::TimeToISO8601(server_time));
log_list.Append(std::move(log_status));
}
{
base::Value::Dict log_status;
log_status.Set("logId", base::Base64Encode(kTestNonGoogleLogId2));
log_status.Set("ingestedUntil", base::TimeToISO8601(server_time));
log_list.Append(std::move(log_status));
}
response.Set("logStatus", std::move(log_list));
std::string json;
bool ok = base::JSONWriter::Write(response, &json);
DCHECK(ok);
http_response->set_content(std::move(json));
http_response->set_content_type("application/octet-stream");
return http_response;
}
net::EmbeddedTestServer https_server_{net::EmbeddedTestServer::TYPE_HTTPS};
net::EmbeddedTestServer report_server_{net::EmbeddedTestServer::TYPE_HTTPS};
base::test::ScopedFeatureList scoped_feature_list_;
scoped_refptr<net::X509Certificate> cert_with_precert_;
std::unique_ptr<net::test_server::SimpleConnectionListener>
report_connection_listener_;
mojo::Remote<network::mojom::NetworkServiceTest> network_service_test_;
// `requests_lock_` is used to force sequential access to these variables to
// avoid races that can cause test flakes.
base::Lock requests_lock_;
net::test_server::HttpRequest last_seen_request_;
size_t requests_seen_ = 0;
// Lookup query received parameters.
std::string last_seen_length_;
std::string last_seen_prefix_;
// Lookup query settings.
std::vector<std::string> suffix_list_;
base::OnceClosure requests_closure_;
// How many times the report server should return an error before succeeding,
// specific to full report requests.
size_t error_count_ = 0;
};
// Tests that reports should be sent when extended reporting is opted in.
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
OptedIn_ShouldEnqueueReport) {
SetExtendedReportingEnabled(true);
// Visit an HTTPS page and wait for the report to be sent.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("a.test", "/")));
WaitForRequests(1);
// Check that one report was sent and contains the expected details.
EXPECT_EQ(1u, requests_seen());
EXPECT_EQ(
"a.test",
GetLastSeenReport().certificate_report(0).context().origin().hostname());
}
// Tests that disabling Safe Browsing entirely should cause reports to not get
// sent.
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest, DisableSafebrowsing) {
SetSafeBrowsingEnabled(false);
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("a.test", "/")));
EXPECT_EQ(0u, requests_seen());
EXPECT_TRUE(FlushAndCheckZeroReports());
}
// Tests that we don't send a report for a navigation with a cert error.
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
CertErrorDoesNotEnqueueReport) {
SetExtendedReportingEnabled(true);
// Visit a page with an invalid cert.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("invalid.test", "/")));
EXPECT_EQ(0u, requests_seen());
EXPECT_TRUE(FlushAndCheckZeroReports());
}
// Tests that reports aren't sent for Incognito windows.
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
IncognitoWindow_ShouldNotEnqueueReport) {
// Enable SBER in the main profile.
SetExtendedReportingEnabled(true);
// Create a new Incognito window.
auto* incognito = CreateIncognitoBrowser();
ASSERT_TRUE(
ui_test_utils::NavigateToURL(incognito, https_server()->GetURL("/")));
EXPECT_EQ(0u, requests_seen());
EXPECT_TRUE(FlushAndCheckZeroReports());
}
// Tests that disabling Extended Reporting causes the cache to be cleared.
// TODO(crbug.com/1179504): Reenable. Flakes heavily on all platforms.
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
DISABLED_OptingOutClearsSCTAuditingCache) {
// Enable SCT auditing and enqueue a report.
SetExtendedReportingEnabled(true);
// Visit an HTTPS page and wait for a report to be sent.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("a.test", "/")));
WaitForRequests(1);
// Check that one report was sent.
EXPECT_EQ(1u, requests_seen());
EXPECT_EQ(
"a.test",
GetLastSeenReport().certificate_report(0).context().origin().hostname());
// Disable Extended Reporting which should clear the underlying cache.
SetExtendedReportingEnabled(false);
// We can check that the same report gets cached again instead of being
// deduplicated (i.e., another report should be sent).
SetExtendedReportingEnabled(true);
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("a.test", "/")));
WaitForRequests(2);
EXPECT_EQ(2u, requests_seen());
EXPECT_EQ(
"a.test",
GetLastSeenReport().certificate_report(0).context().origin().hostname());
}
// Tests that reports are still sent for opted-in profiles after the network
// service crashes and is restarted.
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
ReportsSentAfterNetworkServiceRestart) {
// This test is only applicable to out-of-process network service because it
// tests what happens when the network service crashes and restarts.
if (content::IsInProcessNetworkService()) {
return;
}
SetExtendedReportingEnabled(true);
// Crash the NetworkService to force it to restart.
SimulateNetworkServiceCrash();
// Flush the network interface to make sure it notices the crash.
browser()
->profile()
->GetDefaultStoragePartition()
->FlushNetworkInterfaceForTesting();
g_browser_process->system_network_context_manager()
->FlushNetworkInterfaceForTesting();
// The mock cert verify result will be lost when the network service restarts,
// so set back up the necessary rules.
mock_cert_verifier()->set_default_result(net::OK);
// The retry delay override will be reset when the network service restarts,
// so set back up a retry delay of zero to avoid test timeouts.
{
network_service_test().reset();
content::GetNetworkService()->BindTestInterfaceForTesting(
network_service_test().BindNewPipeAndPassReceiver());
mojo::ScopedAllowSyncCallForTesting allow_sync_call;
network_service_test()->SetSCTAuditingRetryDelay(base::TimeDelta());
// Default test fixture teardown will reset the delay back to the default.
}
net::CertVerifyResult verify_result;
verify_result.verified_cert = https_server()->GetCertificate().get();
verify_result.is_issued_by_known_root = true;
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions1",
"signature1", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestGoogleLogId),
std::size(kTestGoogleLogId)),
net::ct::SCT_STATUS_OK, &verify_result.scts);
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions2",
"signature2", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
std::size(kTestNonGoogleLogId1)),
net::ct::SCT_STATUS_OK, &verify_result.scts);
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions3",
"signature3", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId2),
std::size(kTestNonGoogleLogId2)),
net::ct::SCT_STATUS_OK, &verify_result.scts);
mock_cert_verifier()->AddResultForCertAndHost(
https_server()->GetCertificate().get(), "a.test", verify_result, net::OK);
// Visit an HTTPS page and wait for the report to be sent.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("a.test", "/")));
WaitForRequests(1);
// Check that one report was enqueued.
EXPECT_EQ(1u, requests_seen());
EXPECT_EQ(
"a.test",
GetLastSeenReport().certificate_report(0).context().origin().hostname());
}
// Tests that invalid SCTs don't get reported when the overall result is
// compliant with CT policy.
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
CTCompliantInvalidSCTsNotReported) {
// Set up a mocked CertVerifyResult that includes both valid and invalid SCTs.
net::CertVerifyResult verify_result;
verify_result.verified_cert = https_server()->GetCertificate().get();
verify_result.is_issued_by_known_root = true;
// Add three valid SCTs and one invalid SCT. The three valid SCTs meet the
// Chrome CT policy.
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions1",
"signature1", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestGoogleLogId),
sizeof(kTestGoogleLogId)),
net::ct::SCT_STATUS_OK, &verify_result.scts);
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions2",
"signature2", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
sizeof(kTestNonGoogleLogId1)),
net::ct::SCT_STATUS_OK, &verify_result.scts);
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions3",
"signature3", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId2),
sizeof(kTestNonGoogleLogId2)),
net::ct::SCT_STATUS_OK, &verify_result.scts);
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions4",
"signature4", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId2),
sizeof(kTestNonGoogleLogId2)),
net::ct::SCT_STATUS_INVALID_SIGNATURE, &verify_result.scts);
mock_cert_verifier()->AddResultForCertAndHost(
https_server()->GetCertificate().get(), "mixed-scts.test", verify_result,
net::OK);
SetExtendedReportingEnabled(true);
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("mixed-scts.test", "/")));
WaitForRequests(1);
EXPECT_EQ(1u, requests_seen());
auto report = GetLastSeenReport();
EXPECT_EQ(3, report.certificate_report(0).included_sct_size());
}
// Tests that invalid SCTs don't get included when the overall result is
// non-compliant with CT policy. Valid SCTs should still be reported.
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
CTNonCompliantInvalidSCTsNotReported) {
// Set up a mocked CertVerifyResult that includes both valid and invalid SCTs.
net::CertVerifyResult verify_result;
verify_result.verified_cert = https_server()->GetCertificate().get();
verify_result.is_issued_by_known_root = true;
// Add one valid SCT and two invalid SCTs. These SCTs will not meet the Chrome
// CT policy requirements.
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions1",
"signature1", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
sizeof(kTestNonGoogleLogId1)),
net::ct::SCT_STATUS_OK, &verify_result.scts);
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions2",
"signature2", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
sizeof(kTestNonGoogleLogId1)),
net::ct::SCT_STATUS_INVALID_SIGNATURE, &verify_result.scts);
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions3",
"signature3", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId2),
sizeof(kTestNonGoogleLogId2)),
net::ct::SCT_STATUS_INVALID_SIGNATURE, &verify_result.scts);
mock_cert_verifier()->AddResultForCertAndHost(
https_server()->GetCertificate().get(), "mixed-scts.test", verify_result,
net::OK);
SetExtendedReportingEnabled(true);
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("mixed-scts.test", "/")));
WaitForRequests(1);
EXPECT_EQ(1u, requests_seen());
auto report = GetLastSeenReport();
EXPECT_EQ(1, report.certificate_report(0).included_sct_size());
}
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest, NoValidSCTsNoReport) {
// Set up a mocked CertVerifyResult with only invalid SCTs.
net::CertVerifyResult verify_result;
verify_result.verified_cert = https_server()->GetCertificate().get();
verify_result.is_issued_by_known_root = true;
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions1",
"signature1", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
sizeof(kTestNonGoogleLogId1)),
net::ct::SCT_STATUS_INVALID_TIMESTAMP, &verify_result.scts);
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions2",
"signature2", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
sizeof(kTestNonGoogleLogId1)),
net::ct::SCT_STATUS_INVALID_SIGNATURE, &verify_result.scts);
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions3",
"signature3", base::Time::Now(),
std::string(reinterpret_cast<const char*>(kTestNonGoogleLogId1),
sizeof(kTestNonGoogleLogId1)),
net::ct::SCT_STATUS_INVALID_SIGNATURE, &verify_result.scts);
mock_cert_verifier()->AddResultForCertAndHost(
https_server()->GetCertificate().get(), "invalid-scts.test",
verify_result, net::OK);
SetExtendedReportingEnabled(true);
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("invalid-scts.test", "/")));
EXPECT_EQ(0u, requests_seen());
EXPECT_TRUE(FlushAndCheckZeroReports());
}
class SCTReportingServiceZeroSamplingRateBrowserTest
: public SCTReportingServiceBrowserTest {
public:
SCTReportingServiceZeroSamplingRateBrowserTest() {
scoped_feature_list_.InitWithFeaturesAndParameters(
{{features::kSCTAuditing,
{{features::kSCTAuditingSamplingRate.name, "0.0"}}}},
{});
}
SCTReportingServiceZeroSamplingRateBrowserTest(
const SCTReportingServiceZeroSamplingRateBrowserTest&) = delete;
const SCTReportingServiceZeroSamplingRateBrowserTest& operator=(
const SCTReportingServiceZeroSamplingRateBrowserTest&) = delete;
private:
base::test::ScopedFeatureList scoped_feature_list_;
};
// Tests that the embedder is not notified when the sampling rate is zero.
IN_PROC_BROWSER_TEST_F(SCTReportingServiceZeroSamplingRateBrowserTest,
EmbedderNotNotified) {
SetExtendedReportingEnabled(true);
// Visit an HTTPS page.
ASSERT_TRUE(
ui_test_utils::NavigateToURL(browser(), https_server()->GetURL("/")));
// Check that no reports are observed.
EXPECT_EQ(0u, requests_seen());
}
// Tests the simple case where a report succeeds on the first try.
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest, SucceedOnFirstTry) {
// Succeed on the first try.
set_error_count(0);
SetExtendedReportingEnabled(true);
// Visit an HTTPS page and wait for the report to be sent.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("a.test", "/")));
WaitForRequests(1);
// Check that one report was sent and contains the expected details.
EXPECT_EQ(1u, requests_seen());
EXPECT_EQ(
"a.test",
GetLastSeenReport().certificate_report(0).context().origin().hostname());
}
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest, RetryOnceAndSucceed) {
// Succeed on the second try.
set_error_count(1);
SetExtendedReportingEnabled(true);
// Visit an HTTPS page and wait for the report to be sent twice.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("a.test", "/")));
WaitForRequests(2);
// Check that the report was sent twice and contains the expected details.
EXPECT_EQ(2u, requests_seen());
EXPECT_EQ(
"a.test",
GetLastSeenReport().certificate_report(0).context().origin().hostname());
}
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest, FailAfterMaxRetries) {
// Don't succeed for max_retries+1.
set_error_count(16);
SetExtendedReportingEnabled(true);
// Visit an HTTPS page and wait for the report to be sent.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("a.test", "/")));
// Wait until the reporter completes 16 requests.
WaitForRequests(16);
// Check that the report was sent 16x and contains the expected details.
EXPECT_EQ(16u, requests_seen());
EXPECT_EQ(
"a.test",
GetLastSeenReport().certificate_report(0).context().origin().hostname());
}
// Test that a cert error on the first attempt to send a report will trigger
// retries that succeed if the server starts using a good cert.
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
CertificateErrorTriggersRetry) {
{
// Override the retry delay to 1s so that the retries don't all happen
// immediately and the test can reset the default verifier result in
// between retry attempts.
mojo::ScopedAllowSyncCallForTesting allow_sync_call;
network_service_test()->SetSCTAuditingRetryDelay(base::Seconds(1));
// Default test fixture teardown will reset the delay back to the default.
}
// The first request to the report server will trigger a certificate error via
// the mock cert verifier.
mock_cert_verifier()->set_default_result(net::ERR_CERT_COMMON_NAME_INVALID);
SetExtendedReportingEnabled(true);
// Visit an HTTPS page, which will trigger a report being sent to the report
// server but that report request will result in a cert error.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("a.test", "/")));
report_connection_listener()->WaitForConnections();
// After seeing one connection, replace the mock cert verifier result with a
// successful result.
mock_cert_verifier()->set_default_result(net::OK);
WaitForRequests(1);
// The second try should have resulted in the first successful report being
// seen by the HandleRequest() handler.
EXPECT_EQ(1u, requests_seen());
EXPECT_EQ(
"a.test",
GetLastSeenReport().certificate_report(0).context().origin().hostname());
}
class SCTHashdanceBrowserTest : public SCTReportingServiceBrowserTest {
protected:
void SetUpOnMainThread() override {
SCTReportingServiceBrowserTest::SetUpOnMainThread();
SetExtendedReportingEnabled(false);
// Add a valid SCT that was issued at the beginning of time (and should
// therefore be assumed to have been ingested by the server already). We
// need to use a stable timestamp to get the same leaf hash in every run.
// This SCT results in the leaf hash
// 157F5BD43E660E1A87C45797CE524B4171A231CC10FE912A51A14ABA17EAB6B2.
net::CertVerifyResult verify_result;
verify_result.verified_cert = certificate();
verify_result.is_issued_by_known_root = true;
MakeTestSCTAndStatus(
net::ct::SignedCertificateTimestamp::SCT_EMBEDDED, "extensions1",
"signature1", base::Time::UnixEpoch(),
std::string(reinterpret_cast<const char*>(kTestGoogleLogId),
std::size(kTestGoogleLogId)),
net::ct::SCT_STATUS_OK, &verify_result.scts);
mock_cert_verifier()->AddResultForCertAndHost(
https_server()->GetCertificate().get(), "hashdance.test", verify_result,
net::OK);
}
private:
base::test::ScopedFeatureList scoped_feature_list_{
features::kSCTAuditingHashdance};
};
IN_PROC_BROWSER_TEST_F(SCTHashdanceBrowserTest, ReportSCTNotFound) {
SetHashdanceSuffixList(
{base::HexEncode(base::as_bytes(base::make_span(
"000000000000000000000000000000000000000000000000000000000000"))),
base::HexEncode(base::as_bytes(base::make_span(
"0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")))});
// Visit an HTTPS page and wait for the lookup query to be sent.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("hashdance.test", "/")));
WaitForRequests(2);
// Check that the lookup query was sent with the expected details.
EXPECT_EQ(requests_seen(), 2u);
EXPECT_EQ(last_seen_length(), "20");
EXPECT_EQ(last_seen_prefix(), "157F50");
EXPECT_EQ(
"hashdance.test",
GetLastSeenReport().certificate_report(0).context().origin().hostname());
}
IN_PROC_BROWSER_TEST_F(SCTHashdanceBrowserTest, DoNotReportSCTFound) {
SetHashdanceSuffixList(
{HexToString(
"000000000000000000000000000000000000000000000000000000000000"),
HexToString(
"5BD43E660E1A87C45797CE524B4171A231CC10FE912A51A14ABA17EAB6B2"),
HexToString(
"0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")});
// Visit an HTTPS page and wait for the lookup query to be sent.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("hashdance.test", "/")));
WaitForRequests(1);
// Check that the lookup query was sent with the expected details.
EXPECT_EQ(requests_seen(), 1u);
EXPECT_EQ(last_seen_length(), "20");
EXPECT_EQ(last_seen_prefix(), "157F50");
// No requests should have been sent.
EXPECT_TRUE(FlushAndCheckZeroReports(/*requests_so_far=*/1));
}
IN_PROC_BROWSER_TEST_F(SCTHashdanceBrowserTest,
HashdanceReportCountIncremented) {
base::HistogramTester histograms;
// Visit an HTTPS page and wait for the full report to be sent.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("hashdance.test", "/")));
WaitForRequests(2);
// Check that two requests (lookup and full report) were sent and the report
// contains the expected details.
EXPECT_EQ(2u, requests_seen());
EXPECT_EQ(
"hashdance.test",
GetLastSeenReport().certificate_report(0).context().origin().hostname());
// Check that the report count got incremented.
int report_count = g_browser_process->local_state()->GetInteger(
prefs::kSCTAuditingHashdanceReportCount);
EXPECT_EQ(report_count, 1);
// The histogram is logged *before* the report count is incremented, so the
// histogram will only log a report count of zero, once.
histograms.ExpectUniqueSample("Security.SCTAuditing.OptOut.ReportCount", 0,
1);
}
// Test that report count isn't incremented when retrying a single audit report.
// Regression test for crbug.com/1348313.
IN_PROC_BROWSER_TEST_F(SCTHashdanceBrowserTest,
HashdanceReportCountNotIncrementedOnRetry) {
base::HistogramTester histograms;
// Don't succeed for max_retries+1, for the *full report sending*, but the
// hashdance lookup query will always succeed.
set_error_count(16);
// Visit an HTTPS page and wait for the report to be sent.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("hashdance.test", "/")));
// Wait until the reporter completes 32 requests (16 lookup queries which
// succeed, and 16 full report requests which fail).
WaitForRequests(32);
// Check that 32 requests were seen and contains the expected details.
EXPECT_EQ(32u, requests_seen());
EXPECT_EQ(
"hashdance.test",
GetLastSeenReport().certificate_report(0).context().origin().hostname());
// Check that the report was only counted once towards the max-reports limit.
int report_count = g_browser_process->local_state()->GetInteger(
prefs::kSCTAuditingHashdanceReportCount);
EXPECT_EQ(report_count, 1);
// Retrying sending the same report will only check the report count once the
// first time, so the histogram will only log a report count of zero, once.
histograms.ExpectUniqueSample("Security.SCTAuditing.OptOut.ReportCount", 0,
1);
}
IN_PROC_BROWSER_TEST_F(SCTHashdanceBrowserTest, HashdanceReportLimitReached) {
base::HistogramTester histograms;
// Override the report count to be the maximum.
g_browser_process->local_state()->SetInteger(
prefs::kSCTAuditingHashdanceReportCount, 3);
// Visit an HTTPS page.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("hashdance.test", "/")));
// Check that no reports are sent.
EXPECT_EQ(0u, requests_seen());
SetSafeBrowsingEnabled(false); // Clears the deduplication cache.
EXPECT_TRUE(FlushAndCheckZeroReports());
histograms.ExpectUniqueSample("Security.SCTAuditing.OptOut.ReportCount", 3,
1);
}
// Wrapper around FilePathWatcher to help tests wait for an auditing report to
// be persisted to disk. This is also robust to the persistence file being
// written to before the test initiates the wait, helping avoid race conditions
// that can cause hard-to-debug flakes.
//
// This currently monitors *two* file paths, because depending on the platform
// (and the state of the network service sandbox rollout) the persisted data
// file path may have an extra "Network/" subdirectory component, but it is
// difficult to determine this from test data. WaitUntilPersisted() will wait
// until *either* of the two paths have been written to.
//
// ReportPersistenceWaiter also takes a `filesize_threshold` as the "empty"
// persistence file still has some structure/data in it. For the current
// persistence format (list of JSON dicts), the "empty" persistence file is 2
// bytes (the empty list `[]`).
class ReportPersistenceWaiter {
public:
ReportPersistenceWaiter(const base::FilePath& watched_file_path,
const base::FilePath& alternative_file_path,
int64_t filesize_threshold)
: watched_file_path1_(watched_file_path),
watched_file_path2_(alternative_file_path),
filesize_threshold_(filesize_threshold) {}
ReportPersistenceWaiter(const ReportPersistenceWaiter&) = delete;
ReportPersistenceWaiter& operator=(const ReportPersistenceWaiter&) = delete;
void WaitUntilPersisted() {
DCHECK(!watcher1_);
DCHECK(!watcher2_);
{
// Check if either file was already written and if so return early.
base::ScopedAllowBlockingForTesting allow_blocking;
int64_t file_size;
// GetFileSize() will return `false` if the file does not yet exist.
if (base::GetFileSize(watched_file_path1_, &file_size) &&
file_size > filesize_threshold_) {
return;
}
if (base::GetFileSize(watched_file_path2_, &file_size) &&
file_size > filesize_threshold_) {
return;
}
}
watcher1_ = std::make_unique<base::FilePathWatcher>();
watcher2_ = std::make_unique<base::FilePathWatcher>();
EXPECT_TRUE(watcher1_->Watch(
watched_file_path1_, base::FilePathWatcher::Type::kNonRecursive,
base::BindRepeating(&ReportPersistenceWaiter::OnPathChanged,
base::Unretained(this))));
EXPECT_TRUE(watcher2_->Watch(
watched_file_path2_, base::FilePathWatcher::Type::kNonRecursive,
base::BindRepeating(&ReportPersistenceWaiter::OnPathChanged,
base::Unretained(this))));
run_loop_.Run();
// The watchers should be destroyed before quitting the run loop.
DCHECK(!watcher1_);
DCHECK(!watcher2_);
}
private:
void OnPathChanged(const base::FilePath& path, bool error) {
EXPECT_TRUE(path == watched_file_path1_ || path == watched_file_path2_);
EXPECT_FALSE(error);
watcher1_.reset();
watcher2_.reset();
run_loop_.Quit();
}
base::RunLoop run_loop_;
const base::FilePath watched_file_path1_;
const base::FilePath watched_file_path2_;
const int64_t filesize_threshold_;
std::unique_ptr<base::FilePathWatcher> watcher1_;
std::unique_ptr<base::FilePathWatcher> watcher2_;
};
IN_PROC_BROWSER_TEST_F(SCTReportingServiceBrowserTest,
PersistedReportClearedOnClearBrowsingHistory) {
// Set a long retry delay so that retries don't occur immediately.
{
mojo::ScopedAllowSyncCallForTesting allow_sync_call;
network_service_test()->SetSCTAuditingRetryDelay(base::Minutes(1));
}
// Don't immediately succeed, so report stays persisted to disk.
set_error_count(10);
SetExtendedReportingEnabled(true);
// The empty/cleared persistence file will be 2 bytes (the empty JSON list).
constexpr int64_t kEmptyPersistenceFileSize = 2;
base::FilePath persistence_path1 = browser()->profile()->GetPath();
// If the network service sandbox is enabled, then the network service data
// dir path has an additional "Network" subdirectory in it. This means that
// different platforms will have different persistence paths depending on the
// current state of the network service sandbox rollout.
// TODO(crbug.com/715679): Simplify this once the paths are consistent (i.e.,
// after the network service sandbox is fully rolled out.)
base::FilePath persistence_path2 =
persistence_path1.Append(chrome::kNetworkDataDirname);
persistence_path1 =
persistence_path1.Append(chrome::kSCTAuditingPendingReportsFileName);
persistence_path2 =
persistence_path2.Append(chrome::kSCTAuditingPendingReportsFileName);
// Visit an HTTPS page to generate an SCT auditing report. Sending the report
// will result in an error, so the pending report will remain.
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), https_server()->GetURL("a.test", "/")));
// Check that the report got persisted to disk.
{
base::ScopedAllowBlockingForTesting allow_blocking;
ReportPersistenceWaiter waiter(persistence_path1, persistence_path2,
kEmptyPersistenceFileSize);
waiter.WaitUntilPersisted();
int64_t file_size1;
int64_t file_size2;
bool one_file_is_written =
base::GetFileSize(persistence_path1, &file_size1) ||
base::GetFileSize(persistence_path2, &file_size2);
EXPECT_TRUE(one_file_is_written);
EXPECT_TRUE(file_size1 > kEmptyPersistenceFileSize ||
file_size2 > kEmptyPersistenceFileSize);
}
// Trigger removal and wait for completion.
auto* contents = browser()->tab_strip_model()->GetActiveWebContents();
content::BrowsingDataRemover* remover =
contents->GetBrowserContext()->GetBrowsingDataRemover();
content::BrowsingDataRemoverCompletionObserver completion_observer(remover);
remover->RemoveAndReply(
base::Time(), base::Time::Max(),
content::BrowsingDataRemover::DATA_TYPE_CACHE,
content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB,
&completion_observer);
completion_observer.BlockUntilCompletion();
// Check that the persistence file is cleared.
{
base::ScopedAllowBlockingForTesting allow_blocking;
int64_t file_size;
if (base::GetFileSize(persistence_path1, &file_size)) {
EXPECT_EQ(file_size, kEmptyPersistenceFileSize);
} else if (base::GetFileSize(persistence_path2, &file_size)) {
EXPECT_EQ(file_size, kEmptyPersistenceFileSize);
} else {
FAIL() << "Neither persistence file was ever written";
}
}
}
| [
"jengelh@inai.de"
] | jengelh@inai.de |
161fa1dafb5a3a9a120361e898c7b30673237981 | 26772748929329f0a6feb6c54c51f6ab02b79561 | /Export/mac64/cpp/obj/include/lime/audio/openal/ALC.h | 9800c44a4fcea491d656903334d3fb5d152cbd87 | [] | no_license | pvsmartinez/ilha | f9c473bc4ef14a937fe80151f188c21334685265 | 24549ac14c6e2e5b3921b09fb486d7cc9d662804 | refs/heads/master | 2021-01-10T04:43:17.740463 | 2015-11-04T22:06:19 | 2015-11-04T22:06:19 | 44,400,109 | 2 | 0 | null | 2015-11-01T23:31:21 | 2015-10-16T17:21:55 | C++ | UTF-8 | C++ | false | false | 5,348 | h | #ifndef INCLUDED_lime_audio_openal_ALC
#define INCLUDED_lime_audio_openal_ALC
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS3(lime,audio,openal,ALC)
namespace lime{
namespace audio{
namespace openal{
class HXCPP_CLASS_ATTRIBUTES ALC_obj : public hx::Object{
public:
typedef hx::Object super;
typedef ALC_obj OBJ_;
ALC_obj();
Void __construct();
public:
inline void *operator new( size_t inSize, bool inContainer=false,const char *inName="lime.audio.openal.ALC")
{ return hx::Object::operator new(inSize,inContainer,inName); }
static hx::ObjectPtr< ALC_obj > __new();
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~ALC_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
static void __register();
::String __ToString() const { return HX_HCSTRING("ALC","\xf8","\x94","\x31","\x00"); }
static void __boot();
static int FALSE;
static int TRUE;
static int FREQUENCY;
static int REFRESH;
static int SYNC;
static int MONO_SOURCES;
static int STEREO_SOURCES;
static int NO_ERROR;
static int INVALID_DEVICE;
static int INVALID_CONTEXT;
static int INVALID_ENUM;
static int INVALID_VALUE;
static int OUT_OF_MEMORY;
static int ATTRIBUTES_SIZE;
static int ALL_ATTRIBUTES;
static int DEFAULT_DEVICE_SPECIFIER;
static int DEVICE_SPECIFIER;
static int EXTENSIONS;
static int ENUMERATE_ALL_EXT;
static int DEFAULT_ALL_DEVICES_SPECIFIER;
static int ALL_DEVICES_SPECIFIER;
static bool closeDevice( Dynamic device);
static Dynamic closeDevice_dyn();
static Dynamic createContext( Dynamic device,Array< int > attrlist);
static Dynamic createContext_dyn();
static Void destroyContext( Dynamic context);
static Dynamic destroyContext_dyn();
static Dynamic getContextsDevice( Dynamic context);
static Dynamic getContextsDevice_dyn();
static Dynamic getCurrentContext( );
static Dynamic getCurrentContext_dyn();
static int getError( Dynamic device);
static Dynamic getError_dyn();
static ::String getErrorString( Dynamic device);
static Dynamic getErrorString_dyn();
static Array< int > getIntegerv( Dynamic device,int param,int size);
static Dynamic getIntegerv_dyn();
static ::String getString( Dynamic device,int param);
static Dynamic getString_dyn();
static bool makeContextCurrent( Dynamic context);
static Dynamic makeContextCurrent_dyn();
static Dynamic openDevice( ::String deviceName);
static Dynamic openDevice_dyn();
static Void processContext( Dynamic context);
static Dynamic processContext_dyn();
static Void suspendContext( Dynamic context);
static Dynamic suspendContext_dyn();
static bool lime_alc_close_device( Dynamic device);
static Dynamic lime_alc_close_device_dyn();
static Dynamic lime_alc_create_context( Dynamic device,Dynamic attrlist);
static Dynamic lime_alc_create_context_dyn();
static Void lime_alc_destroy_context( Dynamic context);
static Dynamic lime_alc_destroy_context_dyn();
static Dynamic lime_alc_get_contexts_device( Dynamic context);
static Dynamic lime_alc_get_contexts_device_dyn();
static Dynamic lime_alc_get_current_context( );
static Dynamic lime_alc_get_current_context_dyn();
static int lime_alc_get_error( Dynamic device);
static Dynamic lime_alc_get_error_dyn();
static Dynamic lime_alc_get_integerv( Dynamic device,int param,int size);
static Dynamic lime_alc_get_integerv_dyn();
static Dynamic lime_alc_get_string( Dynamic device,int param);
static Dynamic lime_alc_get_string_dyn();
static bool lime_alc_make_context_current( Dynamic context);
static Dynamic lime_alc_make_context_current_dyn();
static Dynamic lime_alc_open_device( ::String devicename);
static Dynamic lime_alc_open_device_dyn();
static Void lime_alc_process_context( Dynamic context);
static Dynamic lime_alc_process_context_dyn();
static Void lime_alc_suspend_context( Dynamic context);
static Dynamic lime_alc_suspend_context_dyn();
static ::cpp::Function< bool ( ::hx::Object * ) > cffi_lime_alc_close_device;
static ::cpp::Function< ::hx::Object * ( ::hx::Object * ,::hx::Object * ) > cffi_lime_alc_create_context;
static ::cpp::Function< void ( ::hx::Object * ) > cffi_lime_alc_destroy_context;
static ::cpp::Function< ::hx::Object * ( ::hx::Object * ) > cffi_lime_alc_get_contexts_device;
static ::cpp::Function< ::hx::Object * ( ) > cffi_lime_alc_get_current_context;
static ::cpp::Function< int ( ::hx::Object * ) > cffi_lime_alc_get_error;
static ::cpp::Function< ::hx::Object * ( ::hx::Object * ,int ,int ) > cffi_lime_alc_get_integerv;
static ::cpp::Function< ::hx::Object * ( ::hx::Object * ,int ) > cffi_lime_alc_get_string;
static ::cpp::Function< bool ( ::hx::Object * ) > cffi_lime_alc_make_context_current;
static ::cpp::Function< ::hx::Object * ( ::String ) > cffi_lime_alc_open_device;
static ::cpp::Function< void ( ::hx::Object * ) > cffi_lime_alc_process_context;
static ::cpp::Function< void ( ::hx::Object * ) > cffi_lime_alc_suspend_context;
};
} // end namespace lime
} // end namespace audio
} // end namespace openal
#endif /* INCLUDED_lime_audio_openal_ALC */
| [
"pvsmartinez@gmail.com"
] | pvsmartinez@gmail.com |
38bd1aab3b57548ab7aadbaafea8fb70e9b041df | 92745756b1d9280222894d6b7ba918c00f76bf3b | /SDK/PUBG_P_VehicleSkidAccel_Grass_BP_classes.hpp | f4a35f8854c8c0f4e3088f4ab83019baf786a0ea | [] | no_license | ziyouhaofan/PUBG-SDK | 018b2b28420b762de8c2b7e7142cb4f28647dc7f | 03d5f52e8d4fd7e2bef250217a9a5622366610e2 | refs/heads/master | 2021-07-19T11:34:17.527464 | 2017-10-26T03:42:44 | 2017-10-26T03:42:44 | 108,414,666 | 1 | 0 | null | 2017-10-26T13:24:32 | 2017-10-26T13:24:32 | null | UTF-8 | C++ | false | false | 664 | hpp | #pragma once
// PlayerUnknown's Battlegrounds SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
namespace Classes {
//---------------------------------------------------------------------------
//Classes
//---------------------------------------------------------------------------
// BlueprintGeneratedClass P_VehicleSkidAccel_Grass_BP.P_VehicleSkidAccel_Grass_BP_C
// 0x0000 (0x03F8 - 0x03F8)
class AP_VehicleSkidAccel_Grass_BP_C : public ATslParticle {
public:
static UClass* StaticClass() {
static UClass* ptr = nullptr;
if (!ptr) ptr = UObject::FindClass(0xa6447e25);
return ptr;
}
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"tj8@live.com.au"
] | tj8@live.com.au |
cd280c76d285ee386f92a9bcfe5751f93e76f686 | 5531d676864880b890630f462cfc6d05defd1d79 | /include/boost/gil/extension/toolbox/color_converters/gray_to_rgba.hpp | f9f9c540fb8d69648b8efaacc48284093767fc72 | [] | no_license | BeamMW/boost-android | 2cd0ec609462e72ac41bdcf02ded82f954652dde | 60cc7878e44e898cf44fb04a1f10372eceaa9b02 | refs/heads/master | 2020-04-27T11:13:33.402189 | 2019-04-01T10:04:55 | 2019-04-01T10:04:55 | 174,288,040 | 2 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,832 | hpp | /*
Copyright 2012 Christian Henning, Andreas Pokorny, Lubomir Bourdev
Use, modification and distribution are subject to the Boost Software License,
Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
http://www.boost.org/LICENSE_1_0.txt).
*/
/*************************************************************************************************/
#ifndef BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_GRAY_TO_RGBA_HPP
#define BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_GRAY_TO_RGBA_HPP
////////////////////////////////////////////////////////////////////////////////////////
/// \file
/// \brief
/// \author Christian Henning, Andreas Pokorny, Lubomir Bourdev \n
///
/// \date 2012 \n
///
////////////////////////////////////////////////////////////////////////////////////////
#include <boost/gil/color_convert.hpp>
namespace boost{ namespace gil {
/// This one is missing in gil ( color_convert.hpp ).
template <>
struct default_color_converter_impl<gray_t,rgba_t>
{
template <typename P1, typename P2>
void operator()(const P1& src, P2& dst) const
{
get_color(dst,red_t()) =
channel_convert<typename color_element_type<P2, red_t >::type>(get_color(src,gray_color_t()));
get_color(dst,green_t())=
channel_convert<typename color_element_type<P2, green_t>::type>(get_color(src,gray_color_t()));
get_color(dst,blue_t()) =
channel_convert<typename color_element_type<P2, blue_t >::type>(get_color(src,gray_color_t()));
typedef typename channel_type< P2 >::type channel_t;
get_color(dst,alpha_t()) = channel_traits< channel_t >::max_value();
}
};
} // namespace gil
} // namespace boost
#endif // BOOST_GIL_EXTENSION_TOOLBOX_COLOR_CONVERTERS_GRAY_TO_RGBA_HPP
| [
"strylets@gmail.com"
] | strylets@gmail.com |
65db86743f5226d16cbe9bf5c4aa3b681d2826a7 | d70d76a346a267b1a592eb1cf5009aafb808bd24 | /node_modules/opencv-build/opencv/build/modules/imgproc/morph.sse2.cpp | 5923e58fde4725d4fb3a11dab29b061abca7d10c | [] | no_license | techieskycode/Vigilant-Engine | b7dd892340f954e62a0f82cbb5256269b278ca31 | 88bd9c8064eef19d9bf8cc5cf78c2e9209618b01 | refs/heads/master | 2023-06-09T06:58:21.848223 | 2020-03-23T09:47:33 | 2020-03-23T09:47:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 224 | cpp |
#include "/home/windows/Desktop/cctv/node_modules/opencv-build/opencv/opencv/modules/imgproc/src/precomp.hpp"
#include "/home/windows/Desktop/cctv/node_modules/opencv-build/opencv/opencv/modules/imgproc/src/morph.simd.hpp"
| [
"skumar2019@outlook.com"
] | skumar2019@outlook.com |
62e124b239ad19240a63785b1b9bccbce589c0fb | de0ea2d1666a1e91f098a19dbb5203c3318cebf2 | /include/mithril/bootstrap/client_event_loop_service.hh | 93ea0e15044a82c36c407ab2fa86b5039e687892 | [
"ISC"
] | permissive | salahsheikh/mithril | 94bd8b6dd57f1de8e48e77a7b43b1456596e9ded | 020c9c6ad645e0a2767653cd158460ab1c6c13ca | refs/heads/main | 2023-03-30T15:24:37.126890 | 2021-04-05T03:17:06 | 2021-04-05T03:17:06 | 347,783,006 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,325 | hh | //
// Created by ssheikh on 2021-02-27.
//
#ifndef MITHRIL_INCLUDE_MITHRIL_CLIENT_EVENT_LOOP_SERVICE_HH
#define MITHRIL_INCLUDE_MITHRIL_CLIENT_EVENT_LOOP_SERVICE_HH
#include <mithril/channel/socket_channel.hh>
#include <seastar/core/future.hh>
#include <seastar/net/api.hh>
#include <seastar/core/distributed.hh>
#include <seastar/core/app-template.hh>
#include <seastar/core/reactor.hh>
#include <seastar/core/distributed.hh>
#include <optional>
using seastar::stop_iteration;
template<typename T>
class client_event_loop_service
{
private:
std::optional<seastar::future<>> task;
std::shared_ptr<socket_channel> channel;
bool running = false;
unsigned short port;
std::string host;
public:
explicit client_event_loop_service(std::string_view host, unsigned short PORT)
: port {PORT}, host {host}
{
}
void start()
{
MITHRIL_LOG(info) << "Started client...";
seastar::socket_address local = seastar::socket_address(::sockaddr_in {AF_INET, INADDR_ANY, {0}});
seastar::ipv4_addr endpoint;
try {
endpoint = seastar::ipv4_addr(host, port);
} catch (std::exception& e) {
MITHRIL_LOG(fatal) << "Invalid host and port combination";
seastar::engine_exit(std::make_exception_ptr(e));
return;
}
auto socket = seastar::connect(endpoint, local, seastar::transport::TCP);
task = socket.then([this](seastar::connected_socket connection) {
running = true;
return handle_connection(std::move(connection));
}).handle_exception([](std::exception_ptr ep) {
MITHRIL_LOG(info) << "Encountered exception: " << ep;
seastar::engine_exit(ep);
});
}
seastar::future<> handle_connection(seastar::connected_socket socket)
{
channel = std::make_shared<socket_channel>(std::move(socket));
channel->attach_pipeline(std::make_shared<channel_pipeline>());
channel->pipeline()->add_last("init", std::make_shared<T>());
channel->pipeline()->remove("init");
channel->pipeline()->fire_channel_active();
auto fire_disconnect = [this] {
return channel->dispatch_all_tx().then([this] {
return channel->output.close();
}).then([this] {
channel->pipeline()->fire_channel_inactive();
running = false;
seastar::engine_exit();
return seastar::make_ready_future<>();
});
};
return seastar::repeat([this] {
return channel->input.read().then([this](auto buf) {
if (buf) {
channel->pipeline()->fire_channel_read(mithril::create_message(std::move(buf)));
return seastar::make_ready_future<stop_iteration>(stop_iteration::no);
} else {
return seastar::make_ready_future<stop_iteration>(stop_iteration::yes);
}
});
}).then(fire_disconnect).handle_exception([](auto e) {
MITHRIL_LOG(warning) << "Exception event in service on shard: " << seastar::this_shard_id();
MITHRIL_LOG(warning) << e;
});
}
seastar::future<> stop()
{
if (running) {
running = false;
channel->socket().shutdown_input();
channel->socket().shutdown_output();
return task->finally([] {
return seastar::make_ready_future<>();
});
}
return seastar::make_ready_future<>();
}
};
#endif //MITHRIL_INCLUDE_MITHRIL_CLIENT_EVENT_LOOP_SERVICE_HH
| [
"salah.h.sheikh@gmail.com"
] | salah.h.sheikh@gmail.com |
d474b8d1b9cd4a5a515fd7250b2ba5dbaab49ad2 | 481f3c6b713379912988084cf10810e7d9a74fd0 | /components/dom_distiller/core/dom_distiller_features.h | d1e56a3db120e267dfe496fcaeeb37d6b8a14440 | [
"MPL-2.0-no-copyleft-exception",
"LicenseRef-scancode-unknown-license-reference",
"AGPL-3.0-only",
"LGPL-2.1-only",
"GPL-2.0-only",
"MPL-2.0",
"BSD-3-Clause"
] | permissive | huhisoft/huhi-android | bab71148730ff68b770f56b93b731302528045ec | 1c00f05a2ab19f0d6acf42331931de61555a93e8 | refs/heads/master | 2023-01-13T11:26:25.618267 | 2019-11-11T04:09:38 | 2019-11-11T04:09:38 | 219,455,870 | 0 | 4 | BSD-3-Clause | 2022-12-10T08:31:33 | 2019-11-04T08:48:00 | null | UTF-8 | C++ | false | false | 570 | h | // Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_DOM_DISTILLER_CORE_DOM_DISTILLER_FEATURES_H_
#define COMPONENTS_DOM_DISTILLER_CORE_DOM_DISTILLER_FEATURES_H_
namespace dom_distiller {
// Returns true when flag enable-dom-distiller is set or enabled from Finch.
bool IsDomDistillerEnabled();
bool ShouldStartDistillabilityService();
} // namespace dom_distiller
#endif // COMPONENTS_DOM_DISTILLER_CORE_DOM_DISTILLER_FEATURES_H_
| [
"huhibrowser@gmail.com"
] | huhibrowser@gmail.com |
79f64b4d4ca17ea45ccefc1a041a857e7b5502fa | c7f6ecdbd4bb2bdcde8bae0a03c10a102b368e7d | /include/mobilerobot/worldmodel.h | 249f854e1ea619f255af474b9f2f275bee0d711d | [] | no_license | bastikr/mobilerobot | 0edd253bf0e63668a1354ece5d80f7313c845d26 | 8d693bdc87fb69e853c2de117a4b990abe4043c0 | refs/heads/master | 2021-05-07T01:41:48.003135 | 2017-11-11T21:28:57 | 2017-11-11T21:28:57 | 110,381,868 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,143 | h | #ifndef MOBILEROBOT_WORLDMODEL_H_
#define MOBILEROBOT_WORLDMODEL_H_
#include <random>
#include <eigen3/Eigen/Dense>
#include "mobilerobot/control.h"
namespace worldmodel {
// (x, y, v, theta)
using State = Eigen::Vector4d;
using Matrix = Eigen::Matrix4d;
class World {
public:
World(double gamma_v, double gamma_theta, double noise_v, double noise_theta);
worldmodel::State derivative(const worldmodel::State& x, const control::State& u) const;
worldmodel::State step(double dt, State x, const control::State& u) const;
worldmodel::State random_step(double dt, State x, const control::State& u);
double random_dv();
double random_dtheta();
Matrix linearize_taylor(double dt, const worldmodel::State& x, const control::State& u) const;
Matrix noise_covariance() const;
// friction parameters
double gamma_v_;
double gamma_theta_;
// noise parameters
double noise_v_;
double noise_theta_;
private:
std::mt19937 gen_v_;
std::mt19937 gen_theta_;
std::normal_distribution<> gaussian_v_;
std::normal_distribution<> gaussian_theta_;
};
} // namespace worldmodel
#endif // MOBILEROBOT_WORLDMODEL_H_
| [
"basti.kr@gmail.com"
] | basti.kr@gmail.com |
a0d86c4771d6ee4ea04cc362e89225b590bd9a9c | 038eb94f1c726480584abb2b720838aa0814d301 | /clang-tidy/pagesjaunes/test/buffer_split.cpp | 2c41c58eb4d58f38dc5b7c9b353d59c360298cf4 | [
"NCSA"
] | permissive | rcoscali/clang-tools-extra | a9c34a90122490aa9fdd375a2c4d6a000791c14a | 9eb42b18281337e38887496926c2312cf9978e7d | refs/heads/master | 2022-10-22T17:04:41.374647 | 2022-10-11T20:43:59 | 2022-10-11T20:43:59 | 97,316,812 | 0 | 0 | NOASSERTION | 2022-10-11T20:44:00 | 2017-07-15T13:13:33 | HTML | UTF-8 | C++ | false | false | 22,228 | cpp | //===------- buffer_split.cpp - clang-tidy ----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include <iostream>
#include <fstream>
#include <cstdlib>
#include "buffer_split.h"
namespace clang
{
namespace tidy
{
namespace pagesjaunes
{
namespace test
{
const std::string
BufferSplitTest::LLVM_SRC_ROOT_DIR_ENVVAR_NAME = "LLVM_SRC_ROOT_DIR";
const std::string
BufferSplitTest::CLANG_TIDY_TEST_FILE_RELATIVE_PATH = "/tools/clang/tools/extra/clang-tidy/pagesjaunes/test/";
const std::string
BufferSplitTest::CLANG_TIDY_TEST_FILE_NAME = "buffer_split_std.txt";
const std::string
BufferSplitTest::CLANG_TIDY_TEST_BIG_FILE_NAME = "buffer_split_cpp.txt";
const unsigned int
BufferSplitTest::SHA256::sha256_k[64] =
{
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};
BufferSplitTest::BufferSplitTest()
{
m_clang_root_directory = new std::string(std::getenv("LLVM_SRC_ROOT_DIR"));
assert(m_clang_root_directory && !m_clang_root_directory->empty());
}
BufferSplitTest::~BufferSplitTest()
{
delete m_clang_root_directory;
}
void
BufferSplitTest::SetUp(void)
{
if (std::getenv(LLVM_SRC_ROOT_DIR_ENVVAR_NAME.c_str()) == nullptr)
std::cerr << "Error: environment: The LLVM_SRC_ROOT_DIR is not set. Some of these tests need this variable's value for successfully running !\n";
}
void
BufferSplitTest::TearDown(void)
{
}
void
BufferSplitTest::PrintTo(const BufferSplitTest& buffer_split, ::std::ostream* os)
{
}
TEST_F(BufferSplitTest, NominalBufferSplit)
{
std::vector<std::string>::size_type linesnr;
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>("line0\nline1\n"), linesnr);
EXPECT_EQ(linesnr, 2);
if (linesnr == 2)
{
EXPECT_STREQ(linesbuf[0].c_str(), "line0");
EXPECT_STREQ(linesbuf[1].c_str(), "line1");
}
}
TEST_F(BufferSplitTest, NominalBufferSplitStartAt1)
{
std::vector<std::string>::size_type linesnr;
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>("line1\nline2\n"), linesnr, 0, false);
EXPECT_EQ(linesnr, 3);
if (linesnr == 3)
{
EXPECT_STREQ(linesbuf[0].c_str(), "");
EXPECT_STREQ(linesbuf[1].c_str(), "line1");
EXPECT_STREQ(linesbuf[2].c_str(), "line2");
}
}
TEST_F(BufferSplitTest, EmptyBuffer)
{
std::vector<std::string>::size_type linesnr;
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>(""), linesnr);
EXPECT_EQ(linesnr, 0);
}
TEST_F(BufferSplitTest, OneEmptyLineBuffer)
{
std::vector<std::string>::size_type linesnr;
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>("\n"), linesnr);
EXPECT_EQ(linesnr, 1);
if (linesnr == 1)
{
EXPECT_STREQ(linesbuf[0].c_str(), "");
}
}
TEST_F(BufferSplitTest, OneEmptyLineBufferStartAt1)
{
std::vector<std::string>::size_type linesnr;
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>("\n"), linesnr, 0, false);
EXPECT_EQ(linesnr, 2);
if (linesnr == 2)
{
EXPECT_STREQ(linesbuf[0].c_str(), "");
EXPECT_STREQ(linesbuf[1].c_str(), "");
}
}
TEST_F(BufferSplitTest, OneLineWithNoCRBuffer)
{
std::vector<std::string>::size_type linesnr;
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>("line0"), linesnr);
EXPECT_EQ(linesnr, 1);
if (linesnr == 1)
{
EXPECT_STREQ(linesbuf[0].c_str(), "line0");
}
}
TEST_F(BufferSplitTest, OneLineWithNoCRBufferStartAt1)
{
std::vector<std::string>::size_type linesnr;
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>("line0"), linesnr, 0, false);
EXPECT_EQ(linesnr, 2);
if (linesnr == 2)
{
EXPECT_STREQ(linesbuf[0].c_str(), "");
EXPECT_STREQ(linesbuf[1].c_str(), "line0");
}
}
TEST_F(BufferSplitTest, BigBuffers)
{
#include "buffer_split.test.h"
std::vector<std::string>::size_type linesnr;
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>(bigbuf), linesnr, 28630, false);
EXPECT_EQ(linesnr, 28626);
if (linesnr == 28626)
{
EXPECT_STREQ(linesbuf[0].c_str(), "");
EXPECT_STREQ(linesbuf[1].c_str(), "/*-------------------------------Identification-------------------------------*/");
EXPECT_STREQ(linesbuf[28616].c_str(), " doc2->value.a_classer.iNbPart = GIViNbTupleIapart;");
EXPECT_STREQ(linesbuf[28625].c_str(), "}");
}
}
TEST_F(BufferSplitTest, BigBuffersStartAt0)
{
#include "buffer_split.test.h"
std::vector<std::string>::size_type linesnr;
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>(bigbuf), linesnr, 28630, true);
EXPECT_EQ(linesnr, 28625);
if (linesnr == 28625)
{
EXPECT_STREQ(linesbuf[0].c_str(), "/*-------------------------------Identification-------------------------------*/");
EXPECT_STREQ(linesbuf[28615].c_str(), " doc2->value.a_classer.iNbPart = GIViNbTupleIapart;");
EXPECT_STREQ(linesbuf[28624].c_str(), "}");
EXPECT_STREQ(linesbuf[28625].c_str(), NULL);
}
}
TEST_F(BufferSplitTest, BigBuffers2)
{
#include "buffer_split.test2.h"
std::vector<std::string>::size_type linesnr;
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>(bigbuf2), linesnr, 2400, false);
EXPECT_EQ(linesnr, 2399);
if (linesnr == 2399)
{
EXPECT_STREQ(linesbuf[0].c_str(), "");
EXPECT_STREQ(linesbuf[1].c_str(), "Vlan pied le dieu rang nuit tu vite. Prepare charger six faisait oui dut cousine. Tard il gare boue si sent mais. Tot fut dela leur long. La de lasser rachat closes. Ah petites facteur maudite pendant agacent du. Habilement nos assurances age vie consentiez bleuissent vit. ");
EXPECT_STREQ(linesbuf[129].c_str(), "As en celui vieux abris etais bride soirs et. Train eux mur bas car adore arbre voici. Un prudence negation flottent cervelle ah reprises du du. Quarante humaines et je tacherai. Sa me porte outre crete robes senti un du. Ah recupera reparler mourants je he epandent il depeches pourquoi. Poussaient paraissent ah un ce inattendus on. Attardent tu miserable illumines et mystiques superieur. Boulevards eux son executeurs vif simplement eclatantes commandant caracolent. Ma rythme disant courbe se reunir polies un parler. ");
EXPECT_STREQ(linesbuf[2398].c_str(), "Ebloui brunes ere voulez des centre polies lorsqu. Ere fit eclatantes une decharnees pic habilement renferment. Et en ma plutot je admire pareil mutuel voyons. Mon defiance appareil peu reposoir dimanche moi mal galopent. Hors dur tous peu avis ses venu. Mal geste jeune des sapin ces dut. Son titres peuple manque veilla mur. ");
}
}
TEST_F(BufferSplitTest, BigBuffers2StartAt0)
{
#include "buffer_split.test2.h"
std::vector<std::string>::size_type linesnr;
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>(bigbuf2), linesnr, 2400, true);
EXPECT_EQ(linesnr, 2398);
if (linesnr == 2398)
{
EXPECT_STREQ(linesbuf[0].c_str(), "Vlan pied le dieu rang nuit tu vite. Prepare charger six faisait oui dut cousine. Tard il gare boue si sent mais. Tot fut dela leur long. La de lasser rachat closes. Ah petites facteur maudite pendant agacent du. Habilement nos assurances age vie consentiez bleuissent vit. ");
EXPECT_STREQ(linesbuf[128].c_str(), "As en celui vieux abris etais bride soirs et. Train eux mur bas car adore arbre voici. Un prudence negation flottent cervelle ah reprises du du. Quarante humaines et je tacherai. Sa me porte outre crete robes senti un du. Ah recupera reparler mourants je he epandent il depeches pourquoi. Poussaient paraissent ah un ce inattendus on. Attardent tu miserable illumines et mystiques superieur. Boulevards eux son executeurs vif simplement eclatantes commandant caracolent. Ma rythme disant courbe se reunir polies un parler. ");
EXPECT_STREQ(linesbuf[2397].c_str(), "Ebloui brunes ere voulez des centre polies lorsqu. Ere fit eclatantes une decharnees pic habilement renferment. Et en ma plutot je admire pareil mutuel voyons. Mon defiance appareil peu reposoir dimanche moi mal galopent. Hors dur tous peu avis ses venu. Mal geste jeune des sapin ces dut. Son titres peuple manque veilla mur. ");
}
}
TEST_F(BufferSplitTest, ReadWriteSplittedBuffer)
{
if (std::getenv(LLVM_SRC_ROOT_DIR_ENVVAR_NAME.c_str()) == nullptr)
{
EXPECT_TRUE(false);
}
else
{
std::string pathname(m_clang_root_directory->c_str());
pathname.append("/");
pathname.append(CLANG_TIDY_TEST_FILE_RELATIVE_PATH);
pathname.append(CLANG_TIDY_TEST_FILE_NAME);
std::string pathname_dst("/tmp/");
pathname_dst.append(CLANG_TIDY_TEST_FILE_NAME);
pathname_dst.append(".copy");
std::size_t filesize;
const char *buffer = clang::tidy::pagesjaunes::readTextFile(pathname.c_str(), filesize);
std::vector<std::string>::size_type linesnr;
// Evaluate number of lines with file length divied by 4 (just a guess)
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>(buffer), linesnr, filesize/4, true);
EXPECT_EQ(linesnr, 8);
if (linesnr == 8)
{
EXPECT_STREQ(linesbuf[0].c_str(), "this is a test file");
EXPECT_STREQ(linesbuf[1].c_str(), "that is not too big");
EXPECT_STREQ(linesbuf[2].c_str(), "only a few lines");
EXPECT_STREQ(linesbuf[3].c_str(), "of standard text");
EXPECT_STREQ(linesbuf[4].c_str(), "le texte contient aussi");
EXPECT_STREQ(linesbuf[5].c_str(), "quelques caractères accentués");
EXPECT_STREQ(linesbuf[6].c_str(), "qui sont codés sur deux octets.");
// This is not a line returned (linesnr == 8) hence shall be empty
EXPECT_STREQ(linesbuf[7].c_str(), "");
std::ofstream dst(pathname_dst, std::ios::out | std::ios::trunc | std::ios::binary);
if (dst.is_open())
{
unsigned int nwlines = 0;
for (auto lbit = linesbuf.begin(); lbit != linesbuf.end() && nwlines < linesnr; ++lbit, ++nwlines)
if (nwlines < linesnr)
{
std::string line = *lbit;
dst.write(line.c_str(), line.length());
dst.write("\n", 1);
}
}
dst.close();
std::size_t filesize_src;
const char *buffer_src = clang::tidy::pagesjaunes::readTextFile(pathname.c_str(), filesize_src);
std::string buf_src(buffer_src);
delete buffer_src;
std::size_t filesize_copy;
const char *buffer_copy = clang::tidy::pagesjaunes::readTextFile(pathname_dst.c_str(), filesize_copy);
std::string buf_copy(buffer_copy);
delete buffer_copy;
EXPECT_TRUE(sha256cmp(buf_src, buf_copy) == 0);
}
}
}
TEST_F(BufferSplitTest, ReadWriteSplittedBufferStartAt1)
{
if (std::getenv(LLVM_SRC_ROOT_DIR_ENVVAR_NAME.c_str()) == nullptr)
{
EXPECT_TRUE(false);
}
else
{
std::string pathname(m_clang_root_directory->c_str());
pathname.append("/");
pathname.append(CLANG_TIDY_TEST_FILE_RELATIVE_PATH);
pathname.append(CLANG_TIDY_TEST_FILE_NAME);
std::string pathname_dst("/tmp/");
pathname_dst.append(CLANG_TIDY_TEST_FILE_NAME);
pathname_dst.append(".copy");
std::size_t filesize;
const char *buffer = clang::tidy::pagesjaunes::readTextFile(pathname.c_str(), filesize);
std::vector<std::string>::size_type linesnr;
// Evaluate number of lines with file length divied by 4
std::vector<std::string> linesbuf = bufferSplit(const_cast<char *>(buffer), linesnr, filesize/4, false);
EXPECT_EQ(linesnr, 9);
if (linesnr == 9)
{
EXPECT_STREQ(linesbuf[0].c_str(), "");
EXPECT_STREQ(linesbuf[1].c_str(), "this is a test file");
EXPECT_STREQ(linesbuf[2].c_str(), "that is not too big");
EXPECT_STREQ(linesbuf[3].c_str(), "only a few lines");
EXPECT_STREQ(linesbuf[4].c_str(), "of standard text");
EXPECT_STREQ(linesbuf[5].c_str(), "le texte contient aussi");
EXPECT_STREQ(linesbuf[6].c_str(), "quelques caractères accentués");
EXPECT_STREQ(linesbuf[7].c_str(), "qui sont codés sur deux octets.");
// This is not a line returned (linesnr == 8) hence shall be empty
EXPECT_STREQ(linesbuf[8].c_str(), "");
std::ofstream dst(pathname_dst, std::ios::out | std::ios::trunc | std::ios::binary);
if (dst.is_open())
{
unsigned int nwlines = 0;
for (auto lbit = linesbuf.begin(); lbit != linesbuf.end() && nwlines < linesnr; ++lbit, ++nwlines)
if (nwlines > 0 && nwlines <= linesnr)
{
std::string line = *lbit;
dst.write(line.c_str(), line.length());
dst.write("\n", 1);
}
}
dst.close();
std::size_t filesize_src;
const char *buffer_src = clang::tidy::pagesjaunes::readTextFile(pathname.c_str(), filesize_src);
std::string buf_src(buffer_src);
delete buffer_src;
std::size_t filesize_copy;
const char *buffer_copy = clang::tidy::pagesjaunes::readTextFile(pathname_dst.c_str(), filesize_copy);
std::string buf_copy(buffer_copy);
delete buffer_copy;
EXPECT_TRUE(sha256cmp(buf_src, buf_copy) == 0);
}
}
}
void
BufferSplitTest::SHA256::transform(const unsigned char *message, unsigned int block_nb)
{
uint32 w[64];
uint32 wv[8];
uint32 t1, t2;
const unsigned char *sub_block;
int i;
int j;
for (i = 0; i < (int) block_nb; i++) {
sub_block = message + (i << 6);
for (j = 0; j < 16; j++) {
SHA2_PACK32(&sub_block[j << 2], &w[j]);
}
for (j = 16; j < 64; j++) {
w[j] = SHA256_F4(w[j - 2]) + w[j - 7] + SHA256_F3(w[j - 15]) + w[j - 16];
}
for (j = 0; j < 8; j++) {
wv[j] = m_h[j];
}
for (j = 0; j < 64; j++) {
t1 = wv[7] + SHA256_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6])
+ sha256_k[j] + w[j];
t2 = SHA256_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]);
wv[7] = wv[6];
wv[6] = wv[5];
wv[5] = wv[4];
wv[4] = wv[3] + t1;
wv[3] = wv[2];
wv[2] = wv[1];
wv[1] = wv[0];
wv[0] = t1 + t2;
}
for (j = 0; j < 8; j++) {
m_h[j] += wv[j];
}
}
}
void
BufferSplitTest::SHA256::init()
{
m_h[0] = 0x6a09e667;
m_h[1] = 0xbb67ae85;
m_h[2] = 0x3c6ef372;
m_h[3] = 0xa54ff53a;
m_h[4] = 0x510e527f;
m_h[5] = 0x9b05688c;
m_h[6] = 0x1f83d9ab;
m_h[7] = 0x5be0cd19;
m_len = 0;
m_tot_len = 0;
}
void
BufferSplitTest::SHA256::update(const unsigned char *message, unsigned int len)
{
unsigned int block_nb;
unsigned int new_len, rem_len, tmp_len;
const unsigned char *shifted_message;
tmp_len = BufferSplitTest::SHA256::SHA224_256_BLOCK_SIZE - m_len;
rem_len = len < tmp_len ? len : tmp_len;
memcpy(&m_block[m_len], message, rem_len);
if (m_len + len < BufferSplitTest::SHA256::SHA224_256_BLOCK_SIZE) {
m_len += len;
return;
}
new_len = len - rem_len;
block_nb = new_len / BufferSplitTest::SHA256::SHA224_256_BLOCK_SIZE;
shifted_message = message + rem_len;
transform(m_block, 1);
transform(shifted_message, block_nb);
rem_len = new_len % BufferSplitTest::SHA256::SHA224_256_BLOCK_SIZE;
memcpy(m_block, &shifted_message[block_nb << 6], rem_len);
m_len = rem_len;
m_tot_len += (block_nb + 1) << 6;
}
void
BufferSplitTest::SHA256::final(unsigned char *digest)
{
unsigned int block_nb;
unsigned int pm_len;
unsigned int len_b;
int i;
block_nb = (1 + ((BufferSplitTest::SHA256::SHA224_256_BLOCK_SIZE - 9)
< (m_len % BufferSplitTest::SHA256::SHA224_256_BLOCK_SIZE)));
len_b = (m_tot_len + m_len) << 3;
pm_len = block_nb << 6;
memset(m_block + m_len, 0, pm_len - m_len);
m_block[m_len] = 0x80;
SHA2_UNPACK32(len_b, m_block + pm_len - 4);
transform(m_block, block_nb);
for (i = 0 ; i < 8; i++)
SHA2_UNPACK32(m_h[i], &digest[i << 2]);
}
std::string
BufferSplitTest::sha256(const std::string& input)
{
unsigned char digest[BufferSplitTest::SHA256::DIGEST_SIZE];
memset(digest, 0, BufferSplitTest::SHA256::DIGEST_SIZE);
BufferSplitTest::SHA256 ctx = BufferSplitTest::SHA256();
ctx.init();
ctx.update(reinterpret_cast<const unsigned char *>(input.c_str()), input.length());
ctx.final(digest);
char buf[2 * BufferSplitTest::SHA256::DIGEST_SIZE+1];
buf[2 * BufferSplitTest::SHA256::DIGEST_SIZE] = 0;
for (unsigned int i = 0; i < BufferSplitTest::SHA256::DIGEST_SIZE; i++)
sprintf(buf+i*2, "%02x", digest[i]);
return std::string(buf);
}
std::string
BufferSplitTest::sha256(std::ifstream& is)
{
std::streambuf *pbuf = is.rdbuf();
std::streamsize filelen = pbuf->pubseekoff(0, is.end);
pbuf->pubseekoff(0, is.beg);
char *buffer = new char[filelen];
pbuf->sgetn(buffer, filelen);
std::string stringbuf(buffer);
delete buffer;
return sha256(stringbuf);
}
int
BufferSplitTest::sha256cmp(const std::string& s1, const std::string& s2)
{
std::string sha256s1 = BufferSplitTest::sha256(s1);
std::string sha256s2 = BufferSplitTest::sha256(s2);
return sha256s1.compare(sha256s2);
}
int
BufferSplitTest::sha256cmp(std::ifstream& is1, std::ifstream& is2)
{
std::string sha256s1 = BufferSplitTest::sha256(is1);
std::string sha256s2 = BufferSplitTest::sha256(is2);
return sha256s1.compare(sha256s2);
}
} // ! namespace test
} // ! namespace pagesjaunes
} // ! namespace tidy
} // ! namespace clang
| [
"remi@jayacode.fr"
] | remi@jayacode.fr |
51529cf2658605ac4f1884c417c77e624b345e1b | fcc777b709d795c4116bad5415439e9faa532d39 | /rongyu/homework1/file/2018152010_1182_正确_455.cpp | af39f35909fcefad3f94e411f2431a9f833a7155 | [] | no_license | demonsheart/C- | 1dcaa2128ec8b20e047ae55dd33f66a359097910 | f567b8ca4a4d3ccdf6d59e9fae5b5cea27ec85c1 | refs/heads/master | 2022-11-29T00:27:30.604843 | 2020-08-10T11:48:36 | 2020-08-10T11:48:36 | 283,923,861 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 586 | cpp | #include <iostream>
char *strAdd(char *s1, char *s2);
using namespace std;
int main()
{
int t;
char ch1[100],ch2[100],*res;
cin>>t;
cin.ignore(2,'\n');
while(t--)
{
cin>>ch1>>ch2;
res=strAdd(ch1,ch2);
cout<<ch1<<' '<<ch2<<' '<<res<<endl;
}
return 0;
}
char *strAdd(char *s1, char *s2)
{
char *s3=new char[200];
int z=0,i;
for(i=0;*(s1+i)!='\0';i++)
{
*(s3+z)=*(s1+i);
z++;
}
for(i=0;*(s2+i)!='\0';i++)
{
*(s3+z)=*(s2+i);
z++;
}
*(s3+z)='\0';
return s3;
}
| [
"2509875617@qq.com"
] | 2509875617@qq.com |
b694e4f7a5385e42c02e6e4fa3dcf127b34db081 | 6626a38d8d777f1aa1cc1add43056116bb26433a | /UI2016/UI/UISDK/Src/Layer/software_layer.h | 8166b169d9ce33a1982b7339b011039ffa5abba1 | [] | no_license | cnsuhao/dragon | 8fa65a114e4aba819e6a2c0376cbdb791157970a | 833baa77d234825abceeed33569be7b5c9d41720 | refs/heads/master | 2021-06-23T14:18:00.257518 | 2016-11-24T14:33:15 | 2016-11-24T14:33:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 271 | h | #pragma once
#include "layer.h"
namespace UI
{
class SoftwareLayer : public Layer
{
public:
SoftwareLayer();
~SoftwareLayer();
virtual LayerType GetType() override { return Layer_Software; }
virtual void UpdateDirty() override;
};
} | [
"leeihcy@49fff2ea-6ae5-4519-8002-a5cf5e333bda"
] | leeihcy@49fff2ea-6ae5-4519-8002-a5cf5e333bda |
24489f22d6f2376299752a18ad73f4ee738776e9 | 0ab6de17a742af2d6e3aff133d9c206f07947849 | /imengine/models/DeltaFunction.cc | f0023fee4377e4a3618db11fab8915bd256454da | [] | no_license | lmoustakas/imengine | 4eba857a1d18036767514a3c2351533919286b9a | 0c761b2f32bc16d10204dc892b3ad1d3606130f6 | refs/heads/master | 2021-01-18T07:51:26.675595 | 2012-01-21T00:49:05 | 2012-01-21T00:49:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 669 | cc | // Created 17-Feb-2011 by David Kirkby (University of California, Irvine) <dkirkby@uci.edu>
#include "imengine/models/DeltaFunction.h"
#include "imengine/TransformData.h"
namespace local = imengine::models;
local::DeltaFunction::DeltaFunction() { }
local::DeltaFunction::~DeltaFunction() { }
void local::DeltaFunction::doTransform(boost::shared_ptr<TransformData> transformData) {
transformData->tabulate(&local::DeltaFunction::setValueToOne);
}
double local::DeltaFunction::operator()(double x, double y) const {
return 0;
}
void local::DeltaFunction::setValueToOne(double kx, double ky, imengine::Complex& value) {
value[0] = 1;
value[1] = 0;
} | [
"dkirkby@uci.edu"
] | dkirkby@uci.edu |
8b0b418cd63c8525a6aa38966b4110dda1c02173 | 8cbea8a4165b61156ad593e9fa3052aa7d8cb761 | /Sources/Extras/CoreMediaIO/DeviceAbstractionLayer/Devices/Sample/PlugIn/CMIO_DP_Sample_PlugIn.cpp | 109d1e4c1c33e0acae191eb61cb9674dc2c496c7 | [
"MIT"
] | permissive | lvsti/CoreMediaIO-DAL-Example | 87981cccb323462b85239f13d490b945eda0b11b | 742ccb114735245bf3bc7f5a29d381526b82b720 | refs/heads/master | 2022-06-29T18:54:10.078279 | 2022-06-19T20:55:54 | 2022-06-19T20:55:54 | 159,476,900 | 187 | 31 | null | 2020-04-10T19:09:07 | 2018-11-28T09:31:24 | C++ | UTF-8 | C++ | false | false | 21,493 | cpp | /*
File: CMIO_DP_Sample_PlugIn.cpp
Abstract: n/a
Version: 1.2
*/
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Includes
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Self Include
#include "CMIO_DP_Sample_PlugIn.h"
// Internal Includes
#include "CMIO_DP_Sample_IOBackedDevice.h"
#include "CMIO_DP_Sample_VirtualDevice.h"
// DAL PlugIn Base Includes
#include "CMIO_DP_DeviceSettings.h"
// Public Utility Includes
#include "CMIODebugMacros.h"
#include "CMIO_DALA_System.h"
#include "CMIO_PropertyAddress.h"
// CA Public Utility Includes
#include "CAAutoDisposer.h"
#include "CAException.h"
#include "CACFString.h"
#include "CAHostTimeBase.h"
// System Includes
#include <IOKit/IOMessage.h>
#include <servers/bootstrap.h>
namespace CMIO { namespace DP { namespace Sample
{
#pragma mark -
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// PlugIn()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
PlugIn::PlugIn(CFUUIDRef factoryUUID, const char* assistantServiceName) :
DP::PlugIn(factoryUUID),
mAssistantPort(),
mDeviceEventPort(NULL),
mDeviceEventDispatchSource(NULL),
mAssistantCrashAnchorTime(CAHostTimeBase::GetCurrentTimeInNanos()),
mAssistantCrashCount(0)
{
mAssistantServiceName = new char[strlen(assistantServiceName) + 1];
strcpy(mAssistantServiceName, assistantServiceName);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// ~PlugIn()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
PlugIn::~PlugIn()
{
// Cancel the dispatch source for the device event notifications
if (NULL != mDeviceEventDispatchSource)
{
dispatch_source_cancel(mDeviceEventDispatchSource);
dispatch_release(mDeviceEventDispatchSource);
mDeviceEventDispatchSource = NULL;
}
delete[] mAssistantServiceName;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Initialize()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void PlugIn::InitializeWithObjectID(CMIOObjectID objectID)
{
// Grab the muxtex for the plugIn's state.
CAMutex::Locker locker(GetStateMutex());
// Initialize the super class
DP::PlugIn::InitializeWithObjectID(objectID);
// Set the object state mutex
Object::SetObjectStateMutexForID(objectID, GetObjectStateMutex());
// Create the Mach port for device event notifications
mDeviceEventPort = new CACFMachPort(reinterpret_cast<CFMachPortCallBack>(DeviceEvent), this);
// Create a dispatch source that listens to the device event port
mDeviceEventDispatchSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_MACH_RECV, mDeviceEventPort->GetMachPort(), 0, dispatch_get_main_queue());
if (NULL == mDeviceEventDispatchSource)
{
// Delete the device event port (since normally that would be handled by the the dispatch source's cancel handler)
delete mDeviceEventPort;
mDeviceEventPort = NULL;
DebugMessage("CMIO::DP::Sample::PlugIn::InitializeWithObjectID: failed to create the mach port event source");
throw CAException(kCMIOHardwareUnspecifiedError);
}
// Install an event handler
dispatch_source_set_event_handler(mDeviceEventDispatchSource, ^{ DeviceEvent(*this); });
// Note that the mach port cannot be freed prior to the the cancel handler running due to a race condition. See the note in the comments dispatch_source_set_cancel_handler in <dispatch/source.h>.
dispatch_source_set_cancel_handler(mDeviceEventDispatchSource, ^{ delete mDeviceEventPort; mDeviceEventPort = NULL; });
// Resume the event source so that it can start handling messages and also so that the source can be released
dispatch_resume(mDeviceEventDispatchSource);
// Get the Mach port on which messages will be sent to the SampleAssistant
mAssistantPort.Reset(DPA::Sample::GetPort(mAssistantServiceName));
// Get the state of all the devices currently connected
UpdateDeviceStates();
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Teardown()
// This is invoked when the DAL is torn down by CMIOHardwareUnload(). If the process quits or crashes, the DAL just vanishes.
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void PlugIn::Teardown()
{
// Grab the muxtex for the plugIn's state
CAMutex::Locker locker(GetStateMutex());
// Cancel the dispatch source for the device event notifications
if (NULL != mDeviceEventDispatchSource)
{
dispatch_source_cancel(mDeviceEventDispatchSource);
dispatch_release(mDeviceEventDispatchSource);
mDeviceEventDispatchSource = NULL;
}
// Do the full teardown if this is outside of the process being torn down or this is the master process
if (not DALA::System::IsInitingOrExiting() or DALA::System::IsMaster())
{
// Teardown all the devices currently being managed
while (0 != GetNumberDevices())
DeviceRemoved(*static_cast<Device*>(GetDeviceByIndex(0)));
// Teardown the super class
DP::PlugIn::Teardown();
}
else
{
// Iterate over the devices and suspend and finalize them
for (UInt32 i = 0 ; i < GetNumberDevices() ; ++i)
{
Device* device = static_cast<Device*>(GetDeviceByIndex(i));
// Suspend the device
device->Unplug();
// Finalize (rather than teardown) the device
device->Finalize();
}
// Teardown the super class
DP::PlugIn::Teardown();
// And leave the rest to die with the process...
}
}
#pragma mark -
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// HasProperty()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
bool PlugIn::HasProperty(const CMIOObjectPropertyAddress& address) const
{
// Initialize the return value
bool answer = false;
switch (address.mSelector)
{
case kCMIOObjectPropertyName:
answer = true;
break;
default:
answer = DP::PlugIn::HasProperty(address);
break;
};
return answer;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// IsPropertySettable()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
bool PlugIn::IsPropertySettable(const CMIOObjectPropertyAddress& address) const
{
bool answer = false;
switch (address.mSelector)
{
case kCMIOObjectPropertyName:
answer = false;
break;
default:
answer = DP::PlugIn::IsPropertySettable(address);
break;
};
return answer;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// GetPropertyDataSize()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
UInt32 PlugIn::GetPropertyDataSize(const CMIOObjectPropertyAddress& address, UInt32 qualifierDataSize, const void* qualifierData) const
{
UInt32 answer = 0;
switch (address.mSelector)
{
case kCMIOObjectPropertyName:
answer = sizeof(CFStringRef);
break;
default:
answer = DP::PlugIn::GetPropertyDataSize(address, qualifierDataSize, qualifierData);
break;
};
return answer;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// GetPropertyData()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void PlugIn::GetPropertyData(const CMIOObjectPropertyAddress& address, UInt32 qualifierDataSize, const void* qualifierData, UInt32 dataSize, UInt32& dataUsed, void* data) const
{
switch (address.mSelector)
{
case kCMIOObjectPropertyName:
ThrowIf(dataSize != GetPropertyDataSize(address, qualifierDataSize, qualifierData), CAException(kCMIOHardwareBadPropertySizeError), "CMIO::DP::Sample::PlugIn::GetPropertyData: wrong data size for kCMIOObjectPropertyName");
*static_cast<CFStringRef*>(data) = CFSTR("com.apple.cmio.DAL.Sample");
CFRetain(*static_cast<CFStringRef*>(data));
dataUsed = sizeof(CFStringRef);
break;
default:
DP::PlugIn::GetPropertyData(address, qualifierDataSize, qualifierData, dataSize, dataUsed, data);
break;
};
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// SetPropertyData()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void PlugIn::SetPropertyData(const CMIOObjectPropertyAddress& address, UInt32 qualifierDataSize, const void* qualifierData, UInt32 dataSize, const void* data)
{
switch (address.mSelector)
{
default:
DP::PlugIn::SetPropertyData(address, qualifierDataSize, qualifierData, dataSize, data);
break;
};
}
#pragma mark -
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// GetDeviceByGUID()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Device& PlugIn::GetDeviceByGUID(UInt64 guid) const
{
Device* device = 0;
bool found = false;
// Iterate over the plugIn's devices and find the one whose guid matches
for (UInt32 i = 0 ; i < GetNumberDevices() ; ++i)
{
device = static_cast<Device*>(GetDeviceByIndex(i));
ThrowIfNULL(device, CAException(kCMIOHardwareBadDeviceError), "CMIO::DP::Sample::PlugIn::GetDeviceByGUID: no device for index");
if (guid == device->GetDeviceGUID())
{
found = true;
break;
}
}
// Make sure that a device was actually found
if (not found)
throw CAException(kCMIOHardwareBadDeviceError);
return *device;
}
#pragma mark -
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// DeviceEvent()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void PlugIn::DeviceEvent(PlugIn& plugIn)
{
// Don't let any exceptions leave this callback
try
{
// The port used to field notifications has a message, so have to pull it off the queue
struct Message
{
DPA::Sample::DeviceStatesChangedMessage mMessage;
mach_msg_trailer_t mTrailer;
};
Message message;
kern_return_t err = plugIn.mDeviceEventPort->ReceiveMessage(sizeof(Message), &message.mMessage.mHeader, 1000);
if (noErr != err)
{
// Something went wrong trying to receive the message
DebugMessageIfError(err, "CMIO::DP::Sample::PlugIn::DeviceEvent: failed to receive the message");
if (MACH_RCV_TIMED_OUT == err)
{
// If the message timed out, simply try and update the devices state again
message.mMessage.mHeader.msgh_id = DPA::Sample::kDeviceStatesChanged;
}
else
{
// Something else went wrong, so act as if the 'case 71' had occurred and re-establish the connection with the Assistant
message.mMessage.mHeader.msgh_id = 71;
}
}
// Grab the mutex for the plugIn's state
CAMutex::Locker locker(plugIn.GetStateMutex());
switch (message.mMessage.mHeader.msgh_id)
{
case DPA::Sample::kDeviceStatesChanged:
{
// Update the state of the of the devices
plugIn.UpdateDeviceStates();
}
break;
case 71:
{
// Though not extensively documented, this is the message ID sent from a MIG server that held a 'send-once right' to a message port but died without ever having exercised
// that right. The plugIn had given the Assistant a 'send-once' right when it had called DPA::Sample::GetDeviceStates(), so getting this message indicates the Assistant
// has crashed.
// Remove all the devices currently being managed
while (0 != plugIn.GetNumberDevices())
plugIn.DeviceRemoved(*static_cast<Device*>(plugIn.GetDeviceByIndex(0)));
// Attempt to re-establish the connection with the Assistant if it hasn't crashed more than 5 times in the last minute. If that threshhold is exceeded, no reconnection
// attempt will be made so all attempts to communicate with it will fail until the application using this plugIn is relaunched.
UInt64 now = CAHostTimeBase::GetCurrentTimeInNanos();
if (now - plugIn.mAssistantCrashAnchorTime > 60000000000ULL or plugIn.mAssistantCrashCount < 5)
{
DebugMessage("CMIO::DP::Sample::PlugIn::DeviceEvent: The Assistant has crashed...respawning it");
// Reset mAssistantCrashAnchorTime to now and reset the crash count to 0 if more than 1 minute has passed since the last time a crash was anchored
if (now - plugIn.mAssistantCrashAnchorTime > 60000000000ULL)
{
plugIn.mAssistantCrashAnchorTime = now;
plugIn.mAssistantCrashCount = 0;
}
// Bump the crash count
++plugIn.mAssistantCrashCount;
// Get the Mach port on which messages will be sent to the SampleAssistant
plugIn.mAssistantPort.Reset(DPA::Sample::GetPort(plugIn.mAssistantServiceName));
// Get the state of all the devices currently connected
plugIn.UpdateDeviceStates();
}
else
{
DebugMessage("CMIO::DP::Sample::PlugIn::DeviceEvent: The Assistant has crashed...not respawning since it has crashed to much");
}
}
break;
}
}
catch (...)
{
}
}
#pragma mark -
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// UpdateDeviceStates()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void PlugIn::UpdateDeviceStates()
{
// Get the current state of all the devices plugged in from the SampleAssistant
DPA::Sample::AutoFreeUnboundedArray<DPA::Sample::DeviceState> deviceStates;
DPA::Sample::GetDeviceStates(mAssistantPort, mDeviceEventPort->GetMachPort(), deviceStates);
// Determine how many devices have been removed (if any).
// This will be done by iterating over all the devices the PlugIn knows about and making sure they are present in the deviceStates array
{
std::vector<Device*> removedDevices;
for (UInt32 i = 0 ; i < GetNumberDevices() ; ++i)
{
Device* device = static_cast<Device*>(GetDeviceByIndex(i));
bool found = false;
// See if it can be located in the deviceStates array
for (UInt32 ii = 0; ii < deviceStates.GetLength() ; ++ii)
{
if (deviceStates[ii].mGUID == device->GetDeviceGUID())
{
found = true;
break;
}
}
// If the device was not found, stick into the vector of unplugged devices
if (not found)
removedDevices.push_back(device);
}
// Remove all the unplugged devices
for (std::vector<Device*>::iterator i = removedDevices.begin() ; i != removedDevices.end() ; ++i)
DeviceRemoved(**i);
}
// Determine how many new devices are present
{
for (UInt32 i = 0; i < deviceStates.GetLength() ; ++i)
{
try
{
// This will throw an exception if the device is not found
(void) GetDeviceByGUID(deviceStates[i].mGUID);
}
catch (...)
{
// No device was found with the indicated GUID, so it is a new device
DeviceArrived(deviceStates[i].mGUID, deviceStates[i].mRegistryPath, deviceStates[i].mIsIOBacked);
}
}
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// DeviceArrived()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void PlugIn::DeviceArrived(UInt64 guid, const io_string_t& registryPath, Boolean isIOBacked)
{
try
{
// Instantiate a new CMIODevice object in the DAL
CMIODeviceID deviceID = 0;
OSStatus err = CMIOObjectCreate(GetInterface(), kCMIOObjectSystemObject, kCMIODeviceClassID, &deviceID);
ThrowIfError(err, CAException(err), "CMIO::DP::Sample::PlugIn::DeviceArrived: couldn't instantiate the CMIODevice object");
// Make a device object
Device* device = nullptr;
if (isIOBacked) {
device = new IOBackedDevice(*this, deviceID, mAssistantPort, guid, registryPath);
}
else {
device = new VirtualDevice(*this, deviceID, mAssistantPort, guid);
}
try
{
// Initialize the device
device->Initialize();
// Restore its settings if necessary
if (DALA::System::IsMaster())
{
DP::DeviceSettings::RestoreFromPrefs(*device, DP::DeviceSettings::sStandardControlsToSave, DP::DeviceSettings::kStandardNumberControlsToSave);
}
// Set the object state mutex
Object::SetObjectStateMutexForID(deviceID, device->GetObjectStateMutex());
// Add it to the device list
AddDevice(*device);
// Unlock the mutex since CMIOObjectsPublishedAndDied() can callout to property listeners
CAMutex::Unlocker unlocker(GetStateMutex());
// Tell the DAL about the device
err = CMIOObjectsPublishedAndDied(GetInterface(), kCMIOObjectSystemObject, 1, &deviceID, 0, 0);
ThrowIfError(err, err, "CMIO::DP::Sample::PlugIn::DeviceArrived: couldn't tell the DAL about a new device");
}
catch (...)
{
// Remove it from the device list (which is always safe to attempt) and delete it
RemoveDevice(*device);
delete device;
}
}
catch (...)
{
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// DeviceRemoved()
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
void PlugIn::DeviceRemoved(Device& device)
{
// Suspend the device
device.Unplug();
// Save it's settings if necessary
if (DALA::System::IsMaster())
DP::DeviceSettings::SaveToPrefs(device, DP::DeviceSettings::sStandardControlsToSave, DP::DeviceSettings::kStandardNumberControlsToSave);
{
// Unlock the mutex since CMIOObjectsPublishedAndDied() can callout to property listeners
CAMutex::Unlocker unlocker(GetStateMutex());
// Tell the DAL that the device has gone away
CMIOObjectID objectID = device.GetObjectID();
OSStatus err = CMIOObjectsPublishedAndDied(GetInterface(), kCMIOObjectSystemObject, 0, 0, 1, &objectID);
AssertNoError(err, "CMIO::DP::Sample::PlugIn::Teardown: got an error telling the DAL a device died");
}
// Remove it from the device list
RemoveDevice(device);
// Get rid of the device object
device.Teardown();
delete &device;
}
}}}
| [
"elveestei@gmail.com"
] | elveestei@gmail.com |
3521767eb36b7d0c86e93381870fc8fe3f798b3b | 811b313aa5d8093ba538a5b285780a39778e0a3a | /Hashing/Chaining.cpp | 22d9f1fbd63cf1ad5c3bb926b3f69d4efd99c6c7 | [] | no_license | Shaheer-Imam/Data-Structures-in-C- | c0810990dd4ae8a5c617c6d58a970604479a8bef | de34f637128dcf4869b0cf042971ccc1942c1792 | refs/heads/master | 2021-11-23T14:23:43.903247 | 2021-11-07T17:56:05 | 2021-11-07T17:56:05 | 172,900,809 | 6 | 1 | null | 2021-11-07T17:56:06 | 2019-02-27T11:13:06 | C++ | UTF-8 | C++ | false | false | 2,131 | cpp | #include <iostream>
#include <math.h>
using namespace std;
struct Node{
int data;
struct Node *next;
} * head[100], *curr;
void init(){
for (int i = 0; i < 100; i++)
head[i] = NULL;
}
void add(int x, int h){
struct Node *temp = new Node;
temp->data = x;
temp->next = NULL;
if (!head[h]){
head[h] = temp;
curr = head[h];
}
else{
curr = head[h];
while (curr->next)
curr = curr->next;
curr->next = temp;
}
}
void display(int mod){
struct Node *temp;
int i;
for (i = 0; i < mod; i++){
if (!head[i]){
cout << "Key " << i << " is empty" << endl;
}
else{
cout << "Key " << i << " has values = ";
temp = head[i];
while (temp->next){
cout << temp->data << " ";
temp = temp->next;
}
cout << temp->data;
cout << endl;
}
}
}
int hash(int x, int mod){
return x % mod;
}
void find(int x, int h){
struct Node *temp = head[h];
if (!head[h]){
cout << "Element not found";
return;
}
while (temp->data != x && temp->next)
temp = temp->next;
if (temp->next)
cout << "Element found";
else{
if (temp->data == x)
cout << "Element found";
else
cout << "Element not found";
}
}
int main(){
init();
int c, x, mod, h;
cout << "Enter the size of Hash Table. = ";
cin >> mod;
bool loop = true;
while (loop){
cout << endl;
cout << "PLEASE CHOOSE -" << endl;
cout << "1. Add element." << endl;
cout << "2. Find element." << endl;
cout << "3. Generate Hash." << endl;
cout << "4. Display Hash table." << endl;
cout << "5. Exit." << endl;
cin >> c;
switch (c){
case 1:
cout << "Enter element to add = ";
cin >> x;
h = hash(x, mod);
h = fabs(h);
add(x, h);
break;
case 2:
cout << "Enter element to search = ";
cin >> x;
h = hash(x, mod);
find(x, h);
break;
case 3:
cout << "Enter element to generate hash = ";
cin >> x;
cout << "Hash of " << x << " is = " << hash(x, mod);
break;
case 4:
display(mod);
break;
default:
loop = false;
break;
}
cout << endl;
}
add(1,&head1);
add(2,&head1);
add(3,&head2);
add(5,&head1);
display(&head1);
display(&head2);
return 0;
}
| [
"noreply@github.com"
] | Shaheer-Imam.noreply@github.com |
6c2c6c9767de641a212d8cc3962c015e532ab790 | 5430b94b129655688575ff2166327415e6dc7817 | /include/TTdrSiLi.h | 1057680fe5b5b0fc27bc8717d9e7ffcf8456cb0f | [] | no_license | UoG-Nuclear-Physics-Group/iThembaData | 9ad4aa8e855cd56bd29e9169b8662f12f61dc4f2 | 4bc44ff9368b5e49d3b5fd0cd2ad8bb659c407ee | refs/heads/main | 2022-07-09T03:46:49.562957 | 2022-06-20T17:17:05 | 2022-06-20T17:17:05 | 146,322,559 | 0 | 1 | null | 2022-06-20T17:17:06 | 2018-08-27T16:12:14 | C++ | UTF-8 | C++ | false | false | 1,132 | h | #ifndef TTDRSILI_H
#define TTDRSILI_H
/** \addtogroup Detectors
* @{
*/
#include <vector>
#include <cstdio>
#include "TBits.h"
#include "TVector3.h"
#include "Globals.h"
#include "TDetector.h"
#include "TTdrSiLiHit.h"
class TTdrSiLi : public TDetector {
public:
TTdrSiLi();
TTdrSiLi(const TTdrSiLi&);
~TTdrSiLi() override;
public:
TTdrSiLiHit* GetTdrSiLiHit(const int& i) const { return static_cast<TTdrSiLiHit*>(GetHit(i)); }
#ifndef __CINT__
void AddFragment(const std::shared_ptr<const TFragment>&, TChannel*) override;
#endif
static TVector3 GetPosition(int DetNbr); //!<!
TTdrSiLi& operator=(const TTdrSiLi&); //!<!
private:
static bool fSetCoreWave; //!<! Flag for Waveforms ON/OFF
public:
static bool SetCoreWave() { return fSetCoreWave; } //!<!
void Copy(TObject&) const override; //!<!
void Clear(Option_t* opt = "all") override; //!<!
void Print(Option_t* opt = "") const override; //!<!
void Print(std::ostream& out) const override;
/// \cond CLASSIMP
ClassDefOverride(TTdrSiLi, 4) // TdrSiLi Physics structure
/// \endcond
};
/*! @} */
#endif
| [
"vbildste@uoguelph.ca"
] | vbildste@uoguelph.ca |
d4ae2232a9fd31b07c71e43fd5bcb389bac9ebb4 | af57a19f55822d953674583558dad59da6e969af | /Source/print/print.hpp | c797f673e1cfda1660e18e3d2ccb03c559038d59 | [
"Apache-2.0"
] | permissive | Vasar007/utilities | 4a8ae5ba96c8f6c2d8848dd8b9264379e01b92e0 | 49b00497b223d61940ac63e114143120ed352754 | refs/heads/master | 2021-06-26T17:57:09.892655 | 2020-10-04T15:08:33 | 2020-10-04T15:08:33 | 153,836,752 | 0 | 0 | Apache-2.0 | 2020-10-04T15:08:34 | 2018-10-19T20:14:35 | C++ | UTF-8 | C++ | false | false | 1,286 | hpp | // Copyright (C) 2019 Vasily Vasilyev (vasar007@yandex.ru)
#pragma once
#include <iostream>
#include <iterator>
#include <type_traits>
#include <typeinfo>
#include <string>
#include <string_view>
#ifndef _MSC_VER
#include <cxxabi.h>
#endif
#include "print_impl.hpp"
namespace utils
{
/**
* \brief Print string to standart outstream.
* \param[in] str String to print.
*/
void std_output(const std::string_view str);
/**
* \brief Fast print string to outstream.
* \param[in] str String to print.
*/
void fast_output(const std::string& str) noexcept;
/**
* \brief Define the type name of variable.
* \tparam T Datatype to process (use 'decltype()' to send data).
* \return String which contains type name of variable.
*/
template <class T>
constexpr std::string_view type_name() noexcept;
template <class OutputStream, class Container>
void print_container(OutputStream& out, const Container& container);
template <class OutputStream, class Container>
void println_container(OutputStream& out, const Container& container);
void pause(const std::string_view message = "\nPress the Enter key to continue...");
void pause_clear(const std::string_view message = "Press ENTER to continue...");
#include "print.inl"
} // namespace utils
| [
"vasar007@yandex.ru"
] | vasar007@yandex.ru |
ba0ebbca219fada7e742adef555430223b9a5bba | 4071f144a2cd5a4c07ab5172763020f38831452f | /parser.cpp | 58d833f6f183d9b56c63d03a003ad4bde894acc7 | [] | no_license | juliolemus/Project3 | ca6e395f58d50e1b465065929806d8f3dc475759 | f5d3345e8d7e101cd90d0ceae5c6c7bbfe40968a | refs/heads/master | 2021-01-21T02:24:25.284333 | 2014-12-23T18:52:51 | 2014-12-23T18:52:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 55,315 | cpp | /* A Bison parser, made by GNU Bison 2.7. */
/* Bison implementation for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
/* C LALR(1) parser skeleton written by Richard Stallman, by
simplifying the original so-called "semantic" parser. */
/* All symbols defined below should begin with yy or YY, to avoid
infringing on user name space. This should be done even for local
variables, as they might otherwise be expanded by user macros.
There are some unavoidable exceptions within include files to
define necessary library symbols; they are noted "INFRINGES ON
USER NAME SPACE" below. */
/* Identify Bison output. */
#define YYBISON 1
/* Bison version. */
#define YYBISON_VERSION "2.7"
/* Skeleton name. */
#define YYSKELETON_NAME "yacc.c"
/* Pure parsers. */
#define YYPURE 0
/* Push parsers. */
#define YYPUSH 0
/* Pull parsers. */
#define YYPULL 1
/* Copy the first part of user declarations. */
/* Line 371 of yacc.c */
#line 1 "parser.y"
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#define YYDEBUG 1
int yylex(void);
void yyerror(const char *);
/* Line 371 of yacc.c */
#line 78 "parser.cpp"
# ifndef YY_NULL
# if defined __cplusplus && 201103L <= __cplusplus
# define YY_NULL nullptr
# else
# define YY_NULL 0
# endif
# endif
/* Enabling verbose error messages. */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 1
#endif
/* In a future release of Bison, this section will be replaced
by #include "parser.hpp". */
#ifndef YY_YY_PARSER_HPP_INCLUDED
# define YY_YY_PARSER_HPP_INCLUDED
/* Enabling traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
#endif
#if YYDEBUG
extern int yydebug;
#endif
/* Tokens. */
#ifndef YYTOKENTYPE
# define YYTOKENTYPE
/* Put the tokens into the symbol table, so that GDB and other debuggers
know about them. */
enum yytokentype {
T_INTEGER = 258,
T_PLUS = 259,
T_MINUS = 260,
T_DIVIDE = 261,
T_MULT = 262,
T_OR = 263,
T_AND = 264,
T_LESS = 265,
T_EQUAL = 266,
T_EQUALEQ = 267,
T_LESSEQ = 268,
T_NOT = 269,
T_ID = 270,
T_OPENBRACKET = 271,
T_CLOSEBRACKET = 272,
T_OPENPAREN = 273,
T_CLOSEPAREN = 274,
T_TRUE = 275,
T_FALSE = 276,
T_IF = 277,
T_SEMICOLON = 278,
T_ELSE = 279,
T_PRINT = 280,
T_FOR = 281,
T_NEW = 282,
T_INT = 283,
T_BOOL = 284,
T_NONE = 285,
T_DOTOP = 286,
T_EOF = 287,
T_COMMA = 288,
U_MINUS = 289,
T_COLON = 290,
T_RETURN = 291
};
#endif
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
typedef int YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
# define YYSTYPE_IS_DECLARED 1
#endif
extern YYSTYPE yylval;
#ifdef YYPARSE_PARAM
#if defined __STDC__ || defined __cplusplus
int yyparse (void *YYPARSE_PARAM);
#else
int yyparse ();
#endif
#else /* ! YYPARSE_PARAM */
#if defined __STDC__ || defined __cplusplus
int yyparse (void);
#else
int yyparse ();
#endif
#endif /* ! YYPARSE_PARAM */
#endif /* !YY_YY_PARSER_HPP_INCLUDED */
/* Copy the second part of user declarations. */
/* Line 390 of yacc.c */
#line 180 "parser.cpp"
#ifdef short
# undef short
#endif
#ifdef YYTYPE_UINT8
typedef YYTYPE_UINT8 yytype_uint8;
#else
typedef unsigned char yytype_uint8;
#endif
#ifdef YYTYPE_INT8
typedef YYTYPE_INT8 yytype_int8;
#elif (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
typedef signed char yytype_int8;
#else
typedef short int yytype_int8;
#endif
#ifdef YYTYPE_UINT16
typedef YYTYPE_UINT16 yytype_uint16;
#else
typedef unsigned short int yytype_uint16;
#endif
#ifdef YYTYPE_INT16
typedef YYTYPE_INT16 yytype_int16;
#else
typedef short int yytype_int16;
#endif
#ifndef YYSIZE_T
# ifdef __SIZE_TYPE__
# define YYSIZE_T __SIZE_TYPE__
# elif defined size_t
# define YYSIZE_T size_t
# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
# define YYSIZE_T size_t
# else
# define YYSIZE_T unsigned int
# endif
#endif
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
#ifndef YY_
# if defined YYENABLE_NLS && YYENABLE_NLS
# if ENABLE_NLS
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
# endif
# endif
# ifndef YY_
# define YY_(Msgid) Msgid
# endif
#endif
/* Suppress unused-variable warnings by "using" E. */
#if ! defined lint || defined __GNUC__
# define YYUSE(E) ((void) (E))
#else
# define YYUSE(E) /* empty */
#endif
/* Identity function, used to suppress warnings about constant conditions. */
#ifndef lint
# define YYID(N) (N)
#else
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static int
YYID (int yyi)
#else
static int
YYID (yyi)
int yyi;
#endif
{
return yyi;
}
#endif
#if ! defined yyoverflow || YYERROR_VERBOSE
/* The parser invokes alloca or malloc; define the necessary symbols. */
# ifdef YYSTACK_USE_ALLOCA
# if YYSTACK_USE_ALLOCA
# ifdef __GNUC__
# define YYSTACK_ALLOC __builtin_alloca
# elif defined __BUILTIN_VA_ARG_INCR
# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
# elif defined _AIX
# define YYSTACK_ALLOC __alloca
# elif defined _MSC_VER
# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
# define alloca _alloca
# else
# define YYSTACK_ALLOC alloca
# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
/* Use EXIT_SUCCESS as a witness for stdlib.h. */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# endif
# endif
# endif
# ifdef YYSTACK_ALLOC
/* Pacify GCC's `empty if-body' warning. */
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
# ifndef YYSTACK_ALLOC_MAXIMUM
/* The OS might guarantee only one guard page at the bottom of the stack,
and a page size can be as small as 4096 bytes. So we cannot safely
invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
to allow for a few compiler-allocated temporary stack slots. */
# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
# endif
# else
# define YYSTACK_ALLOC YYMALLOC
# define YYSTACK_FREE YYFREE
# ifndef YYSTACK_ALLOC_MAXIMUM
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
# endif
# if (defined __cplusplus && ! defined EXIT_SUCCESS \
&& ! ((defined YYMALLOC || defined malloc) \
&& (defined YYFREE || defined free)))
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
# ifndef EXIT_SUCCESS
# define EXIT_SUCCESS 0
# endif
# endif
# ifndef YYMALLOC
# define YYMALLOC malloc
# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# ifndef YYFREE
# define YYFREE free
# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
void free (void *); /* INFRINGES ON USER NAME SPACE */
# endif
# endif
# endif
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
#if (! defined yyoverflow \
&& (! defined __cplusplus \
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */
union yyalloc
{
yytype_int16 yyss_alloc;
YYSTYPE yyvs_alloc;
};
/* The size of the maximum gap between one aligned stack and the next. */
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
/* The size of an array large to enough to hold all stacks, each with
N elements. */
# define YYSTACK_BYTES(N) \
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+ YYSTACK_GAP_MAXIMUM)
# define YYCOPY_NEEDED 1
/* Relocate STACK from its old location to the new one. The
local variables YYSIZE and YYSTACKSIZE give the old and new number of
elements in the stack, and YYPTR gives the new location of the
stack. Advance YYPTR to a properly aligned location for the next
stack. */
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
while (YYID (0))
#endif
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
/* Copy COUNT objects from SRC to DST. The source and destination do
not overlap. */
# ifndef YYCOPY
# if defined __GNUC__ && 1 < __GNUC__
# define YYCOPY(Dst, Src, Count) \
__builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
# else
# define YYCOPY(Dst, Src, Count) \
do \
{ \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(Dst)[yyi] = (Src)[yyi]; \
} \
while (YYID (0))
# endif
# endif
#endif /* !YYCOPY_NEEDED */
/* YYFINAL -- State number of the termination state. */
#define YYFINAL 7
/* YYLAST -- Last index in YYTABLE. */
#define YYLAST 191
/* YYNTOKENS -- Number of terminals. */
#define YYNTOKENS 37
/* YYNNTS -- Number of nonterminals. */
#define YYNNTS 27
/* YYNRULES -- Number of rules. */
#define YYNRULES 68
/* YYNRULES -- Number of states. */
#define YYNSTATES 135
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
#define YYUNDEFTOK 2
#define YYMAXUTOK 291
#define YYTRANSLATE(YYX) \
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
static const yytype_uint8 yytranslate[] =
{
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
35, 36
};
#if YYDEBUG
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */
static const yytype_uint8 yyprhs[] =
{
0, 0, 3, 5, 8, 10, 18, 24, 27, 28,
31, 33, 35, 37, 40, 41, 51, 53, 54, 58,
60, 63, 65, 67, 71, 75, 76, 80, 82, 85,
86, 88, 90, 92, 94, 97, 101, 107, 117, 127,
130, 132, 135, 136, 140, 144, 148, 152, 156, 160,
164, 168, 172, 175, 178, 180, 184, 186, 190, 192,
194, 196, 199, 205, 210, 217, 219, 220, 224
};
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
static const yytype_int8 yyrhs[] =
{
38, 0, -1, 39, -1, 39, 40, -1, 40, -1,
15, 35, 15, 16, 41, 44, 17, -1, 15, 16,
41, 44, 17, -1, 41, 42, -1, -1, 43, 15,
-1, 28, -1, 29, -1, 15, -1, 45, 44, -1,
-1, 15, 18, 46, 19, 35, 49, 16, 50, 17,
-1, 47, -1, -1, 47, 33, 48, -1, 48, -1,
43, 15, -1, 43, -1, 30, -1, 51, 53, 59,
-1, 51, 43, 52, -1, -1, 52, 33, 15, -1,
15, -1, 54, 53, -1, -1, 55, -1, 61, -1,
56, -1, 57, -1, 25, 60, -1, 15, 11, 60,
-1, 22, 60, 16, 58, 17, -1, 22, 60, 16,
58, 17, 24, 16, 58, 17, -1, 26, 55, 23,
60, 23, 55, 16, 58, 17, -1, 58, 54, -1,
54, -1, 36, 60, -1, -1, 60, 4, 60, -1,
60, 5, 60, -1, 60, 7, 60, -1, 60, 6,
60, -1, 60, 10, 60, -1, 60, 13, 60, -1,
60, 12, 60, -1, 60, 9, 60, -1, 60, 8,
60, -1, 14, 60, -1, 5, 60, -1, 15, -1,
15, 31, 15, -1, 61, -1, 18, 60, 19, -1,
3, -1, 20, -1, 21, -1, 27, 15, -1, 27,
15, 18, 62, 19, -1, 15, 18, 62, 19, -1,
15, 31, 15, 18, 62, 19, -1, 63, -1, -1,
63, 33, 60, -1, 60, -1
};
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
static const yytype_uint8 yyrline[] =
{
0, 61, 61, 64, 64, 67, 68, 71, 71, 74,
77, 77, 77, 80, 80, 83, 86, 86, 89, 89,
92, 95, 95, 98, 101, 101, 104, 104, 107, 107,
110, 110, 110, 110, 110, 113, 116, 117, 120, 123,
123, 126, 126, 129, 129, 129, 129, 130, 130, 130,
130, 130, 131, 131, 131, 131, 132, 132, 132, 132,
132, 133, 133, 136, 136, 139, 139, 142, 142
};
#endif
#if YYDEBUG || YYERROR_VERBOSE || 1
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
static const char *const yytname[] =
{
"$end", "error", "$undefined", "T_INTEGER", "T_PLUS", "T_MINUS",
"T_DIVIDE", "T_MULT", "T_OR", "T_AND", "T_LESS", "T_EQUAL", "T_EQUALEQ",
"T_LESSEQ", "T_NOT", "T_ID", "T_OPENBRACKET", "T_CLOSEBRACKET",
"T_OPENPAREN", "T_CLOSEPAREN", "T_TRUE", "T_FALSE", "T_IF",
"T_SEMICOLON", "T_ELSE", "T_PRINT", "T_FOR", "T_NEW", "T_INT", "T_BOOL",
"T_NONE", "T_DOTOP", "T_EOF", "T_COMMA", "U_MINUS", "T_COLON",
"T_RETURN", "$accept", "Start", "Classes", "Class", "Members", "Member",
"Type", "Methods", "Method", "Args", "Arg", "Argument", "ReturnType",
"Body", "Declrs", "Declr", "Stmnts", "Stmnt", "Assignment", "IFELSE",
"FORLOOP", "Block", "Return", "Exp", "MethodCall", "Params", "Params_P", YY_NULL
};
#endif
# ifdef YYPRINT
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
token YYLEX-NUM. */
static const yytype_uint16 yytoknum[] =
{
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
285, 286, 287, 288, 289, 290, 291
};
# endif
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
static const yytype_uint8 yyr1[] =
{
0, 37, 38, 39, 39, 40, 40, 41, 41, 42,
43, 43, 43, 44, 44, 45, 46, 46, 47, 47,
48, 49, 49, 50, 51, 51, 52, 52, 53, 53,
54, 54, 54, 54, 54, 55, 56, 56, 57, 58,
58, 59, 59, 60, 60, 60, 60, 60, 60, 60,
60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
60, 60, 60, 61, 61, 62, 62, 63, 63
};
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
static const yytype_uint8 yyr2[] =
{
0, 2, 1, 2, 1, 7, 5, 2, 0, 2,
1, 1, 1, 2, 0, 9, 1, 0, 3, 1,
2, 1, 1, 3, 3, 0, 3, 1, 2, 0,
1, 1, 1, 1, 2, 3, 5, 9, 9, 2,
1, 2, 0, 3, 3, 3, 3, 3, 3, 3,
3, 3, 2, 2, 1, 3, 1, 3, 1, 1,
1, 2, 5, 4, 6, 1, 0, 3, 1
};
/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
Performed when YYTABLE doesn't specify something else to do. Zero
means the default is an error. */
static const yytype_uint8 yydefact[] =
{
0, 0, 0, 2, 4, 8, 0, 1, 3, 14,
0, 12, 10, 11, 7, 0, 0, 14, 8, 17,
9, 6, 0, 13, 14, 12, 0, 0, 16, 19,
0, 20, 0, 0, 5, 0, 18, 22, 21, 0,
25, 0, 29, 15, 12, 0, 0, 0, 0, 42,
29, 30, 32, 33, 31, 0, 66, 0, 58, 0,
0, 54, 0, 59, 60, 0, 0, 56, 34, 0,
0, 27, 24, 0, 23, 0, 28, 35, 68, 0,
65, 0, 53, 52, 0, 0, 61, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 41,
63, 0, 66, 55, 57, 66, 43, 44, 46, 45,
51, 50, 47, 49, 48, 40, 0, 0, 26, 67,
0, 0, 36, 39, 0, 64, 62, 0, 0, 0,
0, 0, 0, 37, 38
};
/* YYDEFGOTO[NTERM-NUM]. */
static const yytype_int8 yydefgoto[] =
{
-1, 2, 3, 4, 9, 14, 15, 16, 17, 27,
28, 29, 39, 41, 42, 72, 49, 115, 51, 52,
53, 116, 74, 78, 67, 79, 80
};
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
#define YYPACT_NINF -100
static const yytype_int16 yypact[] =
{
-4, 0, 21, -4, -100, -100, 14, -100, -100, 38,
-1, 24, -100, -100, -100, 17, 27, 32, -100, 57,
-100, -100, 24, -100, 38, -100, 49, 20, 35, -100,
54, -100, 40, 57, -100, 22, -100, -100, -100, 63,
-100, 56, 55, -100, 15, 4, 4, 67, 85, 83,
113, -100, -100, -100, -100, 4, 4, 122, -100, 4,
4, -14, 4, -100, -100, 128, 117, -100, 148, 135,
126, -100, 115, 4, -100, 15, -100, 148, 148, 140,
133, 151, -100, -100, 161, 101, 159, 4, 4, 4,
4, 4, 4, 4, 4, 4, 113, 4, 164, 148,
-100, 4, 4, 151, -100, 4, 97, 97, -100, -100,
158, 168, 111, 111, 111, -100, 23, 89, -100, 148,
163, 165, 162, -100, 67, -100, -100, 167, 169, 113,
113, 119, 125, -100, -100
};
/* YYPGOTO[NTERM-NUM]. */
static const yytype_int16 yypgoto[] =
{
-100, -100, -100, 184, 170, -100, 1, -12, -100, -100,
-100, 156, -100, -100, -100, -100, 141, -40, -46, -100,
-100, 2, -100, -32, -42, -99, -100
};
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule which
number is the opposite. If YYTABLE_NINF, syntax error. */
#define YYTABLE_NINF -1
static const yytype_uint8 yytable[] =
{
54, 70, 50, 120, 56, 23, 121, 58, 54, 59,
50, 1, 30, 66, 68, 18, 5, 84, 60, 61,
26, 7, 62, 77, 63, 64, 55, 82, 83, 10,
85, 65, 20, 56, 26, 6, 38, 25, 75, 32,
122, 99, 19, 48, 21, 45, 57, 22, 46, 47,
12, 13, 37, 11, 54, 106, 107, 108, 109, 110,
111, 112, 113, 114, 31, 117, 12, 13, 33, 119,
44, 34, 25, 43, 54, 35, 123, 45, 128, 40,
46, 47, 69, 12, 13, 12, 13, 54, 54, 54,
54, 123, 123, 87, 88, 89, 90, 91, 92, 93,
71, 94, 95, 89, 90, 87, 88, 89, 90, 91,
92, 93, 124, 94, 95, 87, 88, 89, 90, 73,
104, 87, 88, 89, 90, 91, 92, 93, 75, 94,
95, 131, 132, 96, 75, 45, 133, 81, 46, 47,
75, 45, 134, 86, 46, 47, 55, 45, 98, 97,
46, 47, 87, 88, 89, 90, 91, 92, 93, 100,
94, 95, 87, 88, 89, 90, 101, 92, 93, 102,
94, 95, 87, 88, 89, 90, 103, 105, 93, 118,
94, 95, 125, 129, 126, 130, 127, 8, 24, 36,
0, 76
};
#define yypact_value_is_default(Yystate) \
(!!((Yystate) == (-100)))
#define yytable_value_is_error(Yytable_value) \
YYID (0)
static const yytype_int16 yycheck[] =
{
42, 47, 42, 102, 18, 17, 105, 3, 50, 5,
50, 15, 24, 45, 46, 16, 16, 31, 14, 15,
19, 0, 18, 55, 20, 21, 11, 59, 60, 15,
62, 27, 15, 18, 33, 35, 35, 15, 15, 19,
17, 73, 18, 42, 17, 22, 31, 15, 25, 26,
28, 29, 30, 15, 96, 87, 88, 89, 90, 91,
92, 93, 94, 95, 15, 97, 28, 29, 33, 101,
15, 17, 15, 17, 116, 35, 116, 22, 124, 16,
25, 26, 15, 28, 29, 28, 29, 129, 130, 131,
132, 131, 132, 4, 5, 6, 7, 8, 9, 10,
15, 12, 13, 6, 7, 4, 5, 6, 7, 8,
9, 10, 23, 12, 13, 4, 5, 6, 7, 36,
19, 4, 5, 6, 7, 8, 9, 10, 15, 12,
13, 129, 130, 16, 15, 22, 17, 15, 25, 26,
15, 22, 17, 15, 25, 26, 11, 22, 33, 23,
25, 26, 4, 5, 6, 7, 8, 9, 10, 19,
12, 13, 4, 5, 6, 7, 33, 9, 10, 18,
12, 13, 4, 5, 6, 7, 15, 18, 10, 15,
12, 13, 19, 16, 19, 16, 24, 3, 18, 33,
-1, 50
};
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */
static const yytype_uint8 yystos[] =
{
0, 15, 38, 39, 40, 16, 35, 0, 40, 41,
15, 15, 28, 29, 42, 43, 44, 45, 16, 18,
15, 17, 15, 44, 41, 15, 43, 46, 47, 48,
44, 15, 19, 33, 17, 35, 48, 30, 43, 49,
16, 50, 51, 17, 15, 22, 25, 26, 43, 53,
54, 55, 56, 57, 61, 11, 18, 31, 3, 5,
14, 15, 18, 20, 21, 27, 60, 61, 60, 15,
55, 15, 52, 36, 59, 15, 53, 60, 60, 62,
63, 15, 60, 60, 31, 60, 15, 4, 5, 6,
7, 8, 9, 10, 12, 13, 16, 23, 33, 60,
19, 33, 18, 15, 19, 18, 60, 60, 60, 60,
60, 60, 60, 60, 60, 54, 58, 60, 15, 60,
62, 62, 17, 54, 23, 19, 19, 24, 55, 16,
16, 58, 58, 17, 17
};
#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY (-2)
#define YYEOF 0
#define YYACCEPT goto yyacceptlab
#define YYABORT goto yyabortlab
#define YYERROR goto yyerrorlab
/* Like YYERROR except do call yyerror. This remains here temporarily
to ease the transition to the new meaning of YYERROR, for GCC.
Once GCC version 2 has supplanted version 1, this can go. However,
YYFAIL appears to be in use. Nevertheless, it is formally deprecated
in Bison 2.4.2's NEWS entry, where a plan to phase it out is
discussed. */
#define YYFAIL goto yyerrlab
#if defined YYFAIL
/* This is here to suppress warnings from the GCC cpp's
-Wunused-macros. Normally we don't worry about that warning, but
some users do, and we want to make it easy for users to remove
YYFAIL uses, which will produce warnings from Bison 2.5. */
#endif
#define YYRECOVERING() (!!yyerrstatus)
#define YYBACKUP(Token, Value) \
do \
if (yychar == YYEMPTY) \
{ \
yychar = (Token); \
yylval = (Value); \
YYPOPSTACK (yylen); \
yystate = *yyssp; \
goto yybackup; \
} \
else \
{ \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (YYID (0))
/* Error token number */
#define YYTERROR 1
#define YYERRCODE 256
/* This macro is provided for backward compatibility. */
#ifndef YY_LOCATION_PRINT
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
#endif
/* YYLEX -- calling `yylex' with the right arguments. */
#ifdef YYLEX_PARAM
# define YYLEX yylex (YYLEX_PARAM)
#else
# define YYLEX yylex ()
#endif
/* Enable debugging if requested. */
#if YYDEBUG
# ifndef YYFPRINTF
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
# define YYFPRINTF fprintf
# endif
# define YYDPRINTF(Args) \
do { \
if (yydebug) \
YYFPRINTF Args; \
} while (YYID (0))
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
do { \
if (yydebug) \
{ \
YYFPRINTF (stderr, "%s ", Title); \
yy_symbol_print (stderr, \
Type, Value); \
YYFPRINTF (stderr, "\n"); \
} \
} while (YYID (0))
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
#else
static void
yy_symbol_value_print (yyoutput, yytype, yyvaluep)
FILE *yyoutput;
int yytype;
YYSTYPE const * const yyvaluep;
#endif
{
FILE *yyo = yyoutput;
YYUSE (yyo);
if (!yyvaluep)
return;
# ifdef YYPRINT
if (yytype < YYNTOKENS)
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
# else
YYUSE (yyoutput);
# endif
switch (yytype)
{
default:
break;
}
}
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
#else
static void
yy_symbol_print (yyoutput, yytype, yyvaluep)
FILE *yyoutput;
int yytype;
YYSTYPE const * const yyvaluep;
#endif
{
if (yytype < YYNTOKENS)
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
else
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
yy_symbol_value_print (yyoutput, yytype, yyvaluep);
YYFPRINTF (yyoutput, ")");
}
/*------------------------------------------------------------------.
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
| TOP (included). |
`------------------------------------------------------------------*/
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
#else
static void
yy_stack_print (yybottom, yytop)
yytype_int16 *yybottom;
yytype_int16 *yytop;
#endif
{
YYFPRINTF (stderr, "Stack now");
for (; yybottom <= yytop; yybottom++)
{
int yybot = *yybottom;
YYFPRINTF (stderr, " %d", yybot);
}
YYFPRINTF (stderr, "\n");
}
# define YY_STACK_PRINT(Bottom, Top) \
do { \
if (yydebug) \
yy_stack_print ((Bottom), (Top)); \
} while (YYID (0))
/*------------------------------------------------.
| Report that the YYRULE is going to be reduced. |
`------------------------------------------------*/
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
#else
static void
yy_reduce_print (yyvsp, yyrule)
YYSTYPE *yyvsp;
int yyrule;
#endif
{
int yynrhs = yyr2[yyrule];
int yyi;
unsigned long int yylno = yyrline[yyrule];
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
yyrule - 1, yylno);
/* The symbols being reduced. */
for (yyi = 0; yyi < yynrhs; yyi++)
{
YYFPRINTF (stderr, " $%d = ", yyi + 1);
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
&(yyvsp[(yyi + 1) - (yynrhs)])
);
YYFPRINTF (stderr, "\n");
}
}
# define YY_REDUCE_PRINT(Rule) \
do { \
if (yydebug) \
yy_reduce_print (yyvsp, Rule); \
} while (YYID (0))
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
#endif /* !YYDEBUG */
/* YYINITDEPTH -- initial size of the parser's stacks. */
#ifndef YYINITDEPTH
# define YYINITDEPTH 200
#endif
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
if the built-in stack extension method is used).
Do not make this value too large; the results are undefined if
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
evaluated with infinite-precision integer arithmetic. */
#ifndef YYMAXDEPTH
# define YYMAXDEPTH 10000
#endif
#if YYERROR_VERBOSE
# ifndef yystrlen
# if defined __GLIBC__ && defined _STRING_H
# define yystrlen strlen
# else
/* Return the length of YYSTR. */
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static YYSIZE_T
yystrlen (const char *yystr)
#else
static YYSIZE_T
yystrlen (yystr)
const char *yystr;
#endif
{
YYSIZE_T yylen;
for (yylen = 0; yystr[yylen]; yylen++)
continue;
return yylen;
}
# endif
# endif
# ifndef yystpcpy
# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
# define yystpcpy stpcpy
# else
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
YYDEST. */
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static char *
yystpcpy (char *yydest, const char *yysrc)
#else
static char *
yystpcpy (yydest, yysrc)
char *yydest;
const char *yysrc;
#endif
{
char *yyd = yydest;
const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
return yyd - 1;
}
# endif
# endif
# ifndef yytnamerr
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
quotes and backslashes, so that it's suitable for yyerror. The
heuristic is that double-quoting is unnecessary unless the string
contains an apostrophe, a comma, or backslash (other than
backslash-backslash). YYSTR is taken from yytname. If YYRES is
null, do not copy; instead, return the length of what the result
would have been. */
static YYSIZE_T
yytnamerr (char *yyres, const char *yystr)
{
if (*yystr == '"')
{
YYSIZE_T yyn = 0;
char const *yyp = yystr;
for (;;)
switch (*++yyp)
{
case '\'':
case ',':
goto do_not_strip_quotes;
case '\\':
if (*++yyp != '\\')
goto do_not_strip_quotes;
/* Fall through. */
default:
if (yyres)
yyres[yyn] = *yyp;
yyn++;
break;
case '"':
if (yyres)
yyres[yyn] = '\0';
return yyn;
}
do_not_strip_quotes: ;
}
if (! yyres)
return yystrlen (yystr);
return yystpcpy (yyres, yystr) - yyres;
}
# endif
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
about the unexpected token YYTOKEN for the state stack whose top is
YYSSP.
Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
not large enough to hold the message. In that case, also set
*YYMSG_ALLOC to the required number of bytes. Return 2 if the
required number of bytes is too large to store. */
static int
yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
yytype_int16 *yyssp, int yytoken)
{
YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
YYSIZE_T yysize = yysize0;
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
/* Internationalized format string. */
const char *yyformat = YY_NULL;
/* Arguments of yyformat. */
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
/* Number of reported tokens (one for the "unexpected", one per
"expected"). */
int yycount = 0;
/* There are many possibilities here to consider:
- Assume YYFAIL is not used. It's too flawed to consider. See
<http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
for details. YYERROR is fine as it does not invoke this
function.
- If this state is a consistent state with a default action, then
the only way this function was invoked is if the default action
is an error action. In that case, don't check for expected
tokens because there are none.
- The only way there can be no lookahead present (in yychar) is if
this state is a consistent state with a default action. Thus,
detecting the absence of a lookahead is sufficient to determine
that there is no unexpected or expected token to report. In that
case, just report a simple "syntax error".
- Don't assume there isn't a lookahead just because this state is a
consistent state with a default action. There might have been a
previous inconsistent state, consistent state with a non-default
action, or user semantic action that manipulated yychar.
- Of course, the expected token list depends on states to have
correct lookahead information, and it depends on the parser not
to perform extra reductions after fetching a lookahead from the
scanner and before detecting a syntax error. Thus, state merging
(from LALR or IELR) and default reductions corrupt the expected
token list. However, the list is correct for canonical LR with
one exception: it will still contain any token that will not be
accepted due to an error action in a later state.
*/
if (yytoken != YYEMPTY)
{
int yyn = yypact[*yyssp];
yyarg[yycount++] = yytname[yytoken];
if (!yypact_value_is_default (yyn))
{
/* Start YYX at -YYN if negative to avoid negative indexes in
YYCHECK. In other words, skip the first -YYN actions for
this state because they are default actions. */
int yyxbegin = yyn < 0 ? -yyn : 0;
/* Stay within bounds of both yycheck and yytname. */
int yychecklim = YYLAST - yyn + 1;
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
int yyx;
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
&& !yytable_value_is_error (yytable[yyx + yyn]))
{
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
{
yycount = 1;
yysize = yysize0;
break;
}
yyarg[yycount++] = yytname[yyx];
{
YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
if (! (yysize <= yysize1
&& yysize1 <= YYSTACK_ALLOC_MAXIMUM))
return 2;
yysize = yysize1;
}
}
}
}
switch (yycount)
{
# define YYCASE_(N, S) \
case N: \
yyformat = S; \
break
YYCASE_(0, YY_("syntax error"));
YYCASE_(1, YY_("syntax error, unexpected %s"));
YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
# undef YYCASE_
}
{
YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
return 2;
yysize = yysize1;
}
if (*yymsg_alloc < yysize)
{
*yymsg_alloc = 2 * yysize;
if (! (yysize <= *yymsg_alloc
&& *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
*yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
return 1;
}
/* Avoid sprintf, as that infringes on the user's name space.
Don't have undefined behavior even if the translation
produced a string with the wrong number of "%s"s. */
{
char *yyp = *yymsg;
int yyi = 0;
while ((*yyp = *yyformat) != '\0')
if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
{
yyp += yytnamerr (yyp, yyarg[yyi++]);
yyformat += 2;
}
else
{
yyp++;
yyformat++;
}
}
return 0;
}
#endif /* YYERROR_VERBOSE */
/*-----------------------------------------------.
| Release the memory associated to this symbol. |
`-----------------------------------------------*/
/*ARGSUSED*/
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
static void
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
#else
static void
yydestruct (yymsg, yytype, yyvaluep)
const char *yymsg;
int yytype;
YYSTYPE *yyvaluep;
#endif
{
YYUSE (yyvaluep);
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
switch (yytype)
{
default:
break;
}
}
/* The lookahead symbol. */
int yychar;
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
# define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif
/* The semantic value of the lookahead symbol. */
YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
/* Number of syntax errors so far. */
int yynerrs;
/*----------.
| yyparse. |
`----------*/
#ifdef YYPARSE_PARAM
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
int
yyparse (void *YYPARSE_PARAM)
#else
int
yyparse (YYPARSE_PARAM)
void *YYPARSE_PARAM;
#endif
#else /* ! YYPARSE_PARAM */
#if (defined __STDC__ || defined __C99__FUNC__ \
|| defined __cplusplus || defined _MSC_VER)
int
yyparse (void)
#else
int
yyparse ()
#endif
#endif
{
int yystate;
/* Number of tokens to shift before error messages enabled. */
int yyerrstatus;
/* The stacks and their tools:
`yyss': related to states.
`yyvs': related to semantic values.
Refer to the stacks through separate pointers, to allow yyoverflow
to reallocate them elsewhere. */
/* The state stack. */
yytype_int16 yyssa[YYINITDEPTH];
yytype_int16 *yyss;
yytype_int16 *yyssp;
/* The semantic value stack. */
YYSTYPE yyvsa[YYINITDEPTH];
YYSTYPE *yyvs;
YYSTYPE *yyvsp;
YYSIZE_T yystacksize;
int yyn;
int yyresult;
/* Lookahead token as an internal (translated) token number. */
int yytoken = 0;
/* The variables used to return semantic value and location from the
action routines. */
YYSTYPE yyval;
#if YYERROR_VERBOSE
/* Buffer for error messages, and its allocated size. */
char yymsgbuf[128];
char *yymsg = yymsgbuf;
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
/* The number of symbols on the RHS of the reduced rule.
Keep to zero when no symbol should be popped. */
int yylen = 0;
yyssp = yyss = yyssa;
yyvsp = yyvs = yyvsa;
yystacksize = YYINITDEPTH;
YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */
goto yysetstate;
/*------------------------------------------------------------.
| yynewstate -- Push a new state, which is found in yystate. |
`------------------------------------------------------------*/
yynewstate:
/* In all cases, when you get here, the value and location stacks
have just been pushed. So pushing a state here evens the stacks. */
yyssp++;
yysetstate:
*yyssp = yystate;
if (yyss + yystacksize - 1 <= yyssp)
{
/* Get the current used size of the three stacks, in elements. */
YYSIZE_T yysize = yyssp - yyss + 1;
#ifdef yyoverflow
{
/* Give user a chance to reallocate the stack. Use copies of
these so that the &'s don't force the real ones into
memory. */
YYSTYPE *yyvs1 = yyvs;
yytype_int16 *yyss1 = yyss;
/* Each stack pointer address is followed by the size of the
data in use in that stack, in bytes. This used to be a
conditional around just the two extra args, but that might
be undefined if yyoverflow is a macro. */
yyoverflow (YY_("memory exhausted"),
&yyss1, yysize * sizeof (*yyssp),
&yyvs1, yysize * sizeof (*yyvsp),
&yystacksize);
yyss = yyss1;
yyvs = yyvs1;
}
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
goto yyexhaustedlab;
# else
/* Extend the stack our own way. */
if (YYMAXDEPTH <= yystacksize)
goto yyexhaustedlab;
yystacksize *= 2;
if (YYMAXDEPTH < yystacksize)
yystacksize = YYMAXDEPTH;
{
yytype_int16 *yyss1 = yyss;
union yyalloc *yyptr =
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyexhaustedlab;
YYSTACK_RELOCATE (yyss_alloc, yyss);
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
}
# endif
#endif /* no yyoverflow */
yyssp = yyss + yysize - 1;
yyvsp = yyvs + yysize - 1;
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
(unsigned long int) yystacksize));
if (yyss + yystacksize - 1 <= yyssp)
YYABORT;
}
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
if (yystate == YYFINAL)
YYACCEPT;
goto yybackup;
/*-----------.
| yybackup. |
`-----------*/
yybackup:
/* Do appropriate processing given the current state. Read a
lookahead token if we need one and don't already have one. */
/* First try to decide what to do without reference to lookahead token. */
yyn = yypact[yystate];
if (yypact_value_is_default (yyn))
goto yydefault;
/* Not known => get a lookahead token if don't already have one. */
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
if (yychar == YYEMPTY)
{
YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
}
if (yychar <= YYEOF)
{
yychar = yytoken = YYEOF;
YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
yytoken = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
}
/* If the proper action on seeing token YYTOKEN is to reduce or to
detect an error, take that action. */
yyn += yytoken;
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
goto yydefault;
yyn = yytable[yyn];
if (yyn <= 0)
{
if (yytable_value_is_error (yyn))
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus)
yyerrstatus--;
/* Shift the lookahead token. */
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
/* Discard the shifted token. */
yychar = YYEMPTY;
yystate = yyn;
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
YY_IGNORE_MAYBE_UNINITIALIZED_END
goto yynewstate;
/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state. |
`-----------------------------------------------------------*/
yydefault:
yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;
goto yyreduce;
/*-----------------------------.
| yyreduce -- Do a reduction. |
`-----------------------------*/
yyreduce:
/* yyn is the number of a rule to reduce with. */
yylen = yyr2[yyn];
/* If YYLEN is nonzero, implement the default value of the action:
`$$ = $1'.
Otherwise, the following line sets YYVAL to garbage.
This behavior is undocumented and Bison
users should not rely upon it. Assigning to YYVAL
unconditionally makes the parser a bit smaller, and it avoids a
GCC warning that YYVAL may be used uninitialized. */
yyval = yyvsp[1-yylen];
YY_REDUCE_PRINT (yyn);
switch (yyn)
{
/* Line 1792 of yacc.c */
#line 1497 "parser.cpp"
default: break;
}
/* User semantic actions sometimes alter yychar, and that requires
that yytoken be updated with the new translation. We take the
approach of translating immediately before every use of yytoken.
One alternative is translating here after every semantic action,
but that translation would be missed if the semantic action invokes
YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
incorrect destructor might then be invoked immediately. In the
case of YYERROR or YYBACKUP, subsequent parser actions might lead
to an incorrect destructor call or verbose syntax error message
before the lookahead is translated. */
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
*++yyvsp = yyval;
/* Now `shift' the result of the reduction. Determine what state
that goes to, based on the state we popped back to and the rule
number reduced by. */
yyn = yyr1[yyn];
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTOKENS];
goto yynewstate;
/*------------------------------------.
| yyerrlab -- here on detecting error |
`------------------------------------*/
yyerrlab:
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
/* If not already recovering from an error, report this error. */
if (!yyerrstatus)
{
++yynerrs;
#if ! YYERROR_VERBOSE
yyerror (YY_("syntax error"));
#else
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
yyssp, yytoken)
{
char const *yymsgp = YY_("syntax error");
int yysyntax_error_status;
yysyntax_error_status = YYSYNTAX_ERROR;
if (yysyntax_error_status == 0)
yymsgp = yymsg;
else if (yysyntax_error_status == 1)
{
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
if (!yymsg)
{
yymsg = yymsgbuf;
yymsg_alloc = sizeof yymsgbuf;
yysyntax_error_status = 2;
}
else
{
yysyntax_error_status = YYSYNTAX_ERROR;
yymsgp = yymsg;
}
}
yyerror (yymsgp);
if (yysyntax_error_status == 2)
goto yyexhaustedlab;
}
# undef YYSYNTAX_ERROR
#endif
}
if (yyerrstatus == 3)
{
/* If just tried and failed to reuse lookahead token after an
error, discard it. */
if (yychar <= YYEOF)
{
/* Return failure if at end of input. */
if (yychar == YYEOF)
YYABORT;
}
else
{
yydestruct ("Error: discarding",
yytoken, &yylval);
yychar = YYEMPTY;
}
}
/* Else will try to reuse lookahead token after shifting the error
token. */
goto yyerrlab1;
/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR. |
`---------------------------------------------------*/
yyerrorlab:
/* Pacify compilers like GCC when the user code never invokes
YYERROR and the label yyerrorlab therefore never appears in user
code. */
if (/*CONSTCOND*/ 0)
goto yyerrorlab;
/* Do not reclaim the symbols of the rule which action triggered
this YYERROR. */
YYPOPSTACK (yylen);
yylen = 0;
YY_STACK_PRINT (yyss, yyssp);
yystate = *yyssp;
goto yyerrlab1;
/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR. |
`-------------------------------------------------------------*/
yyerrlab1:
yyerrstatus = 3; /* Each real token shifted decrements this. */
for (;;)
{
yyn = yypact[yystate];
if (!yypact_value_is_default (yyn))
{
yyn += YYTERROR;
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
{
yyn = yytable[yyn];
if (0 < yyn)
break;
}
}
/* Pop the current state because it cannot handle the error token. */
if (yyssp == yyss)
YYABORT;
yydestruct ("Error: popping",
yystos[yystate], yyvsp);
YYPOPSTACK (1);
yystate = *yyssp;
YY_STACK_PRINT (yyss, yyssp);
}
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
*++yyvsp = yylval;
YY_IGNORE_MAYBE_UNINITIALIZED_END
/* Shift the error token. */
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
yystate = yyn;
goto yynewstate;
/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here. |
`-------------------------------------*/
yyacceptlab:
yyresult = 0;
goto yyreturn;
/*-----------------------------------.
| yyabortlab -- YYABORT comes here. |
`-----------------------------------*/
yyabortlab:
yyresult = 1;
goto yyreturn;
#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here. |
`-------------------------------------------------*/
yyexhaustedlab:
yyerror (YY_("memory exhausted"));
yyresult = 2;
/* Fall through. */
#endif
yyreturn:
if (yychar != YYEMPTY)
{
/* Make sure we have latest lookahead translation. See comments at
user semantic actions for why this is necessary. */
yytoken = YYTRANSLATE (yychar);
yydestruct ("Cleanup: discarding lookahead",
yytoken, &yylval);
}
/* Do not reclaim the symbols of the rule which action triggered
this YYABORT or YYACCEPT. */
YYPOPSTACK (yylen);
YY_STACK_PRINT (yyss, yyssp);
while (yyssp != yyss)
{
yydestruct ("Cleanup: popping",
yystos[*yyssp], yyvsp);
YYPOPSTACK (1);
}
#ifndef yyoverflow
if (yyss != yyssa)
YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
if (yymsg != yymsgbuf)
YYSTACK_FREE (yymsg);
#endif
/* Make sure YYID is used. */
return YYID (yyresult);
}
/* Line 2055 of yacc.c */
#line 147 "parser.y"
extern int yylineno;
void yyerror(const char *s) {
fprintf(stderr, "%s at line %d\n", s, yylineno);
exit(0);
}
| [
"julio165guyl@gmail.com"
] | julio165guyl@gmail.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.