blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 905
values | visit_date timestamp[us]date 2015-08-09 11:21:18 2023-09-06 10:45:07 | revision_date timestamp[us]date 1997-09-14 05:04:47 2023-09-17 19:19:19 | committer_date timestamp[us]date 1997-09-14 05:04:47 2023-09-06 06:22:19 | github_id int64 3.89k 681M ⌀ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 22
values | gha_event_created_at timestamp[us]date 2012-06-07 00:51:45 2023-09-14 21:58:39 ⌀ | gha_created_at timestamp[us]date 2008-03-27 23:40:48 2023-08-21 23:17:38 ⌀ | gha_language stringclasses 141
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 10.4M | extension stringclasses 115
values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1592a8f945445aaf7706911ff4b3d83dc77ae899 | d2490ebcb141b77224e43d5438b6700f501aa281 | /ITMO Course/Segment Tree/Segment Tree Part 2/Step 2/AssignmentandMinimum.cpp | 81dee15bbc1544a4aba2bf8fecc2d318b367c6af | [] | no_license | swimmingturtle165/Coding | de51aa87dce71eb68eaea3c695b69f10ac9f514c | 257aedc3eb40eef2a0ab4a7c31432e3e8f77a8da | refs/heads/main | 2023-08-15T06:00:50.950875 | 2021-10-10T17:44:56 | 2021-10-10T17:44:56 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,688 | cpp | #include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef unsigned long long int ull;
typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> pll;
#define FOR(i,a,b) for(ll i=a;i<b;i++)
#define FORE(i,a,b) for(int i=a;i<=b;i++)
#define FORD(i,b,a) for(int i=b;i>a;i--)
#define FORDE(i,b,a) for(ll i=b;i>=a;i--)
#define debug(x) cout<< '>'<<#x<<" : "<<x<<"\n";
#define debug2(x,y) cout<< '>'<<#x<<" : "<<x<<"\n"; cout<< '>'<<#y<<" : "<<y<<"\n";
#define debug3(x,y,z) cout<< '>'<<#x<<" : "<<x<<"\n"; cout<< '>'<<#y<<" : "<<y<<"\n";cout<< '>'<<#z<<" : "<<z<<"\n";
#define umap unordered_map
#define uset unordered_set
#define lb lower_bound
#define ub upper_bound
#define mp make_pair
#define in insert
#define s second
#define f first
#define nn cout<<"\n"
#define pb push_back
#define testcase int t;cin>>t;while(t--)
#define gcd(a,b) __gcd(a,b)
#define maxv INT_MAX
#define minv INT_MIN
#define MOD 1000000007
#define FastIO ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(0);
#define here cout<<"I'm here\n";
#define flush fflush(stdout);
#define endl '\n'
#define ordered_set_single tree<ll,null_type,less<ll>,rb_tree_tag,tree_order_statistics_node_update>
ll v9=INT64_MAX;
struct segmenttree{
ll sz=1;
ll NO_OPERATION=LONG_MAX;
vector<ll> assignment;
vector<ll> val;
ll modify_operation(ll a,ll b)
{
return (a | b) ;
}
ll calc_operation(ll a,ll b)
{
return (a & b) ;
}
void apply_mod_operation(ll&a , ll b)
{
a = modify_operation(a, b);
}
void propogate(ll x,ll lx ,ll rx)
{
if(rx-lx==1 || assignment[x]==NO_OPERATION) return;
assignment[2*x+1]=assignment[x];
assignment[2*x+2]=assignment[x];
val[2*x+1]=assignment[x];
val[2*x+2]=assignment[x];
assignment[x]=NO_OPERATION;
}
void build(ll x,ll lx,ll rx)
{
if(rx-lx==1)
{
val[x] = 1;
return;
}
ll mid = (lx + rx) / 2;
build(2 * x + 1, lx, mid);
build(2 * x + 2, mid,rx);
val[x] = (val[2 * x + 1]+val[2 * x + 2]);
}
void init(ll n)
{
sz = 1;
while (sz<n)
{
sz = sz * 2;
}
assignment.assign(2 * sz, 0);
val.assign(2 * sz, 0);
// build(0, 0, sz);
}
ll get_segment(ll l,ll r,ll x,ll lx ,ll rx)
{
propogate(x,lx,rx);
// get val from l to r-1
// we currently store in x val from lx to rx-1
if(l>=rx || r<=lx )
{
// don't intersect
return INT_MAX;
}
if(l<=lx && rx<=r)
{
// complete intersection
// cout<<lx<<" "<<rx<<" "<<x<<endl;
// cout<<" && "<<val[x]<<endl;
return val[x];
}
ll mid = (lx + rx) / 2;
ll v1 = get_segment(l, r, 2 * x + 1, lx, mid);
ll v2 = get_segment(l, r, 2 * x + 2, mid,rx);
ll res=min(v1,v2);
// cout<<v1<<" "<<v2<<" "<<res<<" ";
// apply_mod_operation(res, assignment[x]);
// cout<<res<<endl;
return res;
}
ll get_segment(ll l,ll r)
{
return get_segment(l , r , 0 , 0 , sz);
}
void assignm(ll l, ll r,ll v,ll x,ll lx ,ll rx)
{
propogate(x,lx,rx);
if(l>=rx || r<=lx)
{
// don't intersect
return;
}
if(l<=lx && rx<=r)
{
// complete intersection
assignment[x]= v;
val[x]=assignment[x];
return;
}
ll mid = (lx + rx) / 2;
// left child +
assignm(l, r, v, 2 * x + 1, lx, mid);
// right child
assignm(l, r, v, 2 * x + 2, mid, rx);
val[x] = min(val[2 * x + 1] , val[2 * x + 2]);
// val[x]+=assignment[x]*(rx-lx);
return;
}
void assignm(ll l, ll r,ll v)
{
assignm(l, r, v, 0, 0, sz);
}
};
signed main(int argc, char** argv)
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
FastIO;
long t=1;
while(t--)
{
ll n, m;
cin >> n >> m;
segmenttree arr;
arr.init(n);
while(m--)
{
ll op;
cin >> op;
if(op==1)
{
ll l, r, v;
cin >> l >> r >> v;
arr.assignm(l, r, v);
}
else
{
ll l,r;
cin >> l >> r;
cout<<arr.get_segment(l,r)<<endl;
}
// Uncomment to print tree
// cout<<"&& *************"<<endl;
// FOR(i,0,log2(arr.sz)+1)
// {
// ll v1=pow(2,i);
// FOR(j,0,v1)
// {
// cout<<arr.val[v1-1+j]<<" ";
// }
// cout<<endl;
// }
// cout<<"&& *************"<<endl;
}
}
return 0;
}
| [
"sachitjaggi.1562@gmail.com"
] | sachitjaggi.1562@gmail.com |
2fcbf9c25dd5ba470a5a3441c72db42fa3c355d6 | 9a06196b6348d7fe6def6d900e2725406a3decc6 | /original_content/3rdparty/ceres-solver/internal/ceres/generated/partitioned_matrix_view_2_4_4.cc | 2e1170da01f37572a735571d0aa9f16cec59d13c | [
"BSD-3-Clause",
"MIT"
] | permissive | Mingrui-Yu/slambook2 | 592b38d1986e1c82eb45296bc5cfd28a4a0c8f64 | d31273192bd9fb5ac618f147105082022c87a005 | refs/heads/master | 2020-09-04T22:00:05.960047 | 2019-12-31T00:19:21 | 2019-12-31T00:19:21 | 219,903,430 | 1 | 0 | MIT | 2019-11-06T03:23:11 | 2019-11-06T03:23:10 | null | UTF-8 | C++ | false | false | 2,507 | cc | // Ceres Solver - A fast non-linear least squares minimizer
// Copyright 2017 Google Inc. All rights reserved.
// http://ceres-solver.org/
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of Google Inc. nor the names of its contributors may be
// used to endorse or promote products derived from this software without
// specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Author: sameeragarwal@google.com (Sameer Agarwal)
//
// Template specialization of PartitionedMatrixView.
//
// ========================================
// THIS FILE IS AUTOGENERATED. DO NOT EDIT.
// THIS FILE IS AUTOGENERATED. DO NOT EDIT.
// THIS FILE IS AUTOGENERATED. DO NOT EDIT.
// THIS FILE IS AUTOGENERATED. DO NOT EDIT.
//=========================================
//
// This file is generated using generate_template_specializations.py.
// This include must come before any #ifndef check on Ceres compile options.
#include "ceres/internal/port.h"
#ifndef CERES_RESTRICT_SCHUR_SPECIALIZATION
#include "ceres/partitioned_matrix_view_impl.h"
#include "ceres/internal/eigen.h"
namespace ceres {
namespace internal {
template class PartitionedMatrixView<2, 4, 4>;
} // namespace internal
} // namespace ceres
#endif // CERES_RESTRICT_SCHUR_SPECIALIZATION
| [
"1249682625@qq.com"
] | 1249682625@qq.com |
831a24c51fd72df4886bb8b4d556e8ff95a21178 | a736eca2628ad48779b28c90b1af55a710524359 | /AdjList.h | c81f93632574fda0a35588d2caa25348efb31419 | [] | no_license | itunev/skbTest | ac762899a215b2e7fb3b041da35c4def05c945ea | f9d89b9da0f1bab32fe1d2a5dd0a2acd16dbd6c6 | refs/heads/master | 2021-01-12T13:59:48.689259 | 2016-10-04T13:27:33 | 2016-10-04T13:27:33 | 69,683,067 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,440 | h | #ifndef __AdjList_H
#define __AdjList_H
#include <string>
#include <vector>
#include <unordered_set>
using namespace std;
typedef unsigned int uint; // id of vertice
typedef unordered_set<uint> hashid; // hash of destination vertex
typedef vector<hashid*> AList; // list of hashs
enum Request
{
EmptyInnerDegreesCount = 1,
EmptyMutualDegreesCount = 2,
MaxInnerDegreesCount = 3,
Finish = 4
};
class AdjList
{
static uint maxInnerDegree; // maximum count of inner directed edges
static vector<uint> innerDegrees; // inner directed edges count
static vector<uint> reflectDegrees; // mutual directed edges count
static vector<string> names; // ordered list of names
static AList adjList; // adjacency list
static vector<uint> emptyMutual;
static vector<uint> emptyInnerDegrees;
static vector<uint> maxInnerDegrees;
AdjList ( ) { };
AdjList (AdjList& al) { };
virtual ~AdjList ( ) { };
public:
static bool GetEdge (uint from,
uint to ); // check for directed edge existing
static bool FillLists (const string& fileNames,
const string& fileAdj); // for initialisation of lists
static void ClearLists ( ); // for correct finish without memory leaks
private:
static void ResizeAdjList (uint size );
static bool FillNamesList (const string& fileNames );
static bool FillAdjList (const string& fileAdj );
static bool SetAdjListLine (const string& line,
uint idx );
static void UpdateDegreesInfoByNextNode (uint idx );
public:
static void CalcDegrees ( ); // call after FillLists
static void NamesWithEmptyDegreeCount ( ); // call after CalcDegrees for 1 task
static void NamesWithEmptyReflectDegreeCount ( ); // call after CalcDegrees for 2 task
static void NamesWithMaxDegreeCount ( ); // call after CalcDegrees for 3 task
static void ShowList (uint request);
static void ShowList (vector<uint>& idsList);
};
#endif // #ifndef __AdjList_H
| [
"itunev@splinex.com"
] | itunev@splinex.com |
b1bd177ca18e96262d0068d902b4585154db20e9 | b904efa144015333ec3253e4d50a8a3631fdf290 | /src/KingPin/Window.cpp | 9506790cb6bd53320bc11f680fe59f7b271965ee | [
"MIT"
] | permissive | jojelen/Spazy | a16eaea94aa696a396b90f8a20de0a2b6cd27dc2 | 9d24e0f2ad0731a729cbc903d2384ddaa7a38f1a | refs/heads/master | 2020-03-30T08:09:54.802744 | 2020-01-09T10:31:01 | 2020-01-09T10:31:01 | 150,994,275 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,373 | cpp | #include "Window.h"
#include "Errors.h"
namespace KingPin
{
Window::Window() {}
Window::~Window() {}
int Window::create(std::string windowName, int &screenWidth, int &screenHeight,
unsigned int currentFlags)
{
Uint32 flags = SDL_WINDOW_OPENGL;
if (currentFlags & INVISIBLE)
{
flags |= SDL_WINDOW_HIDDEN;
}
if (currentFlags & FULLSCREEN)
{
flags |= SDL_WINDOW_FULLSCREEN_DESKTOP;
}
if (currentFlags & FULLSCREEN)
{
flags |= SDL_WINDOW_BORDERLESS;
}
// Open a SDL window
_sdlWindow = SDL_CreateWindow(windowName.c_str(), SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, screenWidth,
screenHeight, flags);///flags);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
if (_sdlWindow == nullptr){
std::string errorMessage = SDL_GetError();
fatalError("SDL Window could not be created: " + errorMessage);
}
// SDL_GLContext glContext = SDL_GL_CreateContext(_sdlWindow);
_glContext = SDL_GL_CreateContext(_sdlWindow);
if (_glContext == nullptr)
{
std::string errorMessage = SDL_GetError();
fatalError("SDL_GL context could not be created: " + errorMessage);
}
// Checks the OpenGL version
std::printf("*** OpenGL Version: %s ***\n", glGetString(GL_VERSION));
GLenum error = glewInit();
if (error != GLEW_OK)
{
// glewInit sometimes gives an unknown error that can safely be ignored,
// so shouldn't quit program here.
printf("Error message from glewInit() %s\n", glewGetErrorString(error));
}
// Backgroundcolor
glClearColor(0.4, 0, 0, 1.0);
// Set VSYNC
SDL_GL_SetSwapInterval(1);
// Enable alpha blending
glEnable(GL_BLEND);
// Sets the blending settings
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
_imgui.init(_sdlWindow, &_glContext);
return 0;
}
void Window::showGui()
{
_imgui.show();
}
void Window::clearGui()
{
_imgui.clearGui();
}
void Window::addGuiWindow(std::unique_ptr<GuiWindow> &window)
{
_imgui.addWindow(window);
}
void Window::swapBuffer() { SDL_GL_SwapWindow(_sdlWindow); }
} // namespace KingPin | [
"joel_ored@hotmail.com"
] | joel_ored@hotmail.com |
f308a7bc3c5cc059364bce11f52fa2618f0a92f9 | 72a0d15bbc90b292cba8e02e8bc6d37c1ed2b7a9 | /Chapter_15/ex_15_42/TextQuery.cxx | d045491cc7b47dbd7026d91e1b5e0fe9e2f658a1 | [] | no_license | GuanqunGe/Cpp-Primer_Exercise | 9414f053c0d343fd3521d63d3f873a9f165764a4 | 295ab9272c83e9dc3a627fb647e7977c01ef88ad | refs/heads/main | 2023-03-24T11:22:15.913814 | 2021-03-23T13:03:33 | 2021-03-23T13:03:33 | 319,142,953 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,817 | cxx | #include "TextQuery.h"
#include "QueryResult.h" //actual use of QueryResult object
#include <sstream>
TextQuery::TextQuery(std::ifstream &in):
file(std::make_shared<std::vector<std::string>>()){
std::string line;
while( std::getline(in, line)){
line_no line_number = file->size();
std::istringstream ss(line);
for( std::string word; ss>> word; ){
if(word_map.find(word) == word_map.end()){
//both are right, one directly add a pair, the other first inserts a pair with nullptr, then redirect that pointer to a newly created std::set.
//word_map.insert({word, std::make_shared<std::set<line_no>>()});
word_map[word] = std::make_shared<std::set<line_no>>();
}
word_map[word]->insert(line_number);
}
file->push_back(line);
} //end while loop
}
QueryResult TextQuery::query(const std::string &s) const{
static std::shared_ptr<std::set<line_no>> nodata(std::make_shared<std::set<line_no>>());
//static std::shared_ptr<std::set<line_no>> nodata(new std::set<line_no>);
auto pos = word_map.find(s);
if( pos == word_map.end())
return QueryResult(s, nodata, file);
else
return QueryResult(s, pos->second, file);
//return QueryResult(s, word_map[s], file); //word_map is const object, can't use subscript
}
QueryResult TextQuery::query(const std::string &s, line_no line_limit) const{
static std::shared_ptr<std::set<line_no>> nodata(std::make_shared<std::set<line_no>>());
//static std::shared_ptr<std::set<line_no>> nodata(new std::set<line_no>);
auto pos = word_map.find(s);
if( pos == word_map.end())
return QueryResult(s, nodata, file);
else{
auto upper_limit = pos->second->upper_bound(line_limit);
return QueryResult(s, std::make_shared<std::set<line_no>>(pos->second->begin(), upper_limit), file);
}
}
| [
"gg2690@columbia.edu"
] | gg2690@columbia.edu |
67e119fcbbebc48dedae77f4d8f81718164705e7 | a457238ab1657ecf52736f8fbfd83f4aa2eee3c5 | /C++/S20_CPP_Introduction_Practice/S20_Assignment_Operators.cpp | ed77a5faa4be06432e6e6df9ddc24740b34b41ca | [] | no_license | Ernesto-Canales/FUNDA_101_Ernie | 42833750199c7fa960ed2788f985c2dce9bdce47 | 322f8af209d4415a4dd9e038b6c053199ddb37ee | refs/heads/main | 2023-06-11T05:32:57.265311 | 2021-07-02T00:27:21 | 2021-07-02T00:27:21 | 364,095,642 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 722 | cpp | //Operadores de asignacion
#include <iostream>
using namespace std;
int main() {
int x; //int, double, float, char
//igual
x = 5;
cout << "x = " << x << endl; //esperando 5
//mas igual
x += 5; //x = (x + 5);
cout << "x con (+= 5) es: " << x << endl; //esperando 10
//menos igual
x -= 5; //x = (x - 5);
cout << "x con (-= 5) es: " << x << endl; //esperando 5
//por igual
x *= 5; //x = (x * 5);
cout << "x con (*= 5) es: " << x << endl; //esperando 25
//entre igual
x /= 5; //x = (x / 5);
cout << "x con (/= 5) es: " << x << endl; //esperando 5
//modulo igual
x %= 5; //x = (x % 5);
cout << "x con (%= 5) es: " << x << endl; //esperando 0
} | [
"00051120@uca.edu.sv"
] | 00051120@uca.edu.sv |
0668728294b3c386e0c1d14a688ebc7b220f9b23 | 8aa7dec802fed3ee34f75b48b19e5dd26d477e46 | /longest-palindromic-substring/longest-palindromic-substring.cpp | d04ad18adfd909550786516bc3b18c1024712648 | [] | no_license | niranjan35/coding-practise | 8508e6dddef068e2d08fdce8614929c2cf22fff2 | 1f1613e51c85caeec8f0d08acd2a8a5500c463cf | refs/heads/master | 2022-07-31T17:34:57.936989 | 2022-07-18T07:39:19 | 2022-07-18T07:39:19 | 134,059,662 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,731 | cpp | class Solution {
public:
int dp[1010][1010];
// string rec(string str, int s, int e) {
// if(str[s]==str[e]) {
// return
// }
// }
string longestPalindrome(string str) {
int n=str.length();
memset(dp,-1,sizeof(dp));
for(int i=0;i<1010;i++) {
for(int j=0;j<1010;j++) {
dp[i][j]=-1;
}
}
for(int s=0;s<n;s++) {
for(int x=0;s+x<n;x++) {
int y=s+x;
if(x==y) {
dp[x][y]=1;
continue;
}
if(str[x]==str[y]) {
if(x+1==y) {
dp[x][y]=2;
}
if((x+1<n && y-1>=0) && (x+1<=y-1 && dp[x+1][y-1]!=-1)) {
dp[x][y]=max(dp[x][y],dp[x+1][y-1]+2);
}
// if((x+1<n) && (x+1<=y && dp[x+1][y]!=-1)) {
// dp[x][y]=max(dp[x][y],dp[x+1][y]);
// }
// if((y-1>=0) && (x<=y-1 && dp[x][y-1]!=-1)) {
// dp[x][y]=max(dp[x][y],dp[x][y-1]);
// }
}
}
}
int mx=-1,x,y;
// for(int i=0;i<n;i++) {
// for(int j=0;j<n;j++) {
// cout<<dp[i][j]<<" ";
// }
// cout<<""<<endl;
// }
for(int i=0;i<n;i++) {
for(int j=0;j<n;j++) {
if(dp[i][j]>mx) {
mx=dp[i][j];
x=i;y=j;
}
}
}
return str.substr(x,y-x+1);
}
}; | [
"niranjanbodiga3535@gmail.com"
] | niranjanbodiga3535@gmail.com |
db9a384dc9bf237eb189f6047b48d8f1852f54c0 | 2d61fd0c8093ab4b6aafcecc2a6b94236689281f | /main.cpp | 65b5c1482fce60556f9ec1a214ac755a057ea462 | [] | no_license | thebestmodz/DirectX9ImGuiDesktopApp | 20fd154403d011eb2ee4ab20c9b4dbc3d774e47f | bb66516de4f12464622185f417b5cdd3d6394183 | refs/heads/master | 2023-03-18T20:59:04.745423 | 2020-04-28T05:46:45 | 2020-04-28T05:46:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,274 | cpp | #pragma comment(linker, "/SUBSYSTEM:windows /ENTRY:mainCRTStartup")
#define DIRECTINPUT_VERSION 0x0800
#include "main.h"
int main(int, char**)
{
RECT desktop;
GetWindowRect(GetDesktopWindow(), &desktop);
WNDCLASSEX wc = { sizeof(WNDCLASSEX), CS_CLASSDC, WndProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, AppClass, NULL };
RegisterClassEx(&wc);
hwnd = CreateWindowEx(WS_EX_TOPMOST | WS_EX_LAYERED, AppClass, AppName, WS_POPUP, (desktop.right / 2) - (WindowWidth / 2), (desktop.bottom / 2) - (WindowHeight / 2), WindowWidth, WindowHeight, 0, 0, wc.hInstance, 0);
//SetLayeredWindowAttributes(hwnd, 0, 255, LWA_ALPHA);
SetLayeredWindowAttributes(hwnd, RGB(0, 0, 0), 0, ULW_COLORKEY);
if (CreateDeviceD3D(hwnd) < 0)
{
CleanupDeviceD3D();
UnregisterClass(wc.lpszClassName, wc.hInstance);
return 1;
}
ShowWindow(hwnd, SW_SHOWDEFAULT);
UpdateWindow(hwnd);
SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
DefaultFont = io.Fonts->AddFontFromFileTTF("C:\\Windows\\Fonts\\segoeui.ttf", 20.0f, NULL, io.Fonts->GetGlyphRangesCyrillic());
ImGui::StyleColorsDark();
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX9_Init(g_pd3dDevice);
MSG msg;
ZeroMemory(&msg, sizeof(msg));
static bool open = true;
DWORD dwFlag = ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse;
char somelogin[25] = "";
while (msg.message != WM_QUIT)
{
if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
continue;
}
if (!open) ExitProcess(EXIT_SUCCESS);
std::this_thread::sleep_for(std::chrono::milliseconds(20));
ImGui_ImplDX9_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
ImGui::SetNextWindowSize(ImVec2(WindowWidth, WindowHeight), ImGuiCond_Once);
ImGui::SetNextWindowPos(ImVec2(0, 0), ImGuiCond_Once);
{
ImGui::Begin(AppName, &open, dwFlag);
ImGui::AlignTextToFramePadding();
ImGui::Text("LOGIN:"); ImGui::SameLine();
ImGui::InputText("##login", somelogin, sizeof(somelogin), 0, 0, 0);
ImGui::Button("LogIn", ImVec2(186, 29));
}
ImGui::End();
ImGui::EndFrame();
g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
if (g_pd3dDevice->BeginScene() >= 0)
{
ImGui::Render();
ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());
g_pd3dDevice->EndScene();
}
HRESULT result = g_pd3dDevice->Present(NULL, NULL, NULL, NULL);
if (result == D3DERR_DEVICELOST && g_pd3dDevice->TestCooperativeLevel() == D3DERR_DEVICENOTRESET) ResetDevice();
}
ImGui_ImplDX9_Shutdown();
ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext();
CleanupDeviceD3D();
DestroyWindow(hwnd);
UnregisterClass(wc.lpszClassName, wc.hInstance);
return 0;
}
| [
"klesksp@gmail.com"
] | klesksp@gmail.com |
9e0132c1fc784d424c690974bd4625d365dab893 | cc0e498dc6a2f5dd9309bb2fdf6a9b75c6b57f97 | /ExaHyPE/exahype/solvers/Solver.h | 55ea72d101ae77672c417e6e4d1b1937ce0604fa | [
"BSD-3-Clause",
"LicenseRef-scancode-free-unknown"
] | permissive | annereinarz/ExaHyPE-Workshop-Engine | cbae7c7e40ed4184205e6f723c2ac91105d6a210 | 714a6052a8accace0235fd2483566d7e9cbacb0a | refs/heads/master | 2022-02-25T15:56:50.652168 | 2019-10-17T09:11:30 | 2019-10-17T09:11:30 | 198,189,738 | 2 | 3 | BSD-3-Clause | 2019-07-22T11:56:14 | 2019-07-22T09:20:56 | C++ | UTF-8 | C++ | false | false | 81,204 | h | /**
* This file is part of the ExaHyPE project.
* Copyright (c) 2016 http://exahype.eu
* All rights reserved.
*
* The project has received funding from the European Union's Horizon
* 2020 research and innovation programme under grant agreement
* No 671698. For copyrights and licensing, please consult the webpage.
*
* Released under the BSD 3 Open Source License.
* For the full license text, see LICENSE.txt
*
* \author Dominic E. Charrier, Tobias Weinzierl
**/
#ifndef _EXAHYPE_SOLVERS_SOLVER_H_
#define _EXAHYPE_SOLVERS_SOLVER_H_
#include <utility>
#include <memory>
#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include <atomic>
#include "tarch/compiler/CompilerSpecificSettings.h"
#include "peano/utils/PeanoOptimisations.h"
#include "tarch/multicore/MulticoreDefinitions.h"
#include "tarch/la/Vector.h"
#include "tarch/la/VectorVectorOperations.h"
#include "tarch/multicore/BooleanSemaphore.h"
#include "peano/utils/Globals.h"
#include "peano/grid/VertexEnumerator.h"
#include "peano/heap/Heap.h"
#include "peano/heap/DoubleHeap.h"
#include "peano/heap/CharHeap.h"
#include "peano/heap/HeapAllocator.h"
#include "multiscalelinkedcell/HangingVertexBookkeeper.h"
#include "exahype/State.h"
#include "exahype/profilers/Profiler.h"
#include "exahype/profilers/simple/NoOpProfiler.h"
// cell descriptions
#include "exahype/records/ADERDGCellDescription.h"
#include "exahype/records/FiniteVolumesCellDescription.h"
#include <functional>
#if defined(CompilerICC) && defined(SharedTBB)
// See: https://www.threadingbuildingblocks.org/tutorial-intel-tbb-scalable-memory-allocator
#include <tbb/cache_aligned_allocator.h> // prevents false sharing
#endif
#if defined(USE_ITAC_ALL) and !defined(USE_ITAC)
#define USE_ITAC 1
#endif
#ifdef USE_ITAC
#include "VT.h"
#endif
// Some helpers
constexpr int power(int basis, int exp) {
return (exp == 0) ? 1 : basis * power(basis, exp - 1);
}
#ifdef ALIGNMENT
constexpr int addPadding(const int originalSize) {
return ALIGNMENT/8 * static_cast<int>((originalSize+(ALIGNMENT/8-1))/(ALIGNMENT/8));
}
#else
constexpr int addPadding(const int originalSize) {
return originalSize;
}
#endif
namespace exahype {
// Forward declarations
class Cell;
class Vertex;
namespace parser {
class ParserView;
} // namespace parser
/**
* We store the degrees of freedom associated with the ADERDGCellDescription and FiniteVolumesCellDescription
* instances on this heap.
* We further use this heap to send and receive face data from one MPI rank to the other.
*
* !!! CreateCopiesOfSentData
*
* All solvers must store the face data they send to neighbours at persistent addresses.
*/
#ifdef ALIGNMENT
#if defined(CompilerICC) && defined(SharedTBB)
typedef tbb::cache_aligned_allocator<double> AlignedAllocator;
typedef tbb::cache_aligned_allocator<char> AlignedCharAllocator;
#else
typedef peano::heap::HeapAllocator<double, ALIGNMENT > AlignedAllocator;
typedef peano::heap::HeapAllocator<char, ALIGNMENT > AlignedCharAllocator;
#endif
typedef peano::heap::AlignedDoubleSendReceiveTask<ALIGNMENT> AlignedDoubleSendReceiveTask;
typedef peano::heap::AlignedCharSendReceiveTask<ALIGNMENT> AlignedCharSendReceiveTask;
#endif
#if defined(UsePeanosSymmetricBoundaryExchanger) and defined(UsePeanosRLEBoundaryExchanger)
#error UsePeanosSymmetricBoundaryExchanger and UsePeanosRLEBoundaryExchanger must not be defined at the same time!
#endif
// aligned data -> AlignedDoubleSendReceiveTask
#if defined(ALIGNMENT) and defined(UsePeanosSymmetricBoundaryExchanger)
typedef peano::heap::DoubleHeap<
peano::heap::SynchronousDataExchanger< double, true, AlignedDoubleSendReceiveTask, std::vector< double, AlignedAllocator > >,
peano::heap::SynchronousDataExchanger< double, true, AlignedDoubleSendReceiveTask, std::vector< double, AlignedAllocator > >,
peano::heap::SymmetricBoundaryDataExchanger< double, false, AlignedDoubleSendReceiveTask, std::vector< double, AlignedAllocator > >,
std::vector< double, AlignedAllocator >
> DataHeap;
typedef peano::heap::CharHeap<
peano::heap::SynchronousDataExchanger< char, true, AlignedCharSendReceiveTask, std::vector< char, AlignedCharAllocator > >,
peano::heap::SynchronousDataExchanger< char, true, AlignedCharSendReceiveTask, std::vector< char, AlignedCharAllocator > >,
peano::heap::SymmetricBoundaryDataExchanger< char, false, AlignedCharSendReceiveTask, std::vector< char, AlignedCharAllocator > >,
std::vector< char, AlignedCharAllocator >
> CompressedDataHeap;
#elif defined(ALIGNMENT) and defined(UsePeanosRLEBoundaryExchanger)
typedef peano::heap::DoubleHeap<
peano::heap::SynchronousDataExchanger< double, true, AlignedDoubleSendReceiveTask, std::vector< double, AlignedAllocator > >,
peano::heap::SynchronousDataExchanger< double, true, AlignedDoubleSendReceiveTask, std::vector< double, AlignedAllocator > >,
peano::heap::AggregationBoundaryDataExchanger< double, AlignedDoubleSendReceiveTask, std::vector< double, AlignedAllocator > >,
std::vector< double, AlignedAllocator >
> DataHeap;
typedef peano::heap::CharHeap<
peano::heap::SynchronousDataExchanger< char, true, AlignedCharSendReceiveTask, std::vector< char, AlignedCharAllocator > >,
peano::heap::SynchronousDataExchanger< char, true, AlignedCharSendReceiveTask, std::vector< char, AlignedCharAllocator > >,
peano::heap::AggregationBoundaryDataExchanger< char, AlignedCharSendReceiveTask, std::vector< char, AlignedCharAllocator > >,
std::vector< char, AlignedCharAllocator >
> CompressedDataHeap;
#elif defined(ALIGNMENT) // Default: AggregationBoundaryDataExchanger
typedef peano::heap::DoubleHeap<
peano::heap::SynchronousDataExchanger< double, true, AlignedDoubleSendReceiveTask, std::vector< double, AlignedAllocator > >,
peano::heap::SynchronousDataExchanger< double, true, AlignedDoubleSendReceiveTask, std::vector< double, AlignedAllocator > >,
peano::heap::AggregationBoundaryDataExchanger< double, AlignedDoubleSendReceiveTask, std::vector< double, AlignedAllocator > >,
std::vector< double, AlignedAllocator >
> DataHeap;
typedef peano::heap::CharHeap<
peano::heap::SynchronousDataExchanger< char, true, AlignedCharSendReceiveTask, std::vector< char, AlignedCharAllocator > >,
peano::heap::SynchronousDataExchanger< char, true, AlignedCharSendReceiveTask, std::vector< char, AlignedCharAllocator > >,
peano::heap::AggregationBoundaryDataExchanger< char, AlignedCharSendReceiveTask, std::vector< char, AlignedCharAllocator > >,
std::vector< char, AlignedCharAllocator >
> CompressedDataHeap;
#endif
// non-aligned data -> SendReceiveTask
#if !defined(ALIGNMENT) and defined(UsePeanosSymmetricBoundaryExchanger)
typedef peano::heap::DoubleHeap<
peano::heap::SynchronousDataExchanger< double, true, peano::heap::SendReceiveTask<double> >,
peano::heap::SynchronousDataExchanger< double, true, peano::heap::SendReceiveTask<double> >,
peano::heap::SymmetricBoundaryDataExchanger< double, false, peano::heap::SendReceiveTask<double> >
> DataHeap;
typedef peano::heap::CharHeap<
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::SymmetricBoundaryDataExchanger< char, false, peano::heap::SendReceiveTask<char> >
> CompressedDataHeap;
#elif !defined(ALIGNMENT) and defined(UsePeanosRLEBoundaryExchanger)
typedef peano::heap::DoubleHeap<
peano::heap::SynchronousDataExchanger< double, true, peano::heap::SendReceiveTask<double> >,
peano::heap::SynchronousDataExchanger< double, true, peano::heap::SendReceiveTask<double> >,
peano::heap::RLEBoundaryDataExchanger< double, false, peano::heap::SendReceiveTask<double> >
> DataHeap;
typedef peano::heap::CharHeap<
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::RLEBoundaryDataExchanger< char, false, peano::heap::SendReceiveTask<char> >
> CompressedDataHeap;
#elif !defined(ALIGNMENT) // Default: AggregationBoundaryDataExchanger
typedef peano::heap::DoubleHeap<
peano::heap::SynchronousDataExchanger< double, true, peano::heap::SendReceiveTask<double> >,
peano::heap::SynchronousDataExchanger< double, true, peano::heap::SendReceiveTask<double> >,
peano::heap::AggregationBoundaryDataExchanger< double, peano::heap::SendReceiveTask<double>, std::vector<double> >
> DataHeap;
typedef peano::heap::CharHeap<
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::AggregationBoundaryDataExchanger< char, peano::heap::SendReceiveTask<char>, std::vector<char> >
> CompressedDataHeap;
#endif
/**
* @return a data heap array as vector.
*
* @param index heap index of the array.
*/
DataHeap::HeapEntries& getDataHeapEntries(const int index);
const DataHeap::HeapEntries& getDataHeapEntriesForReadOnlyAccess(const int index);
/**
* Moves a DataHeap array, i.e. copies the found
* data at "fromIndex" to the array at "toIndex" and
* deletes the "fromIndex" array afterwards.
*/
void moveDataHeapEntries(const int fromIndex,const int toIndex,bool recycleFromArray);
/**
* @see waitUntilAllBackgroundTasksHaveTerminated()
*/
extern tarch::multicore::BooleanSemaphore ReductionSemaphore;
/**
* A semaphore for serialising heap access.
*/
extern tarch::multicore::BooleanSemaphore HeapSemaphore;
#ifdef Parallel
/**
* An empty DataHeap message.
*
* !!! CreateCopiesOfSentData
*
* If we have set CreateCopiesOfSentData to
* false for the DataHeap, all messages need to
* have a fixed address as long as the send
* process takes.
*
* Has to be declared extern in C++ standard as
* it is instantiated in the corresponding cpp file.
*/
extern DataHeap::HeapEntries EmptyDataHeapMessage;
/**
* We abuse this heap to send and receive metadata from one MPI rank to the other.
* We never actually store data on this heap.
*
* !!! CreateCopiesOfSentData
*
* It is assumed by the metadata send routines of the solvers that
* all data exchangers of the MetadataHeap create copies of the data to send.
*
* <h2> Implementation </h2>
*
* These meta data are not symmetric, i..e we can use the Aggregation heap but we
* may not use any symmetric heap.
*/
#if defined(UsePeanosSymmetricBoundaryExchangerForMetaData) and defined(UsePeanosRLEBoundaryExchangerForMetaData)
#error UsePeanosSymmetricBoundaryExchangerForMetaData and UsePeanosRLEBoundaryExchangerForMetaData must not be defined at the same time!
#endif
#if defined(UsePeanosSymmetricBoundaryExchangerForMetaData)
typedef peano::heap::CharHeap<
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::SymmetricBoundaryDataExchanger< char, true, peano::heap::SendReceiveTask<char> >
> MetadataHeap;
#elif defined(UsePeanosRLEBoundaryExchangerForMetaData)
typedef peano::heap::CharHeap<
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::RLEBoundaryDataExchanger< char, true, peano::heap::SendReceiveTask<char> >
> MetadataHeap;
#else
typedef peano::heap::CharHeap<
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::SynchronousDataExchanger< char, true, peano::heap::SendReceiveTask<char> >,
peano::heap::AggregationBoundaryDataExchanger< char, peano::heap::SendReceiveTask<char>, std::vector<char> >
> MetadataHeap;
#endif
/**
* Defines an invalid metadata entry.
*/
static constexpr int InvalidMetadataEntry = -10;
/**
* Defines the length of the metadata
* we send out per solver.
*
* First entry is the cell (description) type.
* Second entry is the augmentation status,
* third the helper status and the fourth the
* limiter status.
*/
static constexpr int NeighbourCommunicationMetadataPerSolver = 4;
static constexpr int NeighbourCommunicationMetadataCellType = 0;
static constexpr int NeighbourCommunicationMetadataAugmentationStatus = 1;
static constexpr int NeighbourCommunicationMetadataCommunicationStatus = 2;
static constexpr int NeighbourCommunicationMetadataLimiterStatus = 3;
static constexpr int MasterWorkerCommunicationMetadataPerSolver = 5;
static constexpr int MasterWorkerCommunicationMetadataCellType = 0;
static constexpr int MasterWorkerCommunicationMetadataAugmentationStatus = 1;
static constexpr int MasterWorkerCommunicationMetadataCommunicationStatus = 2;
static constexpr int MasterWorkerCommunicationMetadataLimiterStatus = 3;
static constexpr int MasterWorkerCommunicationMetadataSendReceiveData = 4;
/**
* TODO(Dominic): Docu is outdated
*
* Encodes the metadata as integer sequence.
*
* The first element refers to the number of
* ADERDGCellDescriptions associated with this cell (nADERG).
* The next 2*nADERG elements store a pair of
* solver number, and cell description type (encoded as int)
* for each ADERDGCellDescription associated with this cell (description).
*
* The element 1+2*nADERDG refers to the number of
* FiniteVolumesCellDescriptions associated with this cell (nFV).
* The remaining 2*nFV elements store a pair of
* solver number, and cell description type (encoded as int)
* for each FiniteVolumesCellDescription associated with this cell
* (description).
*/
MetadataHeap::HeapEntries gatherNeighbourCommunicationMetadata(
const int cellDescriptionsIndex,
const tarch::la::Vector<DIMENSIONS,int>& src,
const tarch::la::Vector<DIMENSIONS,int>& dest);
/**
* Send metadata to rank @p toRank.
*/
void sendNeighbourCommunicationMetadata(
const int toRank,
const int cellDescriptionsIndex,
const tarch::la::Vector<DIMENSIONS,int>& src,
const tarch::la::Vector<DIMENSIONS,int>& dest,
const tarch::la::Vector<DIMENSIONS,double>& x,
const int level);
/**
* Receive metadata to rank @p toRank.
*
* @note Clears and enlarges the buffer
* if necessary.
*
* @param[in] doNotReceiveAndFillBufferWithInvalidEntries Within batches, we sometimes do not want to receive metadata.
*
* \return The index of the received metadata message
* on the exahype::MetadataHeap.
*/
void receiveNeighbourCommunicationMetadata(
MetadataHeap::HeapEntries& buffer,
const int fromRank,
const tarch::la::Vector<DIMENSIONS,double>& x,
const int level);
/**
* Send a metadata sequence filled with InvalidMetadataEntry
* to rank @p toRank.
*/
void sendNeighbourCommunicationMetadataSequenceWithInvalidEntries(
const int toRank,
const tarch::la::Vector<DIMENSIONS,double>& x,
const int level);
/**
* Drop metadata sent by rank @p fromRank.
*/
void dropMetadata(
const int fromRank,
const peano::heap::MessageType& messageType,
const tarch::la::Vector<DIMENSIONS,double>& x,
const int level);
#endif
namespace solvers {
class Solver;
typedef std::vector<Solver*> RegisteredSolversEntries;
/**
* All the registered solvers. Has to be declared extern in C++ standard as
* it is instantiated in the corresponding cpp file.
*/
extern std::vector<Solver*> RegisteredSolvers;
}
}
/**
* Describes one solver.
*/
class exahype::solvers::Solver {
private:
/**
* Log device.
*/
static tarch::logging::Log _log;
protected:
void tearApart(int numberOfEntries, int normalHeapIndex, int compressedHeapIndex, int bytesForMantissa) const;
void glueTogether(int numberOfEntries, int normalHeapIndex, int compressedHeapIndex, int bytesForMantissa) const;
public:
#ifdef USE_ITAC
/**
* These handles are used to trace solver events with Intel Trace Analyzer and Collector.
*/
static int waitUntilCompletedLastStepHandle;
static int ensureAllJobsHaveTerminatedHandle;
#endif
#ifdef Parallel
/**
* Tag used for master worker communication.
*/
static int MasterWorkerCommunicationTag;
#endif
/**
* Default return value of function getElement(...)
* If we do not find the element in a vector
* stored at a heap address.
*/
static constexpr int NotFound = -1;
/**
* An extensible structure linking to the data of a cell.
* It is passed to all solver routines.
*/
typedef struct CellInfo {
const int _cellDescriptionsIndex= -1;
peano::heap::RLEHeap<exahype::records::ADERDGCellDescription>::HeapEntries& _ADERDGCellDescriptions;
peano::heap::RLEHeap<exahype::records::FiniteVolumesCellDescription>::HeapEntries& _FiniteVolumesCellDescriptions;
CellInfo(const CellInfo& cellInfo) :
_cellDescriptionsIndex (cellInfo._cellDescriptionsIndex ),
_ADERDGCellDescriptions (cellInfo._ADERDGCellDescriptions ),
_FiniteVolumesCellDescriptions(cellInfo._FiniteVolumesCellDescriptions)
{}
CellInfo(const int cellDescriptionsIndex,void* ADERDGCellDescriptions,void* FiniteVolumesCellDescriptions) :
_cellDescriptionsIndex(cellDescriptionsIndex),
_ADERDGCellDescriptions (*static_cast<peano::heap::RLEHeap<exahype::records::ADERDGCellDescription>::HeapEntries*>(ADERDGCellDescriptions)),
_FiniteVolumesCellDescriptions(*static_cast<peano::heap::RLEHeap<exahype::records::FiniteVolumesCellDescription>::HeapEntries*>(FiniteVolumesCellDescriptions))
{}
CellInfo(const int cellDescriptionsIndex) :
_cellDescriptionsIndex(cellDescriptionsIndex),
_ADERDGCellDescriptions (peano::heap::RLEHeap<exahype::records::ADERDGCellDescription>::getInstance().getData(_cellDescriptionsIndex)),
_FiniteVolumesCellDescriptions(peano::heap::RLEHeap<exahype::records::FiniteVolumesCellDescription>::getInstance().getData(_cellDescriptionsIndex))
{}
/**
* @return if no data was found for the cell.
*/
bool empty() const {
return _ADERDGCellDescriptions.empty() && _FiniteVolumesCellDescriptions.empty();
}
/**
* @return the first cell description with the given @p solverNumber.
*
* @param cellDescriptions an ordered collection of cell descriptions
* @param solverNumber identification number of a solver
*/
template <typename CellDescriptionHeapEntries>
static int indexOfCellDescription(CellDescriptionHeapEntries& cellDescriptions,const int solverNumber) {
int index = exahype::solvers::Solver::NotFound;
for (unsigned int element = 0; element < cellDescriptions.size(); ++element) {
if (cellDescriptions[element].getSolverNumber()==solverNumber) {
index = element;
break;
}
}
return index;
}
/**
* @return Index of an ADER-DG cell description or Solver::NotFound (-1).
* @param solverNumber identification number of a solver
*/
int indexOfADERDGCellDescription(const int solverNumber) {
return indexOfCellDescription(_ADERDGCellDescriptions,solverNumber);
}
/**
* @return Index of an Finite Volumes cell description or Solver::NotFound (-1).
* @param solverNumber identification number of a solver
*/
int indexOfFiniteVolumesCellDescription(const int solverNumber) {
return indexOfCellDescription(_FiniteVolumesCellDescriptions,solverNumber);
}
/**
* @return If there is any cell description which belogns to
* the solver with @p solverNumber.
*
* @param solverNumber identification number of a solver
*/
bool foundCellDescriptionForSolver(const int solverNumber) const {
bool found = false;
for (auto& p : _ADERDGCellDescriptions) {
found |= p.getSolverNumber()==solverNumber;
}
for (auto& p : _FiniteVolumesCellDescriptions) {
found |= p.getSolverNumber()==solverNumber;
}
return found;
}
} CellInfo;
/**
* This struct computes and stores some
* commonly used indices when merging neighbouring
* cells via a common interfaces.
*
* TODO(Dominic): Move to more appropriate place?
*/
typedef struct InterfaceInfo {
int _direction; /*! coordinate direction the normal vector is aligned with (0->x,1->y,2->z) */
int _orientation1; /*! orientation of the normal vector from pos1's perspective (0/1 -> pointing in/out of element) */
int _orientation2; /*! orientation of the normal vector from pos2's perspective (0/1 -> pointing in/out of element) */
int _faceIndex1; /*! interface index from perspective of pos1 */
int _faceIndex2; /*! interface index from perspective of pos2 */
int _faceIndexLeft; /*! interface index from perspective of the "left" cell, i.e. the cell with orientation=1 (normal vector points out) */
int _faceIndexRight;/*! interface index from perspective of the "right" cell, i.e. the cell with orientation=0 (normal vector points in) */
InterfaceInfo(const tarch::la::Vector<DIMENSIONS,int>& pos1,const tarch::la::Vector<DIMENSIONS,int>& pos2)
:
_direction (tarch::la::equalsReturnIndex(pos1, pos2)),
_orientation1 ((1 + pos2(_direction) - pos1(_direction))/2),
_orientation2 (1-_orientation1),
_faceIndex1 (2*_direction+_orientation1),
_faceIndex2 (2*_direction+_orientation2),
_faceIndexLeft (2*_direction+1),
_faceIndexRight(2*_direction+0) {
assertionEquals(tarch::la::countEqualEntries(pos1,pos2),DIMENSIONS-1);
}
std::string toString() {
std::ostringstream stringstream;
stringstream << "(";
stringstream << "_direction=" << _direction;
stringstream << ",_orientation1=" << _orientation1;
stringstream << ",_orientation2=" << _orientation2;
stringstream << ",_faceIndex1=" << _faceIndex1;
stringstream << ",_faceIndex2=" << _faceIndex2;
stringstream << ",_faceIndexLeft=" << _faceIndexLeft;
stringstream << ",_faceIndexRight=" << _faceIndexRight;
stringstream << ")";
return stringstream.str();
}
} InterfaceInfo;
/**
* This struct computes and stores some
* commonly used indices when merging a cell
* with boundary data at a boundary face.
*
* TODO(Dominic): Move to more appropriate place?
*/
typedef struct BoundaryFaceInfo {
int _direction; /*! coordinate direction the normal vector is aligned with (0->x,1->y,2->z) */
int _orientation; /*! orientation of the normal vector from posCell's perspective (0/1 -> pointing in/out of element) */
int _faceIndex; /*! interface index from perspective of posCell */
BoundaryFaceInfo(const tarch::la::Vector<DIMENSIONS,int>& posCell,const tarch::la::Vector<DIMENSIONS,int>& posBoundary)
:
_direction (tarch::la::equalsReturnIndex(posCell, posBoundary)),
_orientation((1 + posBoundary(_direction) - posCell(_direction))/2),
_faceIndex (2*_direction+_orientation) {
assertionEquals(tarch::la::countEqualEntries(posCell,posBoundary),DIMENSIONS-1);
}
std::string toString() {
std::ostringstream stringstream;
stringstream << "(";
stringstream << "_direction=" << _direction;
stringstream << ",_orientation=" << _orientation;
stringstream << ",_faceIndex1=" << _faceIndex;
stringstream << ")";
return stringstream.str();
}
} BoundaryFaceInfo;
/**
* TrackGridStatistics is a flag from Peano that I "misuse" here as these
* data also are grid statistics.
*/
#ifdef TrackGridStatistics
static double PipedUncompressedBytes;
static double PipedCompressedBytes;
#endif
/** @name Global profiling options
*
* Global profiling options which are set via the parser.
*/
///@{
/**
* The solvers need to do adjust some operations slightly
* when those are run multiple times after each other in isolation.
*/
static bool ProfileUpdate;
///@}
/** @name Global solver optimisations
*
* Global solver optimisations which are set via the parser.
*/
///@{
/**
* A flag indicating that only initial mesh refinement is used, i.e.
* the mesh remains static.
*
* Multiple operations can then be omitted during the time stepping
* iterations, e.g. backing up a previous solution for
* the pure ADER-DG scheme, evaluating the refinement criterion,
* computing a new time step size if the scheme is linear, ...
*/
static bool OnlyInitialMeshRefinement;
/**
* Indicates that only static limiting is used.
* In this case, the limiter criteria do not need
* to be evaluated and no FV->DG projection needs to
* be performed in troubled cells. This
* makes the troubled cells pure FV cells.
*/
static bool OnlyStaticLimiting;
/**
* A flag indicating we fuse the algorithmic
* phases of all ADERDGSolver and
* LimitingADERDGSolver instances.
*
*/
static bool FuseAllADERDGPhases;
/**
* This factor (alpha) is used to scale
* the admissible time step size if the fused
* time stepping (for nonlinear PDEs) scheme is reset.
*
* The fused times stepping time step size estimate is then reset to
*
* dt_est = alpha * dt_adm.
*/
static double FusedTimeSteppingRerunFactor;
/**
* This factor (beta) is used in the fused time stepping (for nonlinear PDEs)
* time step size estimate as follows:
*
* dt_est = 0.5 ( beta * dt_adm + dt_est ),
*
* i.e dt_est approaches beta * dt_adm over time.
*
* This adds additional numerical diffusion as
* a smaller time step size is chosen as necessary.
*/
static double FusedTimeSteppingDiffusionFactor;
/**
* The number of Prediction,PredictionRerun,PredictionOrLocalRecomputation<
* and FusedTimeStep iterations we need to run per time step.
*/
static int PredictionSweeps;
/**
* Set to 0 if no floating point compression is used. Is usually done in the
* runner once at startup and from hereon is a read-only variable. The
* subsequent field SpawnCompressionAsBackgroundThread has no semantics if
* the present value is set to 0.
*/
static double CompressionAccuracy;
static bool SpawnCompressionAsBackgroundJob;
/**
* Maximum number of background job consumer tasks
* which are allowed to run during the mesh traversal.
*
* Default is zero.
*/
static int MaxNumberOfRunningBackgroundJobConsumerTasksDuringTraversal;
/**
* Set to true if the prediction, and the first and intermediate fused time steps in
* a batch should be launched as background job.
*/
static bool SpawnPredictionAsBackgroundJob;
/**
* Set to true if the update and last fused time step in a batch
* should be launched as background job.
*/
static bool SpawnUpdateAsBackgroundJob;
/**
* Set to true if the prolongation
* should be launched as background job whenever possible.
*
* Requires that the prediction is launched as background job too.
*/
static bool SpawnProlongationAsBackgroundJob;
/**
* Set to true if the mesh refinement iterations
* should run background jobs whenever possible.
*/
static bool SpawnAMRBackgroundJobs;
/**
* If this is set, we can skip sending metadata around during
* batching iterations.
*/
static bool DisableMetaDataExchangeInBatchedTimeSteps;
/**
* If this is set, we can skip Peano vertex neighbour exchange during batching iterations.
*/
static bool DisablePeanoNeighbourExchangeInTimeSteps;
///@}
enum class JobType { AMRJob, ReductionJob, EnclaveJob, SkeletonJob };
enum class JobSystemWaitBehaviourType { ProcessAnyJobs, ProcessJobsWithSamePriority, OnlyPollMPI };
/**
* What to do whenever the job system needs to wait until a
* job is completed.
*/
static JobSystemWaitBehaviourType JobSystemWaitBehaviour;
/**
* \see ensureAllBackgroundJobsHaveTerminated
*/
static std::atomic<int> NumberOfAMRBackgroundJobs;
/**
* Number of jobs spawned which perform a reduction.
*
* Reduction Jobs are spawned as high priority.
* They might be enclave or skeleton jobs.
*/
static std::atomic<int> NumberOfReductionJobs;
/**
* Number of background jobs spawned
* from enclave cells.
*
* \see ensureAllBackgroundJobsHaveTerminated
*/
static std::atomic<int> NumberOfEnclaveJobs;
/**
* Number of background jobs spawned
* from skeleton cells, i.e. cells at parallel
* or adaptivity boundaries.
*
* \see ensureAllBackgroundJobsHaveTerminated
*/
static std::atomic<int> NumberOfSkeletonJobs;
/**
* The type of a solver.
*/
enum class Type { ADERDG, FiniteVolumes, LimitingADERDG };
/**
* The time stepping mode.
*/
enum class TimeStepping {
/**
* In the global time stepping mode, every cells works with the same time step.
*/
Global,
/**
* In the fixed time stepping mode, we assume that each cell advanced in
* time with the prescribed time step size. No CFL condition is checked.
*/
GlobalFixed
// Local, Anarchic
};
/**
* The refinement control states
* returned by the user functions.
*/
enum class RefinementControl { Keep = 0, Refine = 1, Erase = 2 };
/**
* The limiter domain change that was detected after a solution
* update or during the limiter status spreading.
*/
enum class MeshUpdateEvent {
/**
* A regular change of the limiter domain
* has occurred. This might be either no change at
* all or a situation where a cell directly next to a
* troubled cell has been newly marked as troubled.
*/
None = 0,
/**
* The limiter domain of this solver changed in an irregular
* fashion, i.e. a troubled cell appeared suddenly.
* Its appearance was not anticipated
*
* During the consequent refinement
* status spreading, if we observe that
* we also need to update the mesh,
* this event is changed to RefinementRequested.
*/
IrregularLimiterDomainChange = 1,
/**
* Scenario 1:
* A cell which is not directly next to a troubled cell
* has newly been marked as troubled.
* The cell is not on the finest mesh level.
*
* Scenario 2:
* A cell of type Descendant/EmptyDescendant
* was marked with LimiterStatus other than Ok.
* The cell is on the finest mesh level.
*
* <h2>Consequences</h2>
* The runner must then refine the mesh accordingly, and perform a
* rollback in all cells to the previous solution. It computes
* a new time step size in all cells. Next, it recomputes the predictor in all
* cells, troubled or not. Finally, it reruns the whole ADERDG time step in
* all cells, troubled or not.
*
* This can potentially be relaxed for anarchic time stepping where
* each cell has its own time step size and stamp.
*/
RefinementRequested = 2,
/**
* The initial mesh will be created.
*/
InitialRefinementRequested = 3
};
/**
* \return String representation of the meshUpdateEvent.
*/
static std::string toString(const MeshUpdateEvent& meshUpdateEvent);
/**
* Converts LimiterDomainChange to its double equivalent.
*/
static double convertToDouble(const MeshUpdateEvent& meshUpdateEvent);
/**
* Converts a double to a LimiterDomainChange.
*/
static MeshUpdateEvent convertToMeshUpdateEvent(const double value);
/**
* \return the larger (cast to int) value of both events.
*/
static MeshUpdateEvent mergeMeshUpdateEvents(
const MeshUpdateEvent meshUpdateEvent1,const MeshUpdateEvent meshUpdateEvent2);
/**
* This struct is returned after the update or fusedTimeStep
* methods are run.
*/
typedef struct UpdateResult {
double _timeStepSize = std::numeric_limits<double>::infinity();
MeshUpdateEvent _meshUpdateEvent = MeshUpdateEvent::None;
UpdateResult() {}
} UpdateResult;
/**
* This struct is used in the AMR context
* to lookup a parent cell description and
* for computing the subcell position of the child
* with respect to this parent.
*
* TODO(Dominic): Move to more appropriate place?
*/
typedef struct SubcellPosition {
int parentCellDescriptionsIndex;
int parentElement;
tarch::la::Vector<DIMENSIONS,int> subcellIndex;
int levelDifference;
SubcellPosition() :
parentCellDescriptionsIndex(),
parentElement(NotFound),
subcellIndex(-1),
levelDifference(-1) {}
void invalidate() {
parentCellDescriptionsIndex = multiscalelinkedcell::HangingVertexBookkeeper::InvalidAdjacencyIndex;
parentElement = NotFound;
for (int i=0; i<DIMENSIONS; i++) {
subcellIndex[i] = -1;
}
levelDifference = -1;
}
~SubcellPosition() {}
} SubcellPosition;
/**
* The augmentation control states.
*/
enum class AugmentationControl {
/**
* Indicates that a spacetree cell is next to another spacetree cell
* of type exahype::records::ADERDGCellDescription::Cell.
*/
NextToCell = 0,
/**
* Indicates that a spacetree cell is next to another spacetree cell
* of type exahype::records::ADERDGCellDescription::Ancestor or
* exahype::records::ADERDGCellDescription::EmptyAncestor.
*/
NextToAncestor = 1,
/**
* Indicates that a spacetree cell is both, next to another spacetree cell
* of type exahype::records::ADERDGCellDescription::Ancestor or
* exahype::records::ADERDGCellDescription::EmptyAncestor, and
* a spacetree cell of type
* exahype::records::ADERDGCellDescription::Cell.
*/
NextToCellAndAncestor = 2,
/**
* Indicates that a spacetree cell is neither, next to another spacetree cell
* of type exahype::records::ADERDGCellDescription::Ancestor or
* exahype::records::ADERDGCellDescription::EmptyAncestor, nor
* next to a spacetree cell of type exahype::records::ADERDGCellDescription::Cell.
*
* A cell of type exahype::records::ADERDGCellDescription::Descendant can then request erasing.
* A cell of type exahype::records::ADERDGCellDescription::Cell does then not need
* to request augmenting.
*/
Default = 3
};
/**
* @return if dynamic mesh refinement or limiting is used.
*/
static bool areRollbacksPossible() {
return !OnlyInitialMeshRefinement || !OnlyStaticLimiting;
}
/**
* Checks if one of the solvers is of a certain
* type.
*/
static bool oneSolverIsOfType(const Type& type);
/**
* Run over all solvers and identify the minimal time stamp.
*/
static double getMinTimeStampOfAllSolvers();
/**
* Run over all solvers and identify the minimal sum of minimal time stamp
* plus the minimal time step size.
*
* The result is a lower bound of the minimum time stamp
* that will be obtained in the following time step.
*/
static double estimateMinNextSolverTimeStampOfAllSolvers();
/**
* Run over all solvers and identify the minimal time step size.
*/
static double getMinTimeStepSizeOfAllSolvers();
/**
* Run over all solvers and identify the minimal time step size.
*/
static double getMaxSolverTimeStepSizeOfAllSolvers();
/**
* Run over all solvers and identify the maximal time stamp.
*
* On the individual patches, we do use the min time stamp so
* far, so the routine returns the maximum over all min solver
* time stamps.
*/
static double getMaxTimeStampOfAllSolvers();
static bool allSolversUseTimeSteppingScheme(solvers::Solver::TimeStepping scheme);
static double getCoarsestMaximumMeshSizeOfAllSolvers();
static double getFinestMaximumMeshSizeOfAllSolvers();
/**
* Returns the coarsest level which holds patches of
* a solver.
*
* @note It is very important that initSolvers
* has been called on all solvers before this
* method is used.
*
* @note That we start counting the mesh level
* at 1. In a uniform mesh with level l, there
* are thus 3^{DIMENSIONS*(l-1)} cells.
*/
static int getCoarsestMeshLevelOfAllSolvers();
/**
* Returns the finest mesh level where a solver
* has his uniform mesh.
*
* @note It is very important that initSolvers
* has been called on all solvers before this
* method is used.
*/
static int getFinestUniformMeshLevelOfAllSolvers();
/**
* @return the maximum mesh level which might be occupied
* by a solver's cells.
*/
static int getMaximumAdaptiveMeshLevelOfAllSolvers();
/**
* Returns the coarsest mesh size a solver is actually
* using.
*
* @note It is very important that initSolvers
* has been called on all solvers before this
* method is used.
*/
static double getCoarsestMeshSizeOfAllSolvers();
static const tarch::la::Vector<DIMENSIONS,double>& getDomainSize();
static const tarch::la::Vector<DIMENSIONS,double>& getDomainOffset();
/**
* Loop over the solver registry and check if no solver
* performs adaptive mesh refinement.
*/
static bool allSolversPerformOnlyUniformRefinement();
/**
* Loop over the solver registry and check if one
* of the solvers has requested a mesh update.
*/
static bool oneSolverRequestedMeshRefinement();
/**
* Returns true if one of the solvers used a time step size
* that violated the CFL condition.
*
* TODO(Dominic): Rename. Name can be confused with
* oneSolverHasNotAttainedStableState.
*/
static bool oneSolverViolatedStabilityCondition();
/*
* Check if a solver requested limiter status spreading.
* Such a request might stem from a limiting ADERDGSolver which
* has requested mesh refinement or a local
* or global recomputation.
*/
static bool oneSolverRequestedRefinementStatusSpreading();
/*
* Check if a solver requested local recomputation
* recomputation.
*/
static bool oneSolverRequestedLocalRecomputation();
/*
* Check if a solver requested either global
* recomputation.
*/
static bool oneSolverRequestedGlobalRecomputation();
/**
* Loops over all registered LimitingADERDGSolver instances
* and determines the maximum value of their
* minimum limiter status for a troubled cell.
*
* This value determines how long we have to perform
* limiter status spreading.
*
* The minimum possible return value is three.
*/
static int getMaxRefinementStatus();
/**
* Specify if solvers spawn background jobs and
* configure the number of sweeps run by the adapters FusedTimeStep, Prediction, PredictionRerun,
* and PredictorOrLocalRecomputation.
*/
static void configurePredictionPhase(const bool usePredictionBackgroundJobs, bool useProlongationBackgroundJobs);
static std::string toString(const JobType& jobType);
static int getNumberOfQueuedJobs(const JobType& jobType);
/**
* Ensure that all background jobs (such as prediction or compression jobs) have terminated before progressing
* further. We have to wait until all tasks have terminated if we want to modify the heap,
* i.e. insert new data or remove data.
* Therefore, the wait (as well as the underlying semaphore) belong
* into this abstract superclass.
*
* @param[in] backgroundJobCounter A reference to a background job counter.
*/
static void ensureAllJobsHaveTerminated(JobType jobType);
/**
* Waits until the @p cellDescription has completed its time step.
*
* Thread-safety
* -------------
*
* We only read (sample) the hasCompletedLastStep flag and thus do not need any locks.
* If this flag were to assume an undefined state, this would happen after the job working processing the
* cell description was completed. This routine will then do an extra iteration or finish.
* Either is fine.
*
* The flag is modified before a job is spawned and after it was processed.
* As the job cannot be processed before it is spawned, setting the flag
* is thread-safe.
*
* MPI
* ---
*
* Tries to receive dangling MPI messages while waiting if this
* is specified by the user.
*
* Work Stealing
* -------------
*
* Assume this rank has stolen jobs from another rank.
* If this routine actually waits, this indicates it has to wait for a local job
* and not for a stolen one.
* Therefore, we exclude stolen jobs from being processed by this routine.
*
* @note Only use receiveDanglingMessages=true if the routine
* is called from a serial context.
*
* @param cellDescription a cell description
* @param waitForHighPriorityJob a cell description's task was spawned as high priority job
* @param receiveDanglingMessages receive dangling messages while waiting
*/
template <typename CellDescription>
void waitUntilCompletedLastStep(
const CellDescription& cellDescription,const bool waitForHighPriorityJob,const bool receiveDanglingMessages) {
#ifdef USE_ITAC
VT_begin(waitUntilCompletedLastStepHandle);
#endif
if ( !cellDescription.getHasCompletedLastStep() ) {
peano::datatraversal::TaskSet::startToProcessBackgroundJobs();
}
while ( !cellDescription.getHasCompletedLastStep() ) {
#ifdef Parallel
{
tarch::multicore::RecursiveLock lock( tarch::services::Service::receiveDanglingMessagesSemaphore );
tarch::parallel::Node::getInstance().receiveDanglingMessages();
lock.free();
}
#endif
switch ( JobSystemWaitBehaviour ) {
case JobSystemWaitBehaviourType::ProcessJobsWithSamePriority:
tarch::multicore::jobs::processBackgroundJobs( 1, getTaskPriority(waitForHighPriorityJob) );
break;
case JobSystemWaitBehaviourType::ProcessAnyJobs:
tarch::multicore::jobs::processBackgroundJobs( 1 );
break;
default:
break;
}
}
#ifdef USE_ITAC
VT_end(waitUntilCompletedLastStepHandle);
#endif
}
/**
* @return the default priority.
*/
static int getDefaultTaskPriority() {
return tarch::multicore::DefaultPriority;
}
/**
* @return a high priority.
*/
static int getHighPriorityTaskPriority() {
return tarch::multicore::DefaultPriority*2;
}
/**
* @return a high priority if the argument is set to true. Otherwise,
* the default priority.
*/
static int getTaskPriority( const bool isHighPriorityJob ) {
return isHighPriorityJob ? getHighPriorityTaskPriority() : getDefaultTaskPriority();
}
/**
* @return a very high priority.
*/
static int getCompressionTaskPriority() {
return tarch::multicore::DefaultPriority*8;
}
/**
* Return a string representation for the type @p param.
*/
static std::string toString(const exahype::solvers::Solver::Type& param);
/**
* Return a string representation for the time stepping mode @p param.
*/
static std::string toString(const exahype::solvers::Solver::TimeStepping& param);
/**
* @return mesh resolution and mesh level (incremented by 1) such that
* @p boundingBoxSize / 3^level <= @p meshSize.
*
* @note The domain root cell is actually at Peano mesh level 1
* as the domain itself is embedded in a 3^d mesh in Peano.
*
* @note Load balancing makes only sense for a Peano mesh with
* at least 3 (Peano) levels. This is not ensured or checked in this routine.
*
* @param meshSize the coarsest allowed mesh size.
* @param boundingBoxSize size of the bounding box.
*/
static std::pair<double,int> computeCoarsestMeshSizeAndLevel(double meshSize, double boundingBoxSize);
protected:
/**
* Each solver has an identifier/name. It is used for debug purposes only.
*/
const std::string _identifier;
const Type _type;
/**
* The number of state variables of the conservation or balance law.
*/
const int _numberOfVariables;
/**
* The number of parameters, e.g, material parameters.
*/
const int _numberOfParameters;
/**
* The number of global observables, e.g. indicators used by AMR.
*/
const int _numberOfGlobalObservables ;
/**
* The number of nodal basis functions that are employed in each
* coordinate direction.
*/
const int _nodesPerCoordinateAxis;
/**
* The offset of the computational domain.
*
* Is initialised by the initSolver method.
*/
tarch::la::Vector<DIMENSIONS,double> _domainOffset;
/**
* The size of the computational domain.
* * Is initialised by the initSolver method.
*/
tarch::la::Vector<DIMENSIONS,double> _domainSize;
/**
* The maximum extent a cell is allowed to have in each coordinate direction.
*
* @note This is an upper bound specified in the specification file.
* This is not the actual maximum extent of a cell.
*/
const double _maximumMeshSize;
/**
* The maximum depth the adaptive mesh is allowed
* to occupy (set by the user).
* Summing this value with _coarsestMeshdLevel results in
* the finest mesh level the solver might occupy during the
* simulation.
*/
const int _maximumAdaptiveMeshDepth;
/**
* The time stepping mode of this solver.
*/
const TimeStepping _timeStepping;
/**
* The coarsest level of the adaptive mesh that is
* occupied by this solver.
*
* @note Is set by initSolver(...) function
*/
int _coarsestMeshLevel;
/**
* The reduced global observables over the entire domain.
*/
std::vector<double> _globalObservables;
/*
* The coarsest mesh size this solver is using, i.e.
* the mesh size chosen for the uniform base grid.
*
* @note Is set by initSolver(...) function
*/
double _coarsestMeshSize;
/**
* A profiler for this solver.
*/
std::unique_ptr<profilers::Profiler> _profiler;
public:
Solver(const std::string& identifier, exahype::solvers::Solver::Type type,
int numberOfVariables, int numberOfParameters,
int numberOfGlobalObservables,
int nodesPerCoordinateAxis,
double maximumMeshSize,
int maximumAdaptiveMeshDepth,
exahype::solvers::Solver::TimeStepping timeStepping,
std::unique_ptr<profilers::Profiler> profiler =
std::unique_ptr<profilers::Profiler>(
new profilers::simple::NoOpProfiler("")));
virtual ~Solver() { _profiler->writeToConfiguredOutput(); }
// Disallow copy and assignment
Solver(const Solver& other) = delete;
Solver& operator=(const Solver& other) = delete;
virtual std::string toString() const;
virtual void toString(std::ostream& out) const;
/**
* Returns the maximum extent a mesh cell is allowed to have
* in all coordinate directions.
* This maximum mesh size is used both as a
* constraint on the AMR as well as to set up the initial
* grid. If you return the extent of the computational domain in
* each coordinate direction or larger values,
* you indicate that this solver is not active in the domain.
*
* @note This is just an upper bound on the coarsest mesh
* size. For the actual coarsest mesh size, see method
* getCoarsestMeshSize().
*
* TODO(Dominic): Rename to getUserMeshSize()?
*/
double getMaximumMeshSize() const;
/**
* The coarsest level of the adaptive mesh that is
* occupied by this solver.
*
* @note Only safe to use after initSolver(...) was called.
*/
int getCoarsestMeshLevel() const;
/**
* The coarsest mesh size this solver is using,
* i.e. the size of the cells on the uniform base grid.
*
* @note Only safe to use after initSolver(...) was called.
*
* @note This is not not the maximumMeshSize specified by the user.
*/
double getCoarsestMeshSize() const;
/**
* The maximum depth the adaptive mesh is allowed to
* occupy (set by the user).
* Summing this value with _coarsestMeshdLevel results in
* the finest mesh level the solver might occupy during the
* simulation.
*/
int getMaximumAdaptiveMeshDepth() const;
/**
* The finest level of the adaptive mesh that might be
* occupied by this solver.
*/
int getMaximumAdaptiveMeshLevel() const;
/**
* Returns the identifier of this solver.
*/
std::string getIdentifier() const;
/**
* Returns the type of this solver.
*/
Type getType() const;
/**
* Returns the time stepping algorithm this solver is using.
*/
TimeStepping getTimeStepping() const;
/**
* Returns the number of state variables.
*/
int getNumberOfVariables() const;
/**
* Returns the number of parameters, e.g.,material constants etc.
*/
int getNumberOfParameters() const;
/**
* Returns the number of global observables, e.g. indicators for AMR.
*/
int getNumberOfGlobalObservables() const;
/**
* If you use a higher order method, then this operation returns the
* polynomial degree plus one. If you use a Finite Volume method, it
* returns the number of cells within a patch per coordinate axis.
*/
int getNodesPerCoordinateAxis() const;
/**
* \see mergeMeshUpdateEvents
*
* @note Implementation must ensure thread-safety!
*/
virtual void updateMeshUpdateEvent(MeshUpdateEvent meshUpdateEvent) = 0;
/**
* Sets the _nextMeshUpdateEvent as this solver's
* current event. Furthermore resets the
* _nextMeshUpdateEvent variable.
*/
virtual void resetMeshUpdateEvent() = 0;
/**
* \return the currently set mesh update event.
*/
virtual MeshUpdateEvent getMeshUpdateEvent() const = 0;
/**
* \return true if the current mesh update event
* is either RefinementRequested or InitialRefinementRequested.
*/
bool hasRequestedAnyMeshRefinement() const;
/**
* \return minimum time stamp of all cell descriptions.
*/
virtual double getMinTimeStamp() const = 0;
/**
* \return minimum time step size of all cell descriptions computed during the last time step or
* after the last mesh refinement.
*/
virtual double getMinTimeStepSize() const = 0;
/**
* Update the admissible time step size which is computed
* as the minium of the admissible time step size of all cells.
*
* @param value a value the current minium is compared against.
*
* @note Implementation must ensure thread-safety!
*/
virtual void updateAdmissibleTimeStepSize(double value) = 0;
/**
* @return the admissible time step size which is only
* available at the end of a time step.
*
* @note Access is not thread-safe.
*/
virtual double getAdmissibleTimeStepSize() const=0;
/**
* Reset the admissible time step size to infinity in order
* to search for a minimum over all cells.
*/
virtual void resetAdmissibleTimeStepSize() = 0;
// TODO(Lukas) Is this still needed?
/*
virtual void updateNextGlobalObservables(const std::vector<double>& globalObservables);
*/
virtual std::vector<double>& getGlobalObservables();
// TODO(Lukas) Is this still needed?
/*
virtual std::vector<double>& getNextGlobalObservables();
*/
/**
* Initialise the solver's time stamps and time step sizes.
* Further use the bounding box and the already known
* maximum mesh size to compute the coarsest grid level
* this solver is placed on.
*
* @note It is very important that the domainSize
* is chosen as an multiple of the coarsest mesh size
* of all solvers within the grid.
*
* The maximum adaptive refinement level is defined
* with respect to this level.
*
* @param timeStamp the initial time stamp.
* @param domainOffset offset of the domain.
* @param domainSize size of the domain.
* @param boundingBoxSize size of the bounding box.
* @param cellsOutsideOfDomainPerDimension cells which are placed outside of the domain due to bounding box scaling.
* @param cmdlineargs command line arguments.
* @param parserView view on the specification file for the solver.
*/
virtual void initSolver(
const double timeStamp,
const tarch::la::Vector<DIMENSIONS,double>& domainOffset,
const tarch::la::Vector<DIMENSIONS,double>& domainSize,
const double boundingBoxSize,
const double boundingBoxMeshSize,
const std::vector<std::string>& cmdlineargs,
const exahype::parser::ParserView& parserView) = 0;
/**
* Notify the solver that a time step just started.
*
* @param isFirstTimeStepOfBatchOrNoBatch if this is the first time step of a batch or no batch is run.
*/
virtual void kickOffTimeStep(const bool isFirstTimeStepOfBatchOrNoBatch) = 0;
/**
* Notify the solver that a time step just finished.
*
* @param isFirstTimeStepOfBatchOrNoBatch if this is the first time step of a batch or no batch is run.
* @param isLastTimeStepOfBatchOrNoBatch if this is the last time step of a batch or if no batch is run.
*/
virtual void wrapUpTimeStep(const bool isFirstTimeStepOfBatchOrNoBatch,const bool isLastTimeStepOfBatchOrNoBatch) = 0;
/**
* \return true if the solver is computing in the current algorithmic section.
* This depends usually on internal flags of the solver such as ones indicating
* a mesh update request or a limiter domain change during a previous time stepping
* iteration.
*
* All mappings introduced for a specific job, e.g. limiting, mesh refinement etc.,
* do not rely on this method. It is used only for mappings which are shared by different
* algorithm sections. These are
* BroadcastAndMergeTimeStepData, Merging, Prediction, and TimeStepSizeComputation,
* MeshRefinement (+FinaliseMeshRefinement)
*
* E.g. a time step size computation via mapping TimeStepSizeComputation is required in
* algorithm section "LocalRecomputationAllSend" for all solvers which
* have finished a global recomputation or a mesh refinement.
* It is not required for limiting ADER-DG solvers which are currently performing
* a local recomputation.
*
*/
virtual bool isPerformingPrediction(const exahype::State::AlgorithmSection& section) const = 0;
/**
* \return true if this solver needs to merge metadata only(!) in the current algorithm section.
*/
virtual bool isMergingMetadata(const exahype::State::AlgorithmSection& section) const = 0;
/**
* In contrast to startNewTimeStep(), this
* method does not shift the time stamp.
*
* It simply updates the time step size.
*
* This method is used after a mesh refinement.
*/
virtual void updateTimeStepSize() = 0;
/**
* Roll back the minimum time stamp to the one of
* the previous time step.
*
* @note This is a global rollback which is performed happens after mesh refinement.
* The time step size then needs to be recomputed. The old one is thus not restored.
*/
virtual void rollbackToPreviousTimeStep() = 0;
/**
* If an entry for this solver exists,
* return the element index of the cell description
* in the array at address @p cellDescriptionsIndex.
* Otherwise and if @p cellDescriptionsIndex is an
* invalid index, return Solver::NotFound.
*/
virtual int tryGetElement(
const int cellDescriptionsIndex,
const int solverNumber) const = 0;
/**
* Modify a cell description in enter cell event.
* This event should be used for single cell operations
* like marking for refinement, erasing, augmenting,
* or deaugmenting.
*
* \return a struct of type bool.
*
* @note We use this at the moment only
* for refinement events. We can consider later
* on to merge the time stepping functionality
* (solution update, predictor comp.) into
* this hook.
*/
virtual bool progressMeshRefinementInEnterCell(
exahype::Cell& fineGridCell,
exahype::Vertex* const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
exahype::Cell& coarseGridCell,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
const int solverNumber,
const bool stillInRefiningMode) = 0;
/**
* Refinement routine that should be used for
* collective children-parent operations.
*
* \return If a new compute cell was introduced
* as part of a refinement operation.
*/
virtual bool progressMeshRefinementInLeaveCell(
exahype::Cell& fineGridCell,
exahype::Vertex* const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
exahype::Cell& coarseGridCell,
const tarch::la::Vector<DIMENSIONS, int>& fineGridPositionOfCell,
const int solverNumber,
const bool stillInRefiningMode) = 0;
/**
* \return if the vertices around a cell should be erased, kept,
* or refined.
*
* @param checkThoroughly If set to true, check that the indices found in the
* adjacency map are actual heap indices and that the
* geometry information of the cell descriptions found at
* the heap index indicates that these cells are adjacent
* to the vertex.
*/
virtual exahype::solvers::Solver::RefinementControl eraseOrRefineAdjacentVertices(
const int cellDescriptionsIndex,
const int solverNumber,
const tarch::la::Vector<DIMENSIONS, double>& cellOffset,
const tarch::la::Vector<DIMENSIONS, double>& cellSize,
const int level,
const bool checkThoroughly) const = 0;
/**
* Returns true if the solver has attained
* a stable state on the cell description
*
* @param fineGridCell a fine grid cell
* @param fineGridVertices vertices surrounding the fine grid cell
* @param fineGridVerticesEnumerator a enumerator for the fine grid vertices
* @param solverNumber a solver number
* @param stillInRefiningMode indicates if the mesh refinement
* is still in refining mode (true) or switched to coarsening mode (false).
*/
virtual bool attainedStableState(
exahype::Cell& fineGridCell,
exahype::Vertex* const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
const int solverNumber,
const bool stillInRefiningMode) const = 0;
/**
* This method is called after the
* mesh refinement iterations where this
* solver performs states updates in
* the enterCell() and leaveCell().
*
* This method is used to finalise some state
* updates or prepare some states for
* the time stepping or the next
* mesh update iterations.
*/
virtual void finaliseStateUpdates(
const int solverNumber,
CellInfo& cellInfo) = 0;
/////////////////////////////////////
// CELL-LOCAL
/////////////////////////////////////
/**
* Computes a new time step size and overwrites
* a cell description's time stamps and time step sizes
* with it.
*
* In contrast to startNewTimeStep(int,int), this
* method does not shift time stamps.
*
* This method is usually called after mesh refinement
* was performed.
*
* @note Has no const modifier since kernels are not const functions yet.
*/
virtual double updateTimeStepSize(const int solverNumber,CellInfo& cellInfo) = 0;
/**
* Impose initial conditions and mark for refinement.
*
* @note Make sure to reset neighbour merge
* helper variables in this method call.
*
* @note Has no const modifier since kernels are not const functions yet.
*/
virtual void adjustSolutionDuringMeshRefinement(const int solverNumber,CellInfo& cellInfo) = 0;
/**
* Fuse algorithmic phases of the solvers.
*
* FiniteVolumesSolver:
*
* This call degenerates to an updateSolution
* call for the FiniteVolumesSolver.
*
* ADERDGSolver:
*
* Runs the triad of updateSolution,performPredictionAndVolumeIntegral
* plus startNewTimeStep.
*
* LimitingADERDGSolver:
*
* Either runs the ADERDGSolver triad or
* performs an FV update. Performs some additional
* tasks.
*
* Compression
* -----------
*
* Uncompresses the data before performing PDE operations
* Compresses the data after performing PDE operations.
*
* Background Jobs
* ---------------
*
* The FiniteVolumesSolver, ADERDGSolver and LimitingADERDGSolver implementations
* show the following behaviour:
*
* - If exahype::solvers::Solver::SpawnPredictionAsBackgroundJob is set to false,
* this function will not spawn any background jobs.
*
* - If exahype::solvers::Solver::SpawnPredictionAsBackgroundJob is set to true:
*
* - This function will spawn a FusedTimeStepJob in intermediate batch iterations.
* Here, it distinguishes between skeleton and enclave cells.
* ADERDGSolver and LimitingADERDGSolver variants do not spawn a PredictionJob in this case.
*
* - This function will not a spawn a FusedTimeStepJob in the first and last iteration of
* a batch. ADERDGSolver and LimitingADERDGSolver may still spawn a PredictionJob in this case.
*
* @param[in] isFirstIterationOfBatch Indicates that we currently run no batch or
* we are in the first iteration of a batch.
* @param[in] isLastIterationOfBatch Indicates that we currently run no batch or
* we are in the last iteration of a batch.
* (If no batch is run, both flags
* @p isFirstIterationOfBatch and
* @p isLastIterationOfBatch are true).
* @param[in] isAtRemoteBoundary Flag indicating that the cell hosting the
* cell description is adjacent to a remote rank.
*/
virtual UpdateResult fusedTimeStepOrRestrict(
const int solverNumber,
CellInfo& cellInfo,
const bool isFirstIterationOfBatch,
const bool isLastIterationOfBatch,
const bool isAtRemoteBoundary) = 0;
/**
* The nonfused update routine.
*
* FiniteVolumesSolver:
*
* This call degenerates to an updateSolution
* call and a startNewTimeStep call for the FiniteVolumesSolver.
*
* ADERDGSolver:
*
* Update the solution and evaluate the refinement criterion.
*
* LimitingADERDGSolver:
*
* Update the ADER-DG and or FV solution and
* evaluate the limiter and
* the refinement criteria.
*
* @note Make sure to reset neighbour merge
* helper variables in this method call.
*
* @note Has no const modifier since kernels are not const functions yet.
*
* @param cellInfo links to the data associated with the mesh cell
* @param solverNumber id of a solver
* @param isAtRemoteBoundary indicates if this cell is adjacent to the domain of another rank
* @return see UpdateResult
*/
virtual UpdateResult updateOrRestrict(
const int solverNumber,
CellInfo& cellInfo,
const bool isAtRemoteBoundary) = 0;
/**
* Go back to previous time step with
* time step data and solution.
*
* Keep the new refinement status.
*
* Allocate necessary new limiter patches.
*/
virtual void rollbackSolutionGlobally(const int solverNumber,CellInfo& cellInfo) const = 0;
/**
* Explicitly ask the solver to compress
* a cell description.
*
* @param[in] isAtRemoteBoundary Flag indicating that the cell hosting the
* cell description is adjacent to a remote rank.
*/
virtual void compress(
const int solverNumber,
CellInfo& cellInfo,
const bool isAtRemoteBoundary) const = 0;
///////////////////////////////////
// NEIGHBOUR
///////////////////////////////////
#ifdef Parallel
/**
* On coarser grids, the solver can hint on the eventual load and memory distribution
* with this function.
*
* @note Only called on coarser grids by LoadBalancing mapping.
* @note Only invokes user callback during initial mesh refinement.
*
* @param cellCentre the cell centre.
* @param cellSize the cell size.
* @return Estimate of the load based on the geometry.
*/
int computeGeometricLoadBalancingWeight(
const tarch::la::Vector<DIMENSIONS,double>& cellCentre,
const tarch::la::Vector<DIMENSIONS,double>& cellSize);
/**
* If a cell description was allocated at heap address @p cellDescriptionsIndex
* for solver @p solverNumber, encode metadata of the cell description
* and push it to the back of the metadata vector @p metadata.
*
* Otherwise, push exahype::NeighbourCommunicationMetadataPerSolver
* times exahype::InvalidMetadataEntry to the back of the vector.
*/
virtual void appendNeighbourCommunicationMetadata(
MetadataHeap::HeapEntries& metadata,
const tarch::la::Vector<DIMENSIONS,int>& src,
const tarch::la::Vector<DIMENSIONS,int>& dest,
const int cellDescriptionsIndex,
const int solverNumber) const = 0;
///////////////////////////////////
// WORKER<=>MASTER
///////////////////////////////////
/**
* Finishes outstanding refinement operations
* and sends solution data down to the worker
* if required.
*/
virtual void progressMeshRefinementInPrepareSendToWorker(
const int workerRank,
exahype::Cell& fineGridCell,
exahype::Vertex* const fineGridVertices,
const peano::grid::VertexEnumerator& fineGridVerticesEnumerator,
exahype::Cell& coarseGridCell,
const peano::grid::VertexEnumerator& coarseGridVerticesEnumerator,
const int solverNumber) = 0;
/**
* Just receive data or not from the master
* depending on the refinement event.
*/
virtual void sendDataToWorkerIfProlongating(
const int toRank,
const int cellDescriptionsIndex,
const int element,
const tarch::la::Vector<DIMENSIONS, double>& x,
const int level) const = 0;
/**
* Just receive data or not from the master
* depending on the refinement event.
*/
virtual void receiveDataFromMasterIfProlongating(
const int masterRank,
const int receivedCellDescriptionsIndex,
const int receivedElement,
const tarch::la::Vector<DIMENSIONS,double>& x,
const int level) const = 0;
/**
* Finish prolongation operations started on the master.
*/
virtual bool progressMeshRefinementInMergeWithWorker(
const int localCellDescriptionsIndex,
const int receivedCellDescriptionsIndex, const int receivedElement) = 0;
/**
* Finish erasing operations on the worker side and
* send data up to the master if necessary.
* This data is then picked up to finish restriction
* operations.
*/
virtual void progressMeshRefinementInPrepareSendToMaster(
const int masterRank,
const int cellDescriptionsIndex, const int element,
const tarch::la::Vector<DIMENSIONS,double>& x,
const int level) const = 0;
/**
* Finish erasing operations started on the master which
* require data from the worker.
*
* Veto erasing requests from the coarse grid cell as well.
*/
virtual bool progressMeshRefinementInMergeWithMaster(
const int worker,
const int localCellDescriptionsIndex,
const int localElement,
const int coarseGridCellDescriptionsIndex,
const tarch::la::Vector<DIMENSIONS, double>& x,
const int level,
const bool stillInRefiningMode) = 0;
/**
* If a cell description was allocated at heap address @p cellDescriptionsIndex
* for solver @p solverNumber, encode metadata of the cell description
* and push it to the back of the metadata vector @p metadata.
*
* Otherwise, push exahype::MasterWorkerCommunicationMetadataPerSolver
* times exahype::InvalidMetadataEntry to the back of the vector.
*
*/
virtual void appendMasterWorkerCommunicationMetadata(
MetadataHeap::HeapEntries& metadata,
const int cellDescriptionsIndex,
const int solverNumber) const = 0;
/**
* Send solver data to master or worker rank. Read the data from
* the cell description @p element in
* the cell descriptions vector stored at @p
* cellDescriptionsIndex.
*
* @param[in] element Index of the cell description
* holding the data to send out in
* the array with address @p cellDescriptionsIndex.
* This is not the solver number.
*/
virtual void sendDataToWorkerOrMasterDueToForkOrJoin(
const int toRank,
const int cellDescriptionsIndex,
const int element,
const peano::heap::MessageType& messageType,
const tarch::la::Vector<DIMENSIONS, double>& x,
const int level) const = 0;
/**
* Merge with solver data from master or worker rank
* that was sent out due to a fork or join. Wrote the data to
* the cell description @p element in
* the cell descriptions vector stored at @p
* cellDescriptionsIndex.
*
* @param[in] element Index of the cell description
* holding the data to send out in
* the array with address @p cellDescriptionsIndex.
* This is not the solver number.
*/
virtual void mergeWithWorkerOrMasterDataDueToForkOrJoin(
const int fromRank,
const int cellDescriptionsIndex,
const int element,
const peano::heap::MessageType& messageType,
const tarch::la::Vector<DIMENSIONS, double>& x,
const int level) const = 0;
///////////////////////////////////
// WORKER->MASTER
///////////////////////////////////
/**
* Send data to the master that is not
* depending on a particular cell description.
*
* This operation might be used for the reduction of a global
* minimum time step size over all MPI ranks.
*
* @note We always assume that
* startNewTimeStep() has been already called on the
* local solver instance. You thus
* have to return the updated local time step size.
*
* \see startNewTimeStep(), mergeWithWorkerData()
*/
virtual void sendDataToMaster(
const int masterRank,
const tarch::la::Vector<DIMENSIONS, double>& x,
const int level) const = 0;
/**
* Merge with solver data from worker rank.
*/
virtual void mergeWithWorkerData(
const int workerRank,
const tarch::la::Vector<DIMENSIONS, double>& x,
const int level) = 0;
/*
* Send the rank-local mesh update event to
* the master.
*
* At the time of sending data to the master,
* we have already set the next
* mesh update event locally.
* We thus need to communicate the
* current mesh update event to the master.
*/
void sendMeshUpdateEventToMaster(
const int masterRank,
const tarch::la::Vector<DIMENSIONS, double>& x,
const int level) const;
/**
* Merge with the worker's mesh update event.
*
* The master has not yet swapped
* the current event with the next event yet.
* This will happen after the merge.
*/
void mergeWithWorkerMeshUpdateEvent(
const int workerRank,
const tarch::la::Vector<DIMENSIONS, double>& x,
const int level);
///////////////////////////////////
// MASTER->WORKER
///////////////////////////////////
/**
* Send data to the worker that is not
* depending on a particular cell description.
*
* This operation might be used for the synchronisation
* of a global minimum time step size over all MPI ranks.
*
* \see startNewTimeStep(), mergeWithMasterData()
*/
virtual void sendDataToWorker(
const int workerRank,
const tarch::la::Vector<DIMENSIONS, double>& x,
const int level) const = 0;
/**
* Merge with solver data from master rank.
*/
virtual void mergeWithMasterData(
const int masterRank,
const tarch::la::Vector<DIMENSIONS, double>& x,
const int level) = 0;
#endif
/**
* Maps the solution values Q to
* the global observables.
*
* As we can observe all state variables,
* we interpret an 'observable' here as
* 'worthy to be observed'.
*
*\param[inout] globalObservables The mapped observables.
*\param[in] Q The state variables.
*/
virtual std::vector<double> mapGlobalObservables(const double* const Q,
const tarch::la::Vector<DIMENSIONS,double>& dx) const = 0;
/**
* Resets the vector of global observables to some suitable initial value, e.g.
* the smallest possible double if one wants to compute the maximum.
*
*\param[out] globalObservables The mapped observables.
*/
virtual std::vector<double> resetGlobalObservables() const = 0;
/**
* Function that reduces the global observables.
* For example, if one wants to compute the maximum of global variables
* one should set
* reducedGlobalObservables[0] = std::max(reducucedGlobalObservables[i],
* curGlobalObservables[0])
*
* and so on.
*
*\param[inout] reducedGlobalObservables The reduced observables.
*\param[in] curGlobalObservables The current vector of global observables.
*/
virtual void reduceGlobalObservables(
std::vector<double>& reducedGlobalObservables,
const std::vector<double>& curGlobalObservables) const = 0;
virtual void reduceGlobalObservables(std::vector<double>& globalObservables,
CellInfo cellInfo,
int solverNumber) const = 0;
///////////////////////
// PROFILING
///////////////////////
/**
* A struct holding averaged runtime measurements for different cell types.
*/
typedef struct CellProcessingTimes {
double _minTimePredictor = std::numeric_limits<double>::quiet_NaN(); ///> The time (sec) required to run a single ADERDG space-time predictor Picard iteration.
double _maxTimePredictor = std::numeric_limits<double>::quiet_NaN(); ///> The time (sec) required to run order+1 ADERDG space-time predictor Picard iterations.
double _timeADERDGUpdate = std::numeric_limits<double>::quiet_NaN(); ///> The time (sec) to process a (pure) ADER-DG cell minus the predictor computation (plus evaluating the limiting criterion in the LimitingADERDGSolver case).
double _timeADERDG2FVUpdate = std::numeric_limits<double>::quiet_NaN(); ///> The time (sec) to process an ADER-DG cell minus the predictor computation which additionally projects the DG solution into FV space (plus evaluating the limiting criterion), i.e. only one Picard iteration is used.
double _timeFV2ADERDGUpdate = std::numeric_limits<double>::quiet_NaN(); ///> The time (sec) to process an FV cell which additionally projects the FV solution into DG space (plus evaluating the limiting criterion), i.e. only one Picard iteration is used.
double _timeFVUpdate = std::numeric_limits<double>::quiet_NaN(); ///> The time (sec) to process an FV cell (plus evaluating the limiting criterion in the LimitingADERDGsolver case).
void toString(std::ostream& out,const double conversion=1.0,const int precision=8,std::string unit="sec",std::string prefix="") const {
out.precision(precision);
out << prefix << "minTimePredictor = "<<std::setw(12)<<std::fixed<<_minTimePredictor *conversion<<" "<<unit<<std::endl;
out << prefix << "maxTimePredictor = "<<std::setw(12)<<std::fixed<<_maxTimePredictor *conversion<<" "<<unit<<std::endl;
out << prefix << "timeADERDGUpdate = "<<std::setw(12)<<std::fixed<<_timeADERDGUpdate *conversion<<" "<<unit<<std::endl;
out << prefix << "timeADERDG2FVUpdate = "<<std::setw(12)<<std::fixed<<_timeADERDG2FVUpdate*conversion<<" "<<unit<<std::endl;
out << prefix << "timeFV2ADERDGUpdate = "<<std::setw(12)<<std::fixed<<_timeFV2ADERDGUpdate*conversion<<" "<<unit<<std::endl;
out << prefix << "timeFVUpdate = "<<std::setw(12)<<std::fixed<<_timeFVUpdate *conversion<<" "<<unit<<std::endl;
}
} CellProcessingTimes;
/**
* We perform @p numberOfRuns runs per cell type.
*
* @note Must be called after exahype::solvers::Solver::initSolver(...)
* was called for this solver. As we need to process the
*
* @note Precondition: SwitchOffNeighbourMergePerformedCheck must be set to true before
* measuring the cell processing times.
*
* @note No const modifier as kernels are not const.
*
* @param numberOfRuns the number of measurements to perform for each cell type
*
* @return @see exahype::solvers::Solver::CellProcessingTimes
*/
virtual CellProcessingTimes measureCellProcessingTimes(const int numberOfRuns=100) { return CellProcessingTimes(); }
/** @defgroup userHooks User Hooks
* Hooks for user solvers
* @{
*/
protected:
/**
* On coarser grids, the solver can hint on the eventual load or memory distribution
* with this function.
*
* @note Only called on coarser grids by LoadBalancing mapping.
* @note Only invokes user callback during initial mesh refinement (time stamp = 0).
* @note LimitingADERDGSolver will invoke the main solvers routine.
*
* @param cellCentre the cell centre.
* @param cellSize the cell size.
* @return Estimate of the load based on the geometry.
*/
virtual int getGeometricLoadBalancingWeight(
const tarch::la::Vector<DIMENSIONS,double>& cellCentre,
const tarch::la::Vector<DIMENSIONS,double>& cellSize) { return 1; }
public:
/**
* Signals a user solver that ExaHyPE just started a new time step.
*
* @param[in] minTimeStamp the minimum time stamp (over all cells)
*
* @note This function is invoked before the first predictor computation
* when the non fused time stepping is run. Otherwise, it is invoked after
* the first predictor computation. It will always be called before
* "adjustSolution" is invoked.
*
* @note [MPI] Do not use collective MPI operations in here. Not all ranks call this function.
*
* @note [MPI] If you perform broadcasts via MPI primitives in here, ensure
* that isFirstTimeStepOfBatchOrNoBatch is set to true in order to not synchronise
* the MPI ranks during batched time steps.
*/
virtual void beginTimeStep(const double minTimeStamp,const bool isFirstTimeStepOfBatchOrNoBatch) {}
/**
* Signals a user solver that ExaHyPE just finished a time step.
*
* @param[in] minTimeStamp the minimum time stamp (over all cells)
*
* @note This function is invoked after the solution was updated in all
* cells.
*
* @note [MPI] Do not use collective MPI operations in here. Not all ranks call this function.
*
* @note [MPI] If you perform reductions via MPI primitives in here, ensure
* that isLastTimeStepOfBatchOrNoBatch is set to true in order to not synchronise
* the MPI ranks during batched time steps.
*
* @param isFirstTimeStepOfBatchOrNoBatch if this is the first time step of a batch or no batch is run.
* @param isLastTimeStepOfBatchOrNoBatch if this is the last time step of a batch or if no batch is run.
*/
virtual void endTimeStep(const double minTimeStamp,const bool isLastTimeStepOfBatchOrNoBatch) {}
/** @} */ // end of userHooks
};
#endif
| [
"reinarz@in.tum.de"
] | reinarz@in.tum.de |
78a20a2e5af09fa2403aa93983c1f79c7289ed94 | ded208ac8c9ff885f3e07eb5b74fe2b550dc533d | /cpp/src/gandiva/like_holder_test.cc | 3e3cd37c4fed15ed0ae4c5becd949ae38bacd6b4 | [
"Apache-2.0",
"CC0-1.0",
"MIT",
"BSD-3-Clause",
"BSL-1.0",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause"
] | permissive | pdxtrader/arrow | d9b1d0d62b91337e95649e793fe309de0b3ebb57 | 4fbbffa3fab81fb4b4c483f01090a7740cf4f448 | refs/heads/master | 2020-04-04T04:58:52.088927 | 2018-11-01T14:19:10 | 2018-11-01T14:19:10 | 155,731,798 | 1 | 1 | Apache-2.0 | 2018-11-01T14:58:50 | 2018-11-01T14:58:49 | null | UTF-8 | C++ | false | false | 3,908 | cc | // Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
#include "gandiva/like_holder.h"
#include "gandiva/regex_util.h"
#include <memory>
#include <vector>
#include <gtest/gtest.h>
namespace gandiva {
class TestLikeHolder : public ::testing::Test {
public:
FunctionNode BuildLike(std::string pattern) {
auto field = std::make_shared<FieldNode>(arrow::field("in", arrow::utf8()));
auto pattern_node =
std::make_shared<LiteralNode>(arrow::utf8(), LiteralHolder(pattern), false);
return FunctionNode("like", {field, pattern_node}, arrow::boolean());
}
};
TEST_F(TestLikeHolder, TestMatchAny) {
std::shared_ptr<LikeHolder> like_holder;
auto status = LikeHolder::Make("ab%", &like_holder);
EXPECT_EQ(status.ok(), true) << status.message();
auto& like = *like_holder;
EXPECT_TRUE(like("ab"));
EXPECT_TRUE(like("abc"));
EXPECT_TRUE(like("abcd"));
EXPECT_FALSE(like("a"));
EXPECT_FALSE(like("cab"));
}
TEST_F(TestLikeHolder, TestMatchOne) {
std::shared_ptr<LikeHolder> like_holder;
auto status = LikeHolder::Make("ab_", &like_holder);
EXPECT_EQ(status.ok(), true) << status.message();
auto& like = *like_holder;
EXPECT_TRUE(like("abc"));
EXPECT_TRUE(like("abd"));
EXPECT_FALSE(like("a"));
EXPECT_FALSE(like("abcd"));
EXPECT_FALSE(like("dabc"));
}
TEST_F(TestLikeHolder, TestPcreSpecial) {
std::shared_ptr<LikeHolder> like_holder;
auto status = LikeHolder::Make(".*ab_", &like_holder);
EXPECT_EQ(status.ok(), true) << status.message();
auto& like = *like_holder;
EXPECT_TRUE(like(".*abc")); // . and * aren't special in sql regex
EXPECT_FALSE(like("xxabc"));
}
TEST_F(TestLikeHolder, TestRegexEscape) {
std::string res;
auto status = RegexUtil::SqlLikePatternToPcre("#%hello#_abc_def##", '#', res);
EXPECT_TRUE(status.ok()) << status.message();
EXPECT_EQ(res, "%hello_abc.def#");
}
TEST_F(TestLikeHolder, TestOptimise) {
// optimise for 'starts_with'
auto fnode = LikeHolder::TryOptimize(BuildLike("xy 123z%"));
EXPECT_EQ(fnode.descriptor()->name(), "starts_with");
EXPECT_EQ(fnode.ToString(), "bool starts_with((utf8) in, (const string) xy 123z)");
// optimise for 'ends_with'
fnode = LikeHolder::TryOptimize(BuildLike("%xyz"));
EXPECT_EQ(fnode.descriptor()->name(), "ends_with");
EXPECT_EQ(fnode.ToString(), "bool ends_with((utf8) in, (const string) xyz)");
// no optimisation for others.
fnode = LikeHolder::TryOptimize(BuildLike("xyz_"));
EXPECT_EQ(fnode.descriptor()->name(), "like");
fnode = LikeHolder::TryOptimize(BuildLike("_xyz"));
EXPECT_EQ(fnode.descriptor()->name(), "like");
fnode = LikeHolder::TryOptimize(BuildLike("%xyz%"));
EXPECT_EQ(fnode.descriptor()->name(), "like");
fnode = LikeHolder::TryOptimize(BuildLike("_xyz_"));
EXPECT_EQ(fnode.descriptor()->name(), "like");
fnode = LikeHolder::TryOptimize(BuildLike("%xyz_"));
EXPECT_EQ(fnode.descriptor()->name(), "like");
fnode = LikeHolder::TryOptimize(BuildLike("x_yz%"));
EXPECT_EQ(fnode.descriptor()->name(), "like");
}
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
} // namespace gandiva
| [
"wesm+git@apache.org"
] | wesm+git@apache.org |
a9f853b0ab431b802e76a83be3d9166d316301f1 | 59e693a8d161e7279b52d813bf850a7d5b528963 | /UntitledGame/src/Camera.cpp | 3139c4f893efb72aeb0c8ae0c642236b49910402 | [] | no_license | BryanArvizu/UntitledGame | ab1d2daa086884cb75ad9cccf745c75b1dc095b9 | 14f7a2020af8ad2115bc2c69e590668f5b37c521 | refs/heads/master | 2023-03-12T05:32:59.479821 | 2021-03-04T05:04:32 | 2021-03-04T05:04:32 | 330,850,348 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,608 | cpp | #include "Camera.h"
#include "Entity.h"
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
ret::Camera::Camera(glm::vec3 t_pos, glm::vec3 t_rot)
{
posOffset = t_pos;
rotation = t_rot;
worldUp_ = glm::vec3(0, 1, 0);
UpdateCameraVectors();
}
glm::mat4 ret::Camera::GetViewMatrix()
{
if (entity != nullptr)
{
return glm::lookAt(posOffset + entity->transform.position, posOffset + entity->transform.position + front_, up_);
}
else
return glm::lookAt(posOffset, posOffset + front_, up_);
}
void ret::Camera::Rotate(float t_xoffset, float t_yoffset, GLboolean t_constrainPitch)
{
// There may be a bug with the math here, where higher sensitivities make the camera wonky
rotation.x = glm::mod(rotation.x + t_yoffset, 360.0f);
rotation.y = glm::mod(rotation.y + t_xoffset, 360.0f);
//std::cout << "YAW: " << yaw << " | " << "PITCH: " << pitch << std::endl;
if (t_constrainPitch)
{
if (rotation.y < 180.0f)
rotation.y = glm::clamp(rotation.y, -89.0f, 89.0f);
else
rotation.y = glm::clamp(rotation.y, 271.0f, 449.0f);
}
UpdateCameraVectors();
}
void ret::Camera::UpdateCameraVectors()
{
glm::vec3 tFront;
tFront.x = cos(glm::radians(rotation.y)) * cos(glm::radians(rotation.x));
tFront.y = sin(glm::radians(rotation.x));
tFront.z = sin(glm::radians(rotation.y)) * cos(glm::radians(rotation.x));
front_ = glm::normalize(tFront);
if (rotation.x < 270.0f && rotation.x > 90.0f)
right_ = glm::normalize(glm::cross(front_, -worldUp_));
else
right_ = glm::normalize(glm::cross(front_, worldUp_));
up_ = glm::normalize(glm::cross(right_, front_));
}
| [
"35119502+BryanArvizu@users.noreply.github.com"
] | 35119502+BryanArvizu@users.noreply.github.com |
360fc8131b55959b7316b53a05e13037476ce6b1 | 731fecff33f3a58575be62bce88f86a0d8314dd1 | /include/DGL/Vector3D.h | e944bf8707b2d3ce5cc33334129b317ffb651c05 | [] | no_license | Dagal/libDGL | 5e227461aaeaf1bc225ae95d90037937b129fee2 | 9131da0434bc7ad51597fcb5ab5a5a0db78c87b2 | refs/heads/master | 2021-01-01T18:12:07.840338 | 2015-11-15T17:05:09 | 2015-11-15T17:05:09 | 18,449,448 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 649 | h | /*
* Vector3D.h
*
* Created on: 25 janv. 2014
* Author: dagal
*/
#ifndef VECTOR3D_H_
#define VECTOR3D_H_
#include "Double.h"
namespace DGL
{
class Vector3D
{
public:
Vector3D();
virtual ~Vector3D();
const Double& getX() const {return mX;};
const Double& getY() const {return mY;};
const Double& getZ() const {return mZ;};
void set(const Double& x, const Double& y, const Double& z) {mX=x; mY=y; mZ=z;};
void setX(const Double& x) {mX = x;};
void setY(const Double& y) {mY = y;};
void setZ(const Double& z) {mZ = z;};
private:
Double mX;
Double mY;
Double mZ;
};
}
#endif /* VECTOR3D_H_ */
| [
"dejarding@gmail.com"
] | dejarding@gmail.com |
545b9993e1e92d9ea8f1ab5942cff96e7d494058 | 51c8e6ede1dd181e4f61764249d8abafdecd05ac | /SimCore/model/Timer/Timer.h | 7eb80a7f3d65d73e8cc8dff331423eab2ee5774a | [
"Apache-2.0"
] | permissive | kino-6/BuiltInSystemSimulator | d59022121d170884909121d67c97a327591afdac | 63d447f89c0c9166b93a96844d2d103f9d00a4b2 | refs/heads/main | 2023-08-28T04:05:15.638756 | 2021-09-25T10:54:48 | 2021-09-25T10:54:48 | 336,766,244 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 663 | h | #pragma once
#include "BaseModel.h"
class Timer :
public BaseModel
{
public:
std::vector<uint64_t> Timers;
uint64_t ticks;
public:
Timer(void);
void reset(void);
void reset(SimTimerIdx idx);
void set(SimTimerIdx idx, uint_fast64_t val);
void set_ticks(uint_fast64_t val);
uint_fast64_t get_ticks(SimTimerIdx idx);
void tick(void);
void tick(SimTimerIdx idx, uint_fast64_t val);
bool is_time_out(SimTimerIdx idx, uint_fast64_t val);
///////////////////////////////////////////////////////////////////////////
void Main(void);
void Reset(void);
///////////////////////////////////////////////////////////////////////////
~Timer(void);
};
| [
"mutamuta3@gmail.com"
] | mutamuta3@gmail.com |
5a9d602e8daf7001216822a8218924184843901a | 10606791359a12f24f631daf475405c0390f112b | /OpenCV/c++/csv/csv2xml.cpp | fe14aca8de39861ce692880bebe66ed3e06e2f1d | [] | no_license | DavidChan0519/exercise | b185be9ebcc932890e699dca6e75390700541eb3 | 39f6d876ad21eaa79e0e5c94d95c613c9eccb65e | refs/heads/master | 2020-03-19T01:11:30.731817 | 2018-05-31T03:52:38 | 2018-05-31T04:15:08 | 135,528,665 | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 1,733 | cpp | #include<opencv2/opencv.hpp>
#include<iostream>
using namespace std;
using namespace cv;
int main()
{
CvMLData mlData;
mlData.read_csv("train.csv");//¶ÁÈ¡csvÎļþ
Mat data = cv::Mat(mlData.get_values(), true);
cout << "Data have been read successfully!" << endl;
//Mat double_data;
//data.convertTo(double_data, CV_64F);
Mat input_ = data(Rect(1, 1, 784, data.rows - 1)).t();
Mat label_ = data(Rect(0, 1, 1, data.rows - 1));
Mat target_(10, input_.cols, CV_32F, Scalar::all(0.));
Mat digit(28, 28, CV_32FC1);
Mat col_0 = input_.col(3);
float label0 = label_.at<float>(3, 0);
cout << label0;
for (int i = 0; i < 28; i++)
{
for (int j = 0; j < 28; j++)
{
digit.at<float>(i, j) = col_0.at<float>(i * 28 + j);
}
}
for (int i = 0; i < label_.rows; ++i)
{
float label_num = label_.at<float>(i, 0);
//target_.at<float>(label_num, i) = 1.;
target_.at<float>(label_num, i) = label_num;
}
Mat input_normalized(input_.size(), input_.type());
for (int i = 0; i < input_.rows; ++i)
{
for (int j = 0; j < input_.cols; ++j)
{
//if (input_.at<double>(i, j) >= 1.)
//{
input_normalized.at<float>(i, j) = input_.at<float>(i, j) / 255.;
//}
}
}
string filename = "input_label_0-9.xml";
FileStorage fs(filename, FileStorage::WRITE);
fs << "input" << input_normalized;
fs << "target" << target_; // Write cv::Mat
fs.release();
Mat input_1000 = input_normalized(Rect(0, 0, 10000, input_normalized.rows));
Mat target_1000 = target_(Rect(0, 0, 10000, target_.rows));
string filename2 = "input_label_0-9_10000.xml";
FileStorage fs2(filename2, FileStorage::WRITE);
fs2 << "input" << input_1000;
fs2 << "target" << target_1000; // Write cv::Mat
fs2.release();
return 0;
}
| [
"wei.cheng@bitmain.com"
] | wei.cheng@bitmain.com |
d4afc7f9b8211c1bf1c8eb05d4ffdadf5e0b6f27 | 8d1ee4bfb88b5f884d23a14cc83799b79904a7b0 | /rainfall.cpp | d556d20d1ae2387e446000ef376ed5faee18d886 | [] | no_license | mojoe12/UVa | aefb2020fe3b48c115557be131acb62ede08f5dc | dba57e95b3f387b187a872620ae9e72290fa1a61 | refs/heads/master | 2021-01-23T01:45:54.335619 | 2017-09-29T02:22:29 | 2017-09-29T02:22:29 | 92,890,593 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 471 | cpp | #include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <iomanip>
using namespace std;
int main() {
int k;
cin >> k;
while (k--) {
double l, k, t1, t2, h;
cin >> l >> k >> t1 >> t2 >> h;
double x = h + t2 * k;
double r = sqrt(x * x - 4 * t1 * l * k);
double rmin = (x - r) / (2 * t1);
double rmax = (x + r) / (2 * t1);
cout << setprecision(6) << fixed << rmin;
cout << ' ' << fixed << rmax << endl;
}
}
| [
"josephahutter@gmail.com"
] | josephahutter@gmail.com |
6393fc19999dd5499111ac39570aa179846ba360 | 1558823dc262eb742acaeaeda87a7a31f5b9ed3a | /OpenGL Shaders/OpenGL Shaders/WEngine/Water/WaterShaderProgram.cpp | ea97f76ed27a29a39f2f5b005f7316c1068ec90b | [] | no_license | OlivierLindenbergh/Eindproject | be7df9c2bb62fcda701ac0f0ad3340a11dc79154 | 0ae8b57e26f0cb3ff8087342d4f6a6b4e74ba606 | refs/heads/master | 2020-07-24T02:04:57.054548 | 2017-01-24T23:49:16 | 2017-01-24T23:49:16 | 73,798,435 | 0 | 0 | null | 2017-01-24T23:49:17 | 2016-11-15T09:35:11 | HTML | UTF-8 | C++ | false | false | 8,005 | cpp | #include "../header.h"
#include "WaterShaderProgram.h"
//Constuctor
WaterShaderProgram::WaterShaderProgram()
{}
//Destuctor
WaterShaderProgram::~WaterShaderProgram()
{
//Cleanup the shader
cleanUp();
}
void WaterShaderProgram::load(char vertexFile[], char fragmentFile[])
{
//Get Shader sources
vertexShaderID = loadShader(vertexFile, GL_VERTEX_SHADER);
fragmentShaderID = loadShader(fragmentFile, GL_FRAGMENT_SHADER);
//Create a program for the shaders
programID = glCreateProgram();
//Attach the shader sources to the program
glAttachShader(programID, vertexShaderID);
glAttachShader(programID, fragmentShaderID);
//Bind in variables
bindAttribute(0, "position"); //Bind position variable to VAO position 0
//Link the program
glLinkProgram(programID);
GLint success;
glGetProgramiv(programID, GL_LINK_STATUS, &success);
if (!success)
{
GLchar infoLog[512];
glGetProgramInfoLog(programID, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
}
//Validate the program
glValidateProgram(programID);
//Get all the uniform locations
location_transformationMatrix = getUniformLocation("transformationMatrix");
location_projectionMatrix = getUniformLocation("projectionMatrix");
location_viewMatrix = getUniformLocation("viewMatrix");
location_reflectiontexture = getUniformLocation("reflectionTexture0");
location_refractiontexture = getUniformLocation("refractionTexture1");
location_dudvMap = getUniformLocation("dudvMap");
location_normalMap = getUniformLocation("normalMap");
location_depthMap = getUniformLocation("depthMap");
location_moveFactor = getUniformLocation("moveFactor");
location_cameraPosition = getUniformLocation("cameraPosition");
location_shineDamper = getUniformLocation("shineDamper");
location_reflectivity = getUniformLocation("reflectivity");
location_ambientLight = getUniformLocation("ambientLight");
location_skyColour = getUniformLocation("skyColour");
for (int i = 0; i < MAX_LIGHTS; i++) {
location_lightPosition[i] = getUniformLocation("lightPosition[" + std::to_string(i) + "]");
location_lightColour[i] = getUniformLocation("lightColour[" + std::to_string(i) + "]");
location_attenuation[i] = getUniformLocation("attenuation[" + std::to_string(i) + "]");
}
// Detach and delete the shaders as the program is already compiled
glDetachShader(programID, vertexShaderID);
glDetachShader(programID, fragmentShaderID);
glDeleteShader(vertexShaderID);
glDeleteShader(fragmentShaderID);
printf("WaterShader Loaded\n");
}
//Start using this shader
void WaterShaderProgram::start()
{
glUseProgram(programID);
}
//Stop using this shader
void WaterShaderProgram::stop()
{
glUseProgram(0);
}
//Clean this shader up
void WaterShaderProgram::cleanUp()
{
//Stop using the shader if active
stop();
glDetachShader(programID, vertexShaderID);
glDetachShader(programID, fragmentShaderID);
glDeleteShader(vertexShaderID);
glDeleteShader(fragmentShaderID);
glDeleteProgram(programID);
}
//Set the ambient light of the object
void WaterShaderProgram::loadAmbientLight(float ambient) {
loadFloat(location_ambientLight, ambient);
}
//Load the transformation matrix in the shader
void WaterShaderProgram::loadTransformationMatrix(glm::mat4 matrix)
{
loadMatrix(location_transformationMatrix, matrix);
}
//Load the projection matrix in the shader
void WaterShaderProgram::loadProjectionMatrix(glm::mat4 matrix)
{
loadMatrix(location_projectionMatrix, matrix);
}
//Load the view matrix in the shader
void WaterShaderProgram::loadViewMatrix(glm::mat4 matrix)
{
loadMatrix(location_viewMatrix, matrix);
}
//Load the shineVariables in the shader. For specular lighting
void WaterShaderProgram::loadShineVariables(float damper, float reflectivity)
{
loadFloat(location_shineDamper, damper);
loadFloat(location_reflectivity, reflectivity);
}
//Load fake lighting in the shader. If true all normals are upward.
void WaterShaderProgram::loadFakeLighting(bool fakeLighting) {
loadBoolean(location_useFakeLighting, fakeLighting);
}
//Set skyColour for fog
void WaterShaderProgram::loadSkyColour(glm::vec3 colour) {
loadVector(location_skyColour, colour);
}
//Load a light
void WaterShaderProgram::loadLights(std::vector<Light*> lights) {
for (int i = 0; i < MAX_LIGHTS; i++) {
if (i < lights.size()) {
loadVector(location_lightPosition[i], lights[i]->getPosition());
loadVector(location_lightColour[i], lights[i]->getColour());
loadVector(location_attenuation[i], lights[i]->getAttenuation());
}
else {
loadVector(location_lightPosition[i], glm::vec3(0, 0, 0));
loadVector(location_lightColour[i], glm::vec3(0, 0, 0));
loadVector(location_attenuation[i], glm::vec3(1, 0, 0));
}
}
}
void WaterShaderProgram::connectTextureUnits()
{
loadInt(location_reflectiontexture, 1);
loadInt(location_refractiontexture, 2);
loadInt(location_dudvMap, 3);
loadInt(location_normalMap, 4);
loadInt(location_depthMap, 5);
}
void WaterShaderProgram::loadMoveFactor(float factor)
{
loadFloat(location_moveFactor, factor);
}
void WaterShaderProgram::loadCameraPosition(glm::vec3 pos)
{
loadVector(location_cameraPosition, pos);
}
//Get the source of a file and create a shader id
GLuint WaterShaderProgram::loadShader(char file[], GLenum type)
{
//Retrieve the source code from file
std::string source;
std::ifstream shaderFile;
// ensures ifstream objects can throw exceptions:
shaderFile.exceptions(std::ifstream::badbit);
try
{
// Open files
shaderFile.open(file);
std::stringstream shaderStream;
// Read file's buffer contents into streams
shaderStream << shaderFile.rdbuf();
// close file handlers
shaderFile.close();
// Convert stream into string
source = shaderStream.str();
}
catch (std::ifstream::failure e)
{
std::cout << "ERROR::SHADER::FILE_NOT_SUCCESFULLY_READ" << std::endl;
}
const GLchar* shaderCode = source.c_str();
//Debug shaderCode
//printf("%s\n", shaderCode);
//Compile shaders
GLuint shaderID;
// Create Shader
shaderID = glCreateShader(type);
glShaderSource(shaderID, 1, &shaderCode, NULL);
glCompileShader(shaderID);
// Print compile errors if any
GLint success;
glGetShaderiv(shaderID, GL_COMPILE_STATUS, &success);
if (!success)
{
GLchar infoLog[512];
glGetShaderInfoLog(shaderID, 512, NULL, infoLog);
std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl;
}
return shaderID;
}
//Bind attribute of VAO to a variable in the shader
void WaterShaderProgram::bindAttribute(int attribute, char variableName[])
{
glBindAttribLocation(programID, attribute, variableName);
}
//Get the location of a unform by name
GLuint WaterShaderProgram::getUniformLocation(std::string uniformName)
{
return glGetUniformLocation(programID, uniformName.c_str());
}
void WaterShaderProgram::loadInt(GLuint location, GLuint value) {
glUniform1i(location, value);
}
//Load a float in the shader at uniform location
void WaterShaderProgram::loadFloat(GLuint location, GLfloat value) {
glUniform1f(location, value);
}
//Load a vector4 in the shader at uniform location
void WaterShaderProgram::loadVector(GLuint location, glm::vec4 vector) {
glUniform4f(location, vector.x, vector.y, vector.z, vector.w);
}
//Load a vector3 in the shader at uniform location
void WaterShaderProgram::loadVector(GLuint location, glm::vec3 vector) {
glUniform3f(location, vector.x, vector.y, vector.z);
}
//Load a vector2 in the shader at uniform location
void WaterShaderProgram::loadVector(GLuint location, glm::vec2 vector) {
glUniform2f(location, vector.x, vector.y);
}
//Load a boolean in the shader at uniform location
void WaterShaderProgram::loadBoolean(GLuint location, bool value) {
float toLoad = 0;
if (value) toLoad = 1;
glUniform1f(location, toLoad);
}
//Load a matrix in the shader at uniform location
void WaterShaderProgram::loadMatrix(GLuint location, glm::mat4 matrix) {
glUniformMatrix4fv(location, 1, GL_FALSE, glm::value_ptr(matrix));
} | [
"olie_vier@hotmail.com"
] | olie_vier@hotmail.com |
775237123f443b651f1a702542ebdaa0cbd20800 | 48c3f0860c8c7e117ae1867a7660ff4affcb3d27 | /include/lsst/afw/image/Exposure.h | 937768d7a5a0de08f6d856378043f4c19635396c | [
"NCSA"
] | permissive | DarkEnergySurvey/cosmicRays | 4b54291e99c32c11951c228d519a11113f1bebca | 5c29bd9fc4a9f37e298e897623ec98fff4a8d539 | refs/heads/main | 2023-03-28T10:34:34.282404 | 2021-03-29T20:25:49 | 2021-03-29T20:25:49 | 347,135,026 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 20,061 | h | // -*- LSST-C++ -*- // fixed format comment for emacs
/*
* LSST Data Management System
* Copyright 2008, 2009, 2010 LSST Corporation.
*
* This product includes software developed by the
* LSST Project (http://www.lsst.org/).
*
* 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 LSST License Statement and
* the GNU General Public License along with this program. If not,
* see <http://www.lsstcorp.org/LegalNotices/>.
*/
#ifndef LSST_AFW_IMAGE_EXPOSURE_H
#define LSST_AFW_IMAGE_EXPOSURE_H
#include <memory>
#include "lsst/base.h"
#include "lsst/daf/base.h"
#include "lsst/afw/image/MaskedImage.h"
#include "lsst/afw/image/ExposureInfo.h"
#include "lsst/geom/Extent.h"
#include "lsst/geom/SpherePoint.h"
namespace lsst {
namespace afw {
namespace image {
/** A class to contain the data, WCS, and other information needed to describe an %image of the sky.
* Exposure Class Implementation for LSST: a templated framework class
* for creating an Exposure from a MaskedImage and a Wcs.
*
* An Exposure is required to take one afwImage::MaskedImage or a region (col,
* row) defining the size of a MaskedImage (this can be of size 0,0). An
* Exposure can (but is not required to) contain an afwImage::SkyWcs.
*
* The template types should optimally be a float, double, unsigned int 16 bit,
* or unsigned int 32 bit for the image (pixel) type and an unsigned int 32 bit
* for the mask type. These types have been explicitly instantiated for the
* Exposure class. All MaskedImage and Wcs constructors are 'const' to allow
* for views and copying.
*
* An Exposure can get and return its MaskedImage, SkyWcs, and a subExposure.
* The getSubExposure member takes a BBox region defining the subRegion of
* the original Exposure to be returned. The member retrieves the MaskedImage
* corresponding to the subRegion. The MaskedImage class throws an exception
* for any subRegion extending beyond the original MaskedImage bounding
* box. This member is not yet fully implemented because it requires the SkyWcs
* class to return the SkyWcs metadata to the member so the CRPIX values of the
* SkyWcs can be adjusted to reflect the new subMaskedImage origin. The
* getSubExposure member will eventually return a subExposure consisting of
* the subMAskedImage and the SkyWcs object with its corresponding adjusted
* metadata.
*
* The hasWcs member is used to determine if the Exposure has a SkyWcs. It is not
* required to have one.
*/
template <typename ImageT, typename MaskT = lsst::afw::image::MaskPixel,
typename VarianceT = lsst::afw::image::VariancePixel>
class Exposure {
public:
typedef MaskedImage<ImageT, MaskT, VarianceT> MaskedImageT;
// Class Constructors and Destructor
/** @brief Construct an Exposure with a blank MaskedImage of specified size (default 0x0) and
* a SkyWcs (which may be default constructed)
*
* @param width number of columns
* @param height number of rows
* @param wcs the SkyWcs
*/
explicit Exposure(unsigned int width, unsigned int height,
std::shared_ptr<geom::SkyWcs const> wcs = std::shared_ptr<geom::SkyWcs const>());
/** @brief Construct an Exposure with a blank MaskedImage of specified size (default 0x0) and
* a SkyWcs (which may be default constructed)
*
* @param dimensions desired image width/height
* @param wcs the SkyWcs
*/
explicit Exposure(lsst::geom::Extent2I const& dimensions = lsst::geom::Extent2I(),
std::shared_ptr<geom::SkyWcs const> wcs = std::shared_ptr<geom::SkyWcs const>());
/** @brief Construct an Exposure with a blank MaskedImage of specified size (default 0x0) and a SkyWcs
*
* @param bbox desired image width/height, and origin
* @param wcs the SkyWcs
*/
explicit Exposure(lsst::geom::Box2I const& bbox,
std::shared_ptr<geom::SkyWcs const> wcs = std::shared_ptr<geom::SkyWcs const>());
/** Construct an Exposure from a MaskedImage and an optional SkyWcs
*
* @param maskedImage the MaskedImage
* @param wcs the SkyWcs
*/
explicit Exposure(MaskedImageT& maskedImage,
std::shared_ptr<geom::SkyWcs const> wcs = std::shared_ptr<geom::SkyWcs const>());
/** Construct an Exposure from a MaskedImage and an ExposureInfo
*
* If the ExposureInfo is an empty pointer then a new empty ExposureInfo is used
*
* @param maskedImage the MaskedImage
* @param info the ExposureInfo
*/
explicit Exposure(MaskedImageT& maskedImage, std::shared_ptr<ExposureInfo> info);
/**
* Construct an Exposure by reading a regular FITS file.
*
* @param[in] fileName File to read.
* @param[in] bbox If non-empty, read only the pixels within the bounding box.
* @param[in] origin Coordinate system of the bounding box; if PARENT, the bounding box
* should take into account the xy0 saved with the image.
* @param[in] conformMasks If true, make Mask conform to the mask layout in the file.
* @param[in] allowUnsafe Permit reading into the requested pixel type even
* when on-disk values may overflow or truncate.
*/
explicit Exposure(std::string const& fileName, lsst::geom::Box2I const& bbox = lsst::geom::Box2I(),
ImageOrigin origin = PARENT, bool conformMasks = false, bool allowUnsafe = false);
/**
* Construct an Exposure by reading a FITS image in memory.
*
* @param[in] manager An object that manages the memory buffer to read.
* @param[in] bbox If non-empty, read only the pixels within the bounding box.
* @param[in] origin Coordinate system of the bounding box; if PARENT, the bounding box
* should take into account the xy0 saved with the image.
* @param[in] conformMasks If true, make Mask conform to the mask layout in the file.
* @param[in] allowUnsafe Permit reading into the requested pixel type even
* when on-disk values may overflow or truncate.
*/
explicit Exposure(fits::MemFileManager& manager, lsst::geom::Box2I const& bbox = lsst::geom::Box2I(),
ImageOrigin origin = PARENT, bool conformMasks = false, bool allowUnsafe = false);
/**
* Construct an Exposure from an already-open FITS object.
*
* @param[in] fitsfile A FITS object to read from. Current HDU is ignored.
* @param[in] bbox If non-empty, read only the pixels within the bounding box.
* @param[in] origin Coordinate system of the bounding box; if PARENT, the bounding box
* should take into account the xy0 saved with the image.
* @param[in] conformMasks If true, make Mask conform to the mask layout in the file.
* @param[in] allowUnsafe Permit reading into the requested pixel type even
* when on-disk values may overflow or truncate.
*/
explicit Exposure(fits::Fits& fitsfile, lsst::geom::Box2I const& bbox = lsst::geom::Box2I(),
ImageOrigin origin = PARENT, bool conformMasks = false, bool allowUnsafe = false);
/** Copy an Exposure
*
* @param src Parent Exposure
* @param deep Should we copy the pixels?
*/
Exposure(Exposure const& src, bool const deep = false);
Exposure(Exposure&& src);
/** Construct a subExposure given an Exposure and a bounding box
*
* @param src Parent Exposure
* @param bbox Desired region in Exposure
* @param origin Coordinate system for bbox
* @param deep Should we copy the pixels?
*
* @throws lsst::pex::exceptions::InvalidParameterError if the requested subRegion
* is not fully contained by the original MaskedImage BBox.
*/
Exposure(Exposure const& src, lsst::geom::Box2I const& bbox, ImageOrigin const origin = PARENT,
bool const deep = false);
/// generalised copy constructor; defined here in the header so that the compiler can instantiate
/// N(N-1)/2 conversions between N ImageBase types.
///
/// We only support converting the Image part
template <typename OtherPixelT>
Exposure(Exposure<OtherPixelT, MaskT, VarianceT> const& rhs, ///< Input Exposure
const bool deep ///< Must be true; needed to disambiguate
)
: _maskedImage(rhs.getMaskedImage(), deep), _info(new ExposureInfo(*rhs.getInfo(), deep)) {
if (not deep) {
throw LSST_EXCEPT(lsst::pex::exceptions::InvalidParameterError,
"Exposure's converting copy constructor must make a deep copy");
}
}
Exposure& operator=(Exposure const&);
Exposure& operator=(Exposure&&);
/**
* Return a subimage corresponding to the given box.
*
* @param bbox Bounding box of the subimage returned.
* @param origin Origin bbox is rleative to; PARENT accounts for xy0, LOCAL does not.
* @return A subimage view into this.
*
* This method is wrapped as __getitem__ in Python.
*
* @note This method permits mutable views to be obtained from const
* references to images (just as the copy constructor does).
* This is an intrinsic flaw in Image's design.
*/
Exposure subset(lsst::geom::Box2I const& bbox, ImageOrigin origin = PARENT) const {
return Exposure(*this, bbox, origin, false);
}
/// Return a subimage corresponding to the given box (interpreted as PARENT coordinates).
Exposure operator[](lsst::geom::Box2I const& bbox) const { return subset(bbox); }
/** Destructor
*/
virtual ~Exposure();
// Get Members
/// Return the MaskedImage
MaskedImageT getMaskedImage() { return _maskedImage; }
/// Return the MaskedImage
MaskedImageT getMaskedImage() const { return _maskedImage; }
std::shared_ptr<geom::SkyWcs const> getWcs() const { return _info->getWcs(); }
/// Return the Exposure's Detector information
std::shared_ptr<lsst::afw::cameraGeom::Detector const> getDetector() const {
return _info->getDetector();
}
/// Return the Exposure's filter
Filter getFilter() const { return _info->getFilter(); }
/// Return flexible metadata
std::shared_ptr<lsst::daf::base::PropertySet> getMetadata() const { return _info->getMetadata(); }
void setMetadata(std::shared_ptr<lsst::daf::base::PropertySet> metadata) { _info->setMetadata(metadata); }
/// Return the Exposure's width
int getWidth() const { return _maskedImage.getWidth(); }
/// Return the Exposure's height
int getHeight() const { return _maskedImage.getHeight(); }
/// Return the Exposure's size
lsst::geom::Extent2I getDimensions() const { return _maskedImage.getDimensions(); }
/**
* Return the Exposure's column-origin
*
* @see getXY0()
*/
int getX0() const { return _maskedImage.getX0(); }
/**
* Return the Exposure's row-origin
*
* @see getXY0()
*/
int getY0() const { return _maskedImage.getY0(); }
/**
* Return the Exposure's origin
*
* This will usually be (0, 0) except for images created using the
* `Exposure(fileName, hdu, BBox, mode)` ctor or `Exposure(Exposure, BBox)` cctor
* The origin can be reset with `setXY0`
*/
lsst::geom::Point2I getXY0() const { return _maskedImage.getXY0(); }
lsst::geom::Box2I getBBox(ImageOrigin const origin = PARENT) const {
return _maskedImage.getBBox(origin);
}
/**
* Set the Exposure's origin (including correcting the Wcs)
*
* The origin is usually set by the constructor, so you shouldn't need this function
*
* @note There are use cases (e.g. memory overlays) that may want to set these values, but
* don't do so unless you are an Expert.
*/
void setXY0(lsst::geom::Point2I const& origin);
// Set Members
/** Set the MaskedImage of the Exposure.
*/
void setMaskedImage(MaskedImageT& maskedImage);
void setWcs(std::shared_ptr<geom::SkyWcs> wcs) { _info->setWcs(wcs); }
/// Set the Exposure's Detector information
void setDetector(std::shared_ptr<lsst::afw::cameraGeom::Detector const> detector) {
_info->setDetector(detector);
}
/// Set the Exposure's filter
void setFilter(Filter const& filter) { _info->setFilter(filter); }
/// Set the Exposure's PhotoCalib object
void setPhotoCalib(std::shared_ptr<PhotoCalib const> photoCalib) { _info->setPhotoCalib(photoCalib); }
/// Return the Exposure's PhotoCalib object
std::shared_ptr<PhotoCalib const> getPhotoCalib() const { return _info->getPhotoCalib(); }
/// Set the Exposure's Psf
void setPsf(std::shared_ptr<lsst::afw::detection::Psf const> psf) { _info->setPsf(psf); }
/// Return the Exposure's Psf object
std::shared_ptr<lsst::afw::detection::Psf const> getPsf() const { return _info->getPsf(); }
/// Does this Exposure have a Psf?
bool hasPsf() const { return _info->hasPsf(); }
/// Does this Exposure have a Wcs?
bool hasWcs() const { return _info->hasWcs(); }
/// Get the ExposureInfo that aggregates all the non-image components. Never null.
std::shared_ptr<ExposureInfo> getInfo() { return _info; }
/// Get the ExposureInfo that aggregates all the non-image components. Never null.
std::shared_ptr<ExposureInfo const> getInfo() const { return _info; }
/// Set the ExposureInfo that aggregates all the non-image components.
void setInfo(std::shared_ptr<ExposureInfo> exposureInfo) { _info = exposureInfo; }
/**
* Write an Exposure to a regular multi-extension FITS file.
*
* @param[in] fileName Name of the file to write.
*
* As with MaskedImage persistence, an empty primary HDU will be created and all images planes
* will be saved to extension HDUs. Most metadata will be saved only to the header of the
* main image HDU, but the WCS will be saved to the header of the mask and variance as well.
* If present, the Psf will be written to one or more additional HDUs.
*
* Note that the LSST pixel origin differs from the FITS convention by one, so the values
* of CRPIX and LTV saved in the file are not the same as those in the C++ objects in memory,
* but are rather modified so they are interpreted by external tools (like ds9).
*/
void writeFits(std::string const& fileName) const;
/**
* Write an Exposure to a multi-extension FITS file in memory.
*
* @param[in] manager Manager for the memory to write to.
*
* @see writeFits
*/
void writeFits(fits::MemFileManager& manager) const;
/**
* Write an Exposure to an already-open FITS file object.
*
* @param[in] fitsfile FITS object to write.
*
* @see writeFits
*/
void writeFits(fits::Fits& fitsfile) const;
/**
* Write an Exposure to a regular multi-extension FITS file.
*
* @param[in] fileName Name of the file to write.
* @param[in] imageOptions Options controlling writing of image as FITS.
* @param[in] maskOptions Options controlling writing of mask as FITS.
* @param[in] varianceOptions Options controlling writing of variance as FITS.
*/
void writeFits(std::string const& fileName, fits::ImageWriteOptions const& imageOptions,
fits::ImageWriteOptions const& maskOptions,
fits::ImageWriteOptions const& varianceOptions) const;
/**
* Write an Exposure to a regular multi-extension FITS file.
*
* @param[in] manager Manager for the memory to write to.
* @param[in] imageOptions Options controlling writing of image as FITS.
* @param[in] maskOptions Options controlling writing of mask as FITS.
* @param[in] varianceOptions Options controlling writing of variance as FITS.
*/
void writeFits(fits::MemFileManager& manager, fits::ImageWriteOptions const& imageOptions,
fits::ImageWriteOptions const& maskOptions,
fits::ImageWriteOptions const& varianceOptions) const;
/**
* Write an Exposure to a regular multi-extension FITS file.
*
* @param[in] fitsfile FITS object to which to write.
* @param[in] imageOptions Options controlling writing of image as FITS.
* @param[in] maskOptions Options controlling writing of mask as FITS.
* @param[in] varianceOptions Options controlling writing of variance as FITS.
*/
void writeFits(fits::Fits& fitsfile, fits::ImageWriteOptions const& imageOptions,
fits::ImageWriteOptions const& maskOptions,
fits::ImageWriteOptions const& varianceOptions) const;
/**
* Read an Exposure from a regular FITS file.
*
* @param[in] filename Name of the file to read.
*/
static Exposure readFits(std::string const& filename) {
return Exposure<ImageT, MaskT, VarianceT>(filename);
}
/**
* Read an Exposure from a FITS RAM file.
*
* @param[in] manager Object that manages the memory to be read.
*/
static Exposure readFits(fits::MemFileManager& manager) {
return Exposure<ImageT, MaskT, VarianceT>(manager);
}
/**
* Return an Exposure that is a small cutout of the original.
*
* @param center desired center of cutout (in RA and Dec)
* @param size width and height (in that order) of cutout in pixels
*
* @return An Exposure of the requested size centered on `center` to within
* half a pixel in either dimension. Pixels past the edge of the original
* exposure will equal @ref math::edgePixel(image::detail::MaskedImage_tag)
* "math::edgePixel<MaskedImageT>".
*
* @throws lsst::pex::exceptions::LogicError Thrown if this Exposure does
* not have a WCS.
* @throws lsst::pex::exceptions::InvalidParameterError Thrown if ``center``
* falls outside this Exposure or if ``size`` is not a valid size.
*/
Exposure getCutout(lsst::geom::SpherePoint const& center, lsst::geom::Extent2I const& size) const;
private:
void _readFits(fits::Fits& fitsfile, lsst::geom::Box2I const& bbox, ImageOrigin origin,
bool conformMasks);
MaskedImageT _maskedImage;
std::shared_ptr<ExposureInfo> _info;
};
/**
* A function to return an Exposure of the correct type (cf. std::make_pair)
*/
template <typename ImagePixelT, typename MaskPixelT, typename VariancePixelT>
std::shared_ptr<Exposure<ImagePixelT, MaskPixelT, VariancePixelT>> makeExposure(
MaskedImage<ImagePixelT, MaskPixelT, VariancePixelT>& mimage, ///< the Exposure's image
std::shared_ptr<geom::SkyWcs const> wcs =
std::shared_ptr<geom::SkyWcs const>() ///< the Exposure's WCS
) {
return typename std::shared_ptr<Exposure<ImagePixelT, MaskPixelT, VariancePixelT>>(
new Exposure<ImagePixelT, MaskPixelT, VariancePixelT>(mimage, wcs));
}
} // namespace image
} // namespace afw
} // namespace lsst
#endif // LSST_AFW_IMAGE_EXPOSURE_H
| [
"friedel@illinois.edu"
] | friedel@illinois.edu |
a940bc5c03504eda3c5400bf083b2eda32dd8f2d | 9e5703a68eb7d71497b6fb2161e6de0ce0f8b159 | /frameworks/cocos2d-x/cocos/editor-support/fairygui/Classes/Transition.cpp | 8a54b4014f1a386233703b7b45359aeadd4ba29f | [
"MIT"
] | permissive | xiaokimi/FairyGUITest | d07ae6d663c49562244db087f1068e2c5007dcea | 58ecc0d5ac2e842a051580513bb53c91f1eb8b50 | refs/heads/master | 2020-08-07T10:32:06.745436 | 2019-10-07T17:04:12 | 2019-10-07T17:04:12 | 213,412,860 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 38,318 | cpp | #include "Transition.h"
#include "GComponent.h"
#include "GRoot.h"
#include "tween/GTween.h"
#include "utils/ByteBuffer.h"
NS_FGUI_BEGIN
USING_NS_CC;
using namespace std;
const int OPTION_IGNORE_DISPLAY_CONTROLLER = 1;
const int OPTION_AUTO_STOP_DISABLED = 2;
const int OPTION_AUTO_STOP_AT_END = 4;
class TValue_Visible
{
public:
bool visible;
};
class TValue_Animation
{
public:
int frame;
bool playing;
bool flag;
};
class TValue_Sound
{
public:
std::string sound;
float volume;
};
class TValue_Transition
{
public:
std::string transName;
int playTimes;
Transition* trans;
float stopTime;
};
class TValue_Shake
{
public:
float amplitude;
float duration;
cocos2d::Vec2 lastOffset;
cocos2d::Vec2 offset;
};
class TValue_Text
{
public:
std::string text;
};
class TValue
{
public:
float f1;
float f2;
float f3;
float f4;
bool b1;
bool b2;
TValue();
cocos2d::Vec2 getVec2() const;
void setVec2(const cocos2d::Vec2& value);
cocos2d::Vec4 getVec4() const;
void setVec4(const cocos2d::Vec4& value);
cocos2d::Color4B getColor() const;
void setColor(const cocos2d::Color4B& value);
};
TValue::TValue()
{
f1 = f2 = f3 = f4 = 0;
b1 = b2 = true;
}
cocos2d::Vec2 TValue::getVec2() const
{
return cocos2d::Vec2(f1, f2);
}
void TValue::setVec2(const cocos2d::Vec2 & value)
{
f1 = value.x;
f2 = value.y;
}
cocos2d::Vec4 TValue::getVec4() const
{
return cocos2d::Vec4(f1, f2, f3, f4);
}
void TValue::setVec4(const cocos2d::Vec4 & value)
{
f1 = value.x;
f2 = value.y;
f3 = value.z;
f4 = value.w;
}
cocos2d::Color4B TValue::getColor() const
{
return cocos2d::Color4B(f1, f2, f3, f4);
}
void TValue::setColor(const cocos2d::Color4B & value)
{
f1 = value.r;
f2 = value.g;
f3 = value.b;
f4 = value.a;
}
class TweenConfig
{
public:
float duration;
EaseType easeType;
int repeat;
bool yoyo;
TValue* startValue;
TValue* endValue;
string endLabel;
Transition::TransitionHook endHook;
TweenConfig();
};
TweenConfig::TweenConfig()
{
easeType = EaseType::QuadOut;
startValue = new TValue();
endValue = new TValue();
}
class TransitionItem
{
public:
float time;
string targetId;
TransitionActionType type;
TweenConfig* tweenConfig;
string label;
void* value;
Transition::TransitionHook hook;
//running properties
GTweener* tweener;
GObject* target;
uint32_t displayLockToken;
TransitionItem(TransitionActionType aType);
};
TransitionItem::TransitionItem(TransitionActionType aType) :
time(0),
type(aType),
hook(nullptr),
tweenConfig(nullptr),
tweener(nullptr),
target(nullptr),
displayLockToken(0)
{
switch (type)
{
case TransitionActionType::XY:
case TransitionActionType::Size:
case TransitionActionType::Scale:
case TransitionActionType::Pivot:
case TransitionActionType::Skew:
case TransitionActionType::Alpha:
case TransitionActionType::Rotation:
case TransitionActionType::Color:
case TransitionActionType::ColorFilter:
value = new TValue();
break;
case TransitionActionType::Animation:
value = new TValue_Animation();
break;
case TransitionActionType::Shake:
value = new TValue_Shake();
break;
case TransitionActionType::Sound:
value = new TValue_Sound();
break;
case TransitionActionType::Transition:
value = new TValue_Transition();
break;
case TransitionActionType::Visible:
value = new TValue_Visible();
break;
case TransitionActionType::Text:
case TransitionActionType::Icon:
value = new TValue_Text();
break;
default:
value = nullptr;
break;
}
}
Transition::Transition(GComponent* owner) :
_owner(owner),
_totalTimes(0),
_totalTasks(0),
_playing(false),
_paused(false),
_ownerBaseX(0),
_ownerBaseY(0),
_onComplete(nullptr),
_options(0),
_reversed(false),
_totalDuration(0),
_autoPlay(false),
_autoPlayDelay(0),
_timeScale(1),
_startTime(0),
_endTime(0)
{
}
Transition::~Transition()
{
if (_playing)
GTween::kill(this);//delay start
for (auto &item : _items)
{
if (item->tweener != nullptr)
{
item->tweener->kill();
item->tweener = nullptr;
}
item->target = nullptr;
item->hook = nullptr;
if (item->tweenConfig != nullptr)
item->tweenConfig->endHook = nullptr;
}
_playing = false;
_onComplete = nullptr;
}
void Transition::play(PlayCompleteCallback callback)
{
play(1, 0, 0, -1, callback, false);
}
void Transition::play(int times, float delay, PlayCompleteCallback callback)
{
play(times, delay, 0, -1, callback, false);
}
void Transition::play(int times, float delay, float startTime, float endTime, PlayCompleteCallback callback)
{
play(times, delay, startTime, endTime, callback, false);
}
void Transition::playReverse(PlayCompleteCallback callback)
{
play(1, 0, 0, -1, callback, true);
}
void Transition::playReverse(int times, float delay, PlayCompleteCallback callback)
{
play(times, delay, 0, -1, callback, true);
}
void Transition::play(int times, float delay, float startTime, float endTime, PlayCompleteCallback onComplete, bool reverse)
{
stop(true, true);
_totalTimes = times;
_reversed = reverse;
_startTime = startTime;
_endTime = endTime;
_playing = true;
_paused = false;
_onComplete = onComplete;
int cnt = (int)_items.size();
for (int i = 0; i < cnt; i++)
{
TransitionItem* item = _items[i];
if (item->target == nullptr)
{
if (!item->targetId.empty())
item->target = _owner->getChildById(item->targetId);
else
item->target = _owner;
}
else if (item->target != _owner && item->target->getParent() != _owner) //maybe removed
item->target = nullptr;
if (item->target != nullptr && item->type == TransitionActionType::Transition)
{
TValue_Transition* value = (TValue_Transition*)item->value;
Transition* trans = dynamic_cast<GComponent*>(item->target)->getTransition(value->transName);
if (trans == this)
trans = nullptr;
if (trans != nullptr)
{
if (value->playTimes == 0) //stop
{
int j;
for (j = i - 1; j >= 0; j--)
{
TransitionItem* item2 = _items[j];
if (item2->type == TransitionActionType::Transition)
{
TValue_Transition* value2 = (TValue_Transition*)item2->value;
if (value2->trans == trans)
{
value2->stopTime = item->time - item2->time;
break;
}
}
}
if (j < 0)
value->stopTime = 0;
else
trans = nullptr; //no need to handle stop anymore
}
else
value->stopTime = -1;
}
value->trans = trans;
}
}
if (delay == 0)
onDelayedPlay();
else
GTween::delayedCall(delay)->setTarget(this)->onComplete(CC_CALLBACK_0(Transition::onDelayedPlay, this));
}
void Transition::changePlayTimes(int value)
{
_totalTimes = value;
}
void Transition::setAutoPlay(bool autoPlay, int times, float delay)
{
if (_autoPlay != autoPlay)
{
_autoPlay = autoPlay;
_autoPlayTimes = times;
_autoPlayDelay = delay;
if (_autoPlay)
{
if (_owner->onStage())
play(_autoPlayTimes, _autoPlayDelay, nullptr);
}
else
{
if (!_owner->onStage())
stop(false, true);
}
}
}
void Transition::stop()
{
stop(true, false);
}
void Transition::stop(bool setToComplete, bool processCallback)
{
if (!_playing)
return;
_playing = false;
_totalTasks = 0;
_totalTimes = 0;
PlayCompleteCallback func = _onComplete;
_onComplete = nullptr;
int cnt = (int)_items.size();
if (_reversed)
{
for (int i = cnt - 1; i >= 0; i--)
{
TransitionItem* item = _items[i];
if (item->target == nullptr)
continue;
stopItem(item, setToComplete);
}
}
else
{
for (int i = 0; i < cnt; i++)
{
TransitionItem *item = _items[i];
if (item->target == nullptr)
continue;
stopItem(item, setToComplete);
}
}
if (processCallback && func != nullptr)
func();
}
void Transition::stopItem(TransitionItem * item, bool setToComplete)
{
if (item->displayLockToken != 0)
{
item->target->releaseDisplayLock(item->displayLockToken);
item->displayLockToken = 0;
}
if (item->tweener != nullptr)
{
item->tweener->kill(setToComplete);
item->tweener = nullptr;
if (item->type == TransitionActionType::Shake && !setToComplete) //震动必须归位，否则下次就越震越远了。
{
item->target->_gearLocked = true;
item->target->setPosition(item->target->getX() - ((TValue_Shake*)item->value)->lastOffset.x, item->target->getY() - ((TValue_Shake*)item->value)->lastOffset.y);
item->target->_gearLocked = false;
}
}
}
void Transition::setPaused(bool paused)
{
if (!_playing || _paused == paused)
return;
_paused = paused;
GTweener* tweener = GTween::getTween(this);
if (tweener != nullptr)
tweener->setPaused(paused);
for (auto &item : _items)
{
if (item->target == nullptr)
continue;
if (item->type == TransitionActionType::Transition)
{
if (((TValue_Transition*)item->value)->trans != nullptr)
((TValue_Transition*)item->value)->trans->setPaused(paused);
}
else if (item->type == TransitionActionType::Animation)
{
if (paused)
{
((TValue_Animation*)item->value)->flag = (dynamic_cast<IAnimationGear*>(item->target))->isPlaying();
(dynamic_cast<IAnimationGear*>(item->target))->setPlaying(false);
}
else
(dynamic_cast<IAnimationGear*>(item->target))->setPlaying(((TValue_Animation*)item->value)->flag);
}
if (item->tweener != nullptr)
item->tweener->setPaused(paused);
}
}
void Transition::setValue(const std::string & label, const ValueVector& values)
{
for (auto &item : _items)
{
void* value;
if (item->label == label)
{
if (item->tweenConfig != nullptr)
value = item->tweenConfig->startValue;
else
value = item->value;
}
else if (item->tweenConfig != nullptr && item->tweenConfig->endLabel == label)
{
value = item->tweenConfig->endValue;
}
else
continue;
switch (item->type)
{
case TransitionActionType::XY:
case TransitionActionType::Size:
case TransitionActionType::Pivot:
case TransitionActionType::Scale:
case TransitionActionType::Skew:
{
TValue* tvalue = (TValue*)value;
tvalue->b1 = true;
tvalue->b2 = true;
tvalue->f1 = values[0].asFloat();
tvalue->f2 = values[1].asFloat();
break;
}
case TransitionActionType::Alpha:
case TransitionActionType::Rotation:
((TValue*)value)->f1 = values[0].asFloat();;
break;
case TransitionActionType::Color:
{
uint32_t v = values[0].asUnsignedInt();
((TValue*)value)->setColor(Color4B((v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF, (v >> 24) & 0xFF));
break;
}
case TransitionActionType::Animation:
{
TValue_Animation* tvalue = (TValue_Animation*)value;
tvalue->frame = values[0].asInt();
if (values.size() > 1)
tvalue->playing = values[1].asBool();
break;
}
case TransitionActionType::Visible:
((TValue_Visible*)value)->visible = values[0].asBool();
break;
case TransitionActionType::Sound:
{
TValue_Sound* tvalue = (TValue_Sound*)value;
tvalue->sound = values[0].asString();
if (values.size() > 1)
tvalue->volume = values[1].asFloat();
break;
}
case TransitionActionType::Transition:
{
TValue_Transition* tvalue = (TValue_Transition*)value;
tvalue->transName = values[0].asString();
if (values.size() > 1)
tvalue->playTimes = values[1].asInt();
break;
}
case TransitionActionType::Shake:
{
((TValue_Shake*)value)->amplitude = values[0].asFloat();
if (values.size() > 1)
((TValue_Shake*)value)->duration = values[1].asFloat();
break;
}
case TransitionActionType::ColorFilter:
{
TValue* tvalue = (TValue*)value;
tvalue->f1 = values[0].asFloat();
tvalue->f2 = values[1].asFloat();
tvalue->f3 = values[2].asFloat();
tvalue->f4 = values[3].asFloat();
break;
}
case TransitionActionType::Text:
case TransitionActionType::Icon:
((TValue_Text*)value)->text = values[0].asString();
break;
default:
break;
}
}
}
void Transition::setHook(const std::string & label, TransitionHook callback)
{
for (auto &item : _items)
{
if (item->label == label)
{
item->hook = callback;
break;
}
else if (item->tweenConfig != nullptr && item->tweenConfig->endLabel == label)
{
item->tweenConfig->endHook = callback;
break;
}
}
}
void Transition::clearHooks()
{
for (auto &item : _items)
{
item->hook = nullptr;
if (item->tweenConfig != nullptr)
item->tweenConfig->endHook = nullptr;
}
}
void Transition::setTarget(const std::string & label, GObject * newTarget)
{
for (auto &item : _items)
{
if (item->label == label)
{
item->targetId = newTarget->id;
item->target = nullptr;
}
}
}
void Transition::setDuration(const std::string & label, float value)
{
for (auto &item : _items)
{
if (item->tweenConfig != nullptr && item->label == label)
item->tweenConfig->duration = value;
}
}
float Transition::getLabelTime(const string& label) const
{
for (auto &item : _items)
{
if (item->label == label)
return item->time;
else if (item->tweenConfig != nullptr && item->label == label)
return item->time + item->tweenConfig->duration;
}
return NAN;
}
void Transition::setTimeScale(float value)
{
if (_timeScale != value)
{
_timeScale = value;
for (auto &item : _items)
{
if (item->tweener != nullptr)
item->tweener->setTimeScale(value);
else if (item->type == TransitionActionType::Transition)
{
if (((TValue_Transition*)item->value)->trans != nullptr)
((TValue_Transition*)item->value)->trans->setTimeScale(value);
}
else if (item->type == TransitionActionType::Animation)
{
if (item->target != nullptr)
(dynamic_cast<IAnimationGear*>(item->target))->setTimeScale(value);
}
}
}
}
void Transition::updateFromRelations(const std::string & targetId, float dx, float dy)
{
int cnt = (int)_items.size();
if (cnt == 0)
return;
for (auto &item : _items)
{
if (item->type == TransitionActionType::XY && item->targetId == targetId)
{
if (item->tweenConfig != nullptr)
{
item->tweenConfig->startValue->f1 += dx;
item->tweenConfig->startValue->f2 += dy;
item->tweenConfig->endValue->f1 += dx;
item->tweenConfig->endValue->f2 += dy;
}
else
{
((TValue*)item->value)->f1 += dx;
((TValue*)item->value)->f2 += dy;
}
}
}
}
void Transition::onOwnerAddedToStage()
{
if (_autoPlay && !_playing)
play(_autoPlayTimes, _autoPlayDelay, nullptr);
}
void Transition::onOwnerRemovedFromStage()
{
if ((_options & OPTION_AUTO_STOP_DISABLED) == 0)
stop((_options & OPTION_AUTO_STOP_AT_END) != 0 ? true : false, false);
}
void Transition::onDelayedPlay()
{
internalPlay();
_playing = _totalTasks > 0;
if (_playing)
{
if ((_options & OPTION_IGNORE_DISPLAY_CONTROLLER) != 0)
{
for (auto &item : _items)
{
if (item->target != nullptr && item->target != _owner)
item->displayLockToken = item->target->addDisplayLock();
}
}
}
else if (_onComplete != nullptr)
{
PlayCompleteCallback func = _onComplete;
_onComplete = nullptr;
func();
}
}
void Transition::internalPlay()
{
_ownerBaseX = _owner->getX();
_ownerBaseY = _owner->getY();
_totalTasks = 0;
bool needSkipAnimations = false;
int cnt = (int)_items.size();
if (!_reversed)
{
for (int i = 0; i < cnt; i++)
{
TransitionItem* item = _items[i];
if (item->target == nullptr)
continue;
if (item->type == TransitionActionType::Animation && _startTime != 0 && item->time <= _startTime)
{
needSkipAnimations = true;
((TValue_Animation*)item->value)->flag = false;
}
else
playItem(item);
}
}
else
{
for (int i = cnt - 1; i >= 0; i--)
{
TransitionItem* item = _items[i];
if (item->target == nullptr)
continue;
playItem(item);
}
}
if (needSkipAnimations)
skipAnimations();
}
void Transition::playItem(TransitionItem* item)
{
float time;
if (item->tweenConfig != nullptr)
{
if (_reversed)
time = (_totalDuration - item->time - item->tweenConfig->duration);
else
time = item->time;
if (_endTime == -1 || time <= _endTime)
{
TValue* startValue;
TValue* endValue;
if (_reversed)
{
startValue = item->tweenConfig->endValue;
endValue = item->tweenConfig->startValue;
}
else
{
startValue = item->tweenConfig->startValue;
endValue = item->tweenConfig->endValue;
}
((TValue*)item->value)->b1 = startValue->b1 || endValue->b1;
((TValue*)item->value)->b2 = startValue->b2 || endValue->b2;
switch (item->type)
{
case TransitionActionType::XY:
case TransitionActionType::Size:
case TransitionActionType::Scale:
case TransitionActionType::Skew:
item->tweener = GTween::to(startValue->getVec2(), endValue->getVec2(), item->tweenConfig->duration);
break;
case TransitionActionType::Alpha:
case TransitionActionType::Rotation:
item->tweener = GTween::to(startValue->f1, endValue->f1, item->tweenConfig->duration);
break;
case TransitionActionType::Color:
item->tweener = GTween::to(startValue->getColor(), endValue->getColor(), item->tweenConfig->duration);
break;
case TransitionActionType::ColorFilter:
item->tweener = GTween::to(startValue->getVec4(), endValue->getVec4(), item->tweenConfig->duration);
break;
default:
break;
}
item->tweener->setDelay(time)
->setEase(item->tweenConfig->easeType)
->setRepeat(item->tweenConfig->repeat, item->tweenConfig->yoyo)
->setTimeScale(_timeScale)
->setTargetAny(item)
->onStart(CC_CALLBACK_1(Transition::onTweenStart, this))
->onUpdate(CC_CALLBACK_1(Transition::onTweenUpdate, this))
->onComplete1(CC_CALLBACK_1(Transition::onTweenComplete, this));
if (_endTime >= 0)
item->tweener->setBreakpoint(_endTime - time);
_totalTasks++;
}
}
else if (item->type == TransitionActionType::Shake)
{
TValue_Shake* value = (TValue_Shake*)item->value;
if (_reversed)
time = (_totalDuration - item->time - value->duration);
else
time = item->time;
if (_endTime == -1 || time <= _endTime)
{
value->lastOffset.setZero();
value->offset.setZero();
item->tweener = GTween::shake(Vec2::ZERO, value->amplitude, value->duration)
->setDelay(time)
->setTimeScale(_timeScale)
->setTargetAny(item)
->onStart(CC_CALLBACK_1(Transition::onTweenStart, this))
->onUpdate(CC_CALLBACK_1(Transition::onTweenUpdate, this))
->onComplete1(CC_CALLBACK_1(Transition::onTweenComplete, this));
if (_endTime >= 0)
item->tweener->setBreakpoint(_endTime - item->time);
_totalTasks++;
}
}
else
{
if (_reversed)
time = (_totalDuration - item->time);
else
time = item->time;
if (time <= _startTime)
{
applyValue(item);
callHook(item, false);
}
else if (_endTime == -1 || time <= _endTime)
{
_totalTasks++;
item->tweener = GTween::delayedCall(time)
->setTimeScale(_timeScale)
->setTargetAny(item)
->onComplete1(CC_CALLBACK_1(Transition::onDelayedPlayItem, this));
}
}
if (item->tweener != nullptr)
item->tweener->seek(_startTime);
}
void Transition::skipAnimations()
{
int frame;
float playStartTime;
float playTotalTime;
TValue_Animation* value;
IAnimationGear* target;
TransitionItem* item;
int cnt = (int)_items.size();
for (int i = 0; i < cnt; i++)
{
item = _items[i];
if (item->type != TransitionActionType::Animation || item->time > _startTime)
continue;
value = (TValue_Animation*)item->value;
if (value->flag)
continue;
target = dynamic_cast<IAnimationGear*>(item->target);
frame = target->getFrame();
playStartTime = target->isPlaying() ? 0 : -1;
playTotalTime = 0;
for (int j = i; j < cnt; j++)
{
item = _items[j];
if (item->type != TransitionActionType::Animation || item->target != (void*)target || item->time > _startTime)
continue;
value = (TValue_Animation*)item->value;
value->flag = true;
if (value->frame != -1)
{
frame = value->frame;
if (value->playing)
playStartTime = item->time;
else
playStartTime = -1;
playTotalTime = 0;
}
else
{
if (value->playing)
{
if (playStartTime < 0)
playStartTime = item->time;
}
else
{
if (playStartTime >= 0)
playTotalTime += (item->time - playStartTime);
playStartTime = -1;
}
}
callHook(item, false);
}
if (playStartTime >= 0)
playTotalTime += (_startTime - playStartTime);
target->setPlaying(playStartTime >= 0);
target->setFrame(frame);
if (playTotalTime > 0)
target->advance(playTotalTime);
}
}
void Transition::onDelayedPlayItem(GTweener* tweener)
{
TransitionItem* item = (TransitionItem*)tweener->getTarget();
item->tweener = nullptr;
_totalTasks--;
applyValue(item);
callHook(item, false);
checkAllComplete();
}
void Transition::onTweenStart(GTweener* tweener)
{
TransitionItem* item = (TransitionItem*)tweener->getTarget();
if (item->type == TransitionActionType::XY || item->type == TransitionActionType::Size) //位置和大小要到start才最终确认起始值
{
TValue* startValue;
TValue* endValue;
if (_reversed)
{
startValue = item->tweenConfig->endValue;
endValue = item->tweenConfig->startValue;
}
else
{
startValue = item->tweenConfig->startValue;
endValue = item->tweenConfig->endValue;
}
if (item->type == TransitionActionType::XY)
{
if (item->target != _owner)
{
if (!startValue->b1)
startValue->f1 = item->target->getX();
if (!startValue->b2)
startValue->f2 = item->target->getY();
}
else
{
if (!startValue->b1)
startValue->f1 = item->target->getX() - _ownerBaseX;
if (!startValue->b2)
startValue->f2 = item->target->getY() - _ownerBaseY;
}
}
else
{
if (!startValue->b1)
startValue->f1 = item->target->getWidth();
if (!startValue->b2)
startValue->f2 = item->target->getHeight();
}
if (!endValue->b1)
endValue->f1 = startValue->f1;
if (!endValue->b2)
endValue->f2 = startValue->f2;
tweener->startValue.setVec2(startValue->getVec2());
tweener->endValue.setVec2(endValue->getVec2());
}
callHook(item, false);
}
void Transition::onTweenUpdate(GTweener* tweener)
{
TransitionItem* item = (TransitionItem*)tweener->getTarget();
switch (item->type)
{
case TransitionActionType::XY:
case TransitionActionType::Size:
case TransitionActionType::Scale:
case TransitionActionType::Skew:
((TValue*)item->value)->setVec2(tweener->value.getVec2());
break;
case TransitionActionType::Alpha:
case TransitionActionType::Rotation:
((TValue*)item->value)->f1 = tweener->value.x;
break;
case TransitionActionType::Color:
((TValue*)item->value)->setColor(tweener->value.getColor());
break;
case TransitionActionType::ColorFilter:
((TValue*)item->value)->setVec4(tweener->value.getVec4());
break;
case TransitionActionType::Shake:
((TValue_Shake*)item->value)->offset = tweener->deltaValue.getVec2();
break;
default:
break;
}
applyValue(item);
}
void Transition::onTweenComplete(GTweener* tweener)
{
TransitionItem* item = (TransitionItem*)tweener->getTarget();
item->tweener = nullptr;
_totalTasks--;
if (tweener->allCompleted()) //当整体播放结束时间在这个tween的中间时不应该调用结尾钩子
callHook(item, true);
checkAllComplete();
}
void Transition::onPlayTransCompleted(TransitionItem* item)
{
_totalTasks--;
checkAllComplete();
}
void Transition::callHook(TransitionItem* item, bool tweenEnd)
{
if (tweenEnd)
{
if (item->tweenConfig != nullptr && item->tweenConfig->endHook != nullptr)
item->tweenConfig->endHook();
}
else
{
if (item->time >= _startTime && item->hook != nullptr)
item->hook();
}
}
void Transition::checkAllComplete()
{
if (_playing && _totalTasks == 0)
{
if (_totalTimes < 0)
{
internalPlay();
}
else
{
_totalTimes--;
if (_totalTimes > 0)
internalPlay();
else
{
_playing = false;
for (auto &item : _items)
{
if (item->target != nullptr && item->displayLockToken != 0)
{
item->target->releaseDisplayLock(item->displayLockToken);
item->displayLockToken = 0;
}
}
if (_onComplete != nullptr)
{
PlayCompleteCallback func = _onComplete;
_onComplete = nullptr;
func();
}
}
}
}
}
void Transition::applyValue(TransitionItem* item)
{
item->target->_gearLocked = true;
switch (item->type)
{
case TransitionActionType::XY:
{
TValue* value = (TValue*)item->value;
if (item->target == _owner)
{
float f1, f2;
if (!value->b1)
f1 = item->target->getX();
else
f1 = value->f1 + _ownerBaseX;
if (!value->b2)
f2 = item->target->getY();
else
f2 = value->f2 + _ownerBaseY;
item->target->setPosition(f1, f2);
}
else
{
if (!value->b1)
value->f1 = item->target->getX();
if (!value->b2)
value->f2 = item->target->getY();
item->target->setPosition(value->f1, value->f2);
}
}
break;
case TransitionActionType::Size:
{
TValue* value = (TValue*)item->value;
if (!value->b1)
value->f1 = item->target->getWidth();
if (!value->b2)
value->f2 = item->target->getHeight();
item->target->setSize(value->f1, value->f2);
}
break;
case TransitionActionType::Pivot:
item->target->setPivot(((TValue*)item->value)->f1, ((TValue*)item->value)->f2, item->target->isPivotAsAnchor());
break;
case TransitionActionType::Alpha:
item->target->setAlpha(((TValue*)item->value)->f1);
break;
case TransitionActionType::Rotation:
item->target->setRotation(((TValue*)item->value)->f1);
break;
case TransitionActionType::Scale:
item->target->setScale(((TValue*)item->value)->f1, ((TValue*)item->value)->f2);
break;
case TransitionActionType::Skew:
item->target->setSkewX(((TValue*)item->value)->f1);
item->target->setSkewY(((TValue*)item->value)->f2);
break;
case TransitionActionType::Color:
(dynamic_cast<IColorGear*>(item->target))->setColor((Color3B)((TValue*)item->value)->getColor());
break;
case TransitionActionType::Animation:
{
TValue_Animation* value = (TValue_Animation*)item->value;
IAnimationGear* target = (dynamic_cast<IAnimationGear*>(item->target));
if (value->frame >= 0)
target->setFrame(value->frame);
target->setPlaying(value->playing);
target->setTimeScale(_timeScale);
}
break;
case TransitionActionType::Visible:
item->target->setVisible(((TValue_Visible*)item->value)->visible);
break;
case TransitionActionType::Shake:
{
TValue_Shake* value = (TValue_Shake*)item->value;
item->target->setPosition(item->target->getX() - value->lastOffset.x + value->offset.x, item->target->getY() - value->lastOffset.y + value->offset.y);
value->lastOffset = value->offset;
}
break;
case TransitionActionType::Transition:
if (_playing)
{
TValue_Transition* value = (TValue_Transition*)item->value;
if (value->trans != nullptr)
{
_totalTasks++;
float startTime = _startTime > item->time ? (_startTime - item->time) : 0;
float endTime = _endTime >= 0 ? (_endTime - item->time) : -1;
if (value->stopTime >= 0 && (endTime < 0 || endTime > value->stopTime))
endTime = value->stopTime;
value->trans->setTimeScale(_timeScale);
value->trans->play(value->playTimes, 0, startTime, endTime, [this, item]() { onPlayTransCompleted(item); }, _reversed);
}
}
break;
case TransitionActionType::Sound:
if (_playing && item->time >= _startTime)
{
TValue_Sound* value = (TValue_Sound*)item->value;
if (!value->sound.empty())
UIRoot->playSound(value->sound, value->volume);
break;
}
case TransitionActionType::ColorFilter:
break;
case TransitionActionType::Text:
item->target->setText(((TValue_Text*)item->value)->text);
break;
case TransitionActionType::Icon:
item->target->setIcon(((TValue_Text*)item->value)->text);
break;
default:
break;
}
item->target->_gearLocked = false;
}
void Transition::setup(ByteBuffer* buffer)
{
name = buffer->ReadS();
_options = buffer->ReadInt();
_autoPlay = buffer->ReadBool();
_autoPlayTimes = buffer->ReadInt();
_autoPlayDelay = buffer->ReadFloat();
int cnt = buffer->ReadShort();
for (int i = 0; i < cnt; i++)
{
int dataLen = buffer->ReadShort();
int curPos = buffer->position;
buffer->Seek(curPos, 0);
TransitionItem* item = new TransitionItem((TransitionActionType)buffer->ReadByte());
_items.push_back(item);
item->time = buffer->ReadFloat();
int targetId = buffer->ReadShort();
if (targetId < 0)
item->targetId = STD_STRING_EMPTY;
else
item->targetId = _owner->getChildAt(targetId)->id;
item->label = buffer->ReadS();
if (buffer->ReadBool())
{
buffer->Seek(curPos, 1);
item->tweenConfig = new TweenConfig();
item->tweenConfig->duration = buffer->ReadFloat();
if (item->time + item->tweenConfig->duration > _totalDuration)
_totalDuration = item->time + item->tweenConfig->duration;
item->tweenConfig->easeType = (EaseType)buffer->ReadByte();
item->tweenConfig->repeat = buffer->ReadInt();
item->tweenConfig->yoyo = buffer->ReadBool();
item->tweenConfig->endLabel = buffer->ReadS();
buffer->Seek(curPos, 2);
decodeValue(item, buffer, item->tweenConfig->startValue);
buffer->Seek(curPos, 3);
decodeValue(item, buffer, item->tweenConfig->endValue);
}
else
{
if (item->time > _totalDuration)
_totalDuration = item->time;
buffer->Seek(curPos, 2);
decodeValue(item, buffer, item->value);
}
buffer->position = curPos + dataLen;
}
}
void Transition::decodeValue(TransitionItem* item, ByteBuffer * buffer, void* value)
{
switch (item->type)
{
case TransitionActionType::XY:
case TransitionActionType::Size:
case TransitionActionType::Pivot:
case TransitionActionType::Skew:
{
TValue* tvalue = (TValue*)value;
tvalue->b1 = buffer->ReadBool();
tvalue->b2 = buffer->ReadBool();
tvalue->f1 = buffer->ReadFloat();
tvalue->f2 = buffer->ReadFloat();
break;
}
case TransitionActionType::Alpha:
case TransitionActionType::Rotation:
((TValue*)value)->f1 = buffer->ReadFloat();
break;
case TransitionActionType::Scale:
{
((TValue*)value)->f1 = buffer->ReadFloat();
((TValue*)value)->f2 = buffer->ReadFloat();
break;
}
case TransitionActionType::Color:
((TValue*)value)->setColor(buffer->ReadColor());
break;
case TransitionActionType::Animation:
{
((TValue_Animation*)value)->playing = buffer->ReadBool();
((TValue_Animation*)value)->frame = buffer->ReadInt();
break;
}
case TransitionActionType::Visible:
((TValue_Visible*)value)->visible = buffer->ReadBool();
break;
case TransitionActionType::Sound:
{
((TValue_Sound*)value)->sound = buffer->ReadS();
((TValue_Sound*)value)->volume = buffer->ReadFloat();
break;
}
case TransitionActionType::Transition:
{
((TValue_Transition*)value)->transName = buffer->ReadS();
((TValue_Transition*)value)->playTimes = buffer->ReadInt();
break;
}
case TransitionActionType::Shake:
{
((TValue_Shake*)value)->amplitude = buffer->ReadFloat();
((TValue_Shake*)value)->duration = buffer->ReadFloat();
break;
}
case TransitionActionType::ColorFilter:
{
TValue* tvalue = (TValue*)value;
tvalue->f1 = buffer->ReadFloat();
tvalue->f2 = buffer->ReadFloat();
tvalue->f3 = buffer->ReadFloat();
tvalue->f4 = buffer->ReadFloat();
break;
}
case TransitionActionType::Text:
case TransitionActionType::Icon:
((TValue_Text*)value)->text = buffer->ReadS();
break;
default:
break;
}
}
NS_FGUI_END
| [
"515360208@qq.com"
] | 515360208@qq.com |
7920ef483ebf77653082e0a3b26a72a806752f97 | 9fcd0caf38e4e9eea4a8db1933898f7a4be80c23 | /src/serve_util.hpp | 9afdee3c63d360cbe706cc6b423bf2bc9ab7baf8 | [
"LicenseRef-scancode-public-domain"
] | permissive | kalven/CodeDB | 8312cc8de663efe2da97bf856271755eaacc7b97 | d38c87c076aa4ed03721d58152e16b65a1cf7145 | refs/heads/master | 2021-01-01T19:50:59.467235 | 2014-05-19T00:12:06 | 2014-05-19T00:12:06 | 522,529 | 9 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 766 | hpp | // CodeDB - public domain - 2010 Daniel Andersson
#ifndef CODEDB_SERVE_UTIL_HPP
#define CODEDB_SERVE_UTIL_HPP
#include "nsalias.hpp"
#include <boost/filesystem/path.hpp>
#include <vector>
#include <string>
#include <map>
struct http_query {
std::string m_action;
std::map<std::string, std::string> m_args;
};
http_query parse_http_query(const std::string& str);
std::string get_arg(const http_query& query, const std::string& index);
std::string html_escape(const std::string& str);
std::string quot_escape(const std::string& str);
std::string urldecode(const std::string& str);
std::string urlencode(const std::string& str);
std::vector<std::string> serve_page(std::string content);
std::vector<std::string> serve_file(const bfs::path& path);
#endif
| [
"kalven@gmail.com"
] | kalven@gmail.com |
1ab435e62e77b6ae9f331377bbe577e11f36b5c5 | 228ff110e466d6775efd21b45f39483ed2009f78 | /src-qt5/core-utils/lumina-config/pages/page_interface_panels.h | 2c7eda7a40c2682c25b6db1880331a1686053a34 | [
"BSD-3-Clause"
] | permissive | 0-wiz-0/lumina | d21d48a4114e98774724009c14668f1d29e53180 | ecae524c77a84b5855fa6390b7e0166c17349c18 | refs/heads/master | 2020-12-24T12:14:07.545433 | 2016-11-07T09:07:05 | 2016-11-07T09:07:05 | 73,060,501 | 0 | 0 | null | 2016-11-07T09:05:04 | 2016-11-07T09:05:04 | null | UTF-8 | C++ | false | false | 1,165 | h | //===========================================
// Lumina Desktop Source Code
// Copyright (c) 2016, Ken Moore
// Available under the 3-clause BSD license
// See the LICENSE file for full details
//===========================================
#ifndef _LUMINA_CONFIG_PAGE_INTERFACE_PANELS_H
#define _LUMINA_CONFIG_PAGE_INTERFACE_PANELS_H
#include "../globals.h"
#include "PageWidget.h"
#include "../LPlugins.h"
#include "../PanelWidget.h"
namespace Ui{
class page_interface_panels;
};
class page_interface_panels : public PageWidget{
Q_OBJECT
public:
page_interface_panels(QWidget *parent);
~page_interface_panels();
bool needsScreenSelector(){ return true; }
public slots:
void SaveSettings();
void LoadSettings(int screennum = -1);
void updateIcons();
private:
Ui::page_interface_panels *ui;
bool loading;
int cscreen; //current monitor/screen number
QSettings *settings;
LPlugins *PINFO;
QList<PanelWidget*> PANELS;
//Get an application on the system
//XDGDesktop getSysApp(bool allowreset = false);
private slots:
void panelValChanged();
void newPanel();
void removePanel(int); //connected to a signal from the panel widget
};
#endif
| [
"moorekou@gmail.com"
] | moorekou@gmail.com |
8a164431838a55d2b9b1a56b6f49dd2b1458820f | 7bad5e9cdc8b59ad6d244b13a3258e1b8f565e4a | /ABC/105/B.cpp | 940a8aef1663ff574f6d3b652932b88bdcf5ddc7 | [] | no_license | kooooichi24/atcoder | 3815feace984b321186a1470d0ce7e4b64e10e9e | 0c6640bd2206a4fc46a7c4c7205a1cbfe716a34d | refs/heads/master | 2021-08-04T08:57:51.734311 | 2020-08-15T05:28:52 | 2020-08-15T05:28:52 | 207,502,272 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 321 | cpp | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using p = pair<int, int>;
int main() {
int n;
cin >> n;
string result = "No";
rep(i,n) {
rep(j,n) {
if (n == 4*i + 7*j) result = "Yes";
}
}
cout << result << endl;
return 0;
} | [
"ex.kouichi1224@gmail.com"
] | ex.kouichi1224@gmail.com |
3bc222b66dc58fe4b22958cb7cb4491656e3f25a | e03580c9e64940029a4b3647f69564344ae41655 | /tut49.cpp | de7cef1c5ba4cbab4d6d4ce843038b1a6ad542ef | [] | no_license | ravibpibs/C-Programming-Tutorial | 255d1ef602f72b65680bfddbb5e25e71ffbc8e01 | 0245fd86b1d850759f2636423a3edb51dfbef7be | refs/heads/master | 2023-03-31T00:15:27.648446 | 2021-03-24T03:03:38 | 2021-03-24T03:03:38 | 350,924,355 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 904 | cpp | #include<iostream>
using namespace std;
/*
syntax for initilazation list in constructor:
constructor (argument-list) : initilization-section
{
assignment + other code;
}
class Test{
int a;
int b;
public:
Test(int i, int j) : a(i), b(j){constructor-body}
}
*/
class Test{
int a;
int b;
public:
// Test(int i, int j) : a(i), b(j)
// Test(int i, int j) : a(i), b(i+j)
// Test(int i, int j) : a(i), b(2 * j)
// Test(int i, int j) : a(i), b(a + j)
// Test(int i, int j) : b(j), a(i+b) ---> this will create problem because a will be initilized first
Test(int i, int j) : a(i)
{
a = i;
b = j;
cout<< "Constructor excuted"<<endl;
cout<< "Value of a is "<<a<<endl;
cout<< "Value of b is "<<b<<endl;
}
};
int main(){
Test t(4, 6);
return 0;
} | [
"rjha4743@gmail.com"
] | rjha4743@gmail.com |
ccd639bf6af322555e735cfd6f73f8a5cfedcbe0 | fd0479531a4f1062ff1318e84fe4fc8c4a8d99cc | /196/seminar10/back_inserter.cpp | 70d2e8991b6becdd575412b66db729bb90213298 | [] | no_license | Daniel-ef/OIMP_seminars_cpp | bb1bac9faa4930af91e9afd384f80ce9edb2a651 | c65b4fcb44d7fd1d469a9e5fb52d3428b48a888f | refs/heads/master | 2020-12-12T06:39:42.715198 | 2020-03-20T07:08:18 | 2020-03-20T07:08:18 | 234,066,759 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 168 | cpp | #include <iostream>
#include <vector>
int main() {
std::vector<int> v1{1, 5, 6};
std::vector<int> v2;
std::copy(v1.begin(), v1.end(), std::back_inserter(v2));
} | [
"dlefimov@yandex-team.ru"
] | dlefimov@yandex-team.ru |
a6c4e5bf0415e4890836c0688c1bfed059d0136f | 406a5228d663f56cb49621edb3d2bb9b6844af74 | /test/unit/phys/dca_step/cluster_solver/ctaux/structs/read_write_config_test.cpp | 3b221c5a790a7c6e1b0f0777333ec1588be46a28 | [
"BSD-3-Clause"
] | permissive | gbalduzz/DCA | 041af8922fcca466869a82033097fdc52535c308 | 65b2da891d81a9984d8fbd0081dfd5d4f7fd97e2 | refs/heads/master | 2021-12-14T23:01:45.693400 | 2019-02-28T16:12:47 | 2019-02-28T16:12:47 | 175,044,383 | 1 | 1 | BSD-3-Clause | 2020-08-17T20:28:39 | 2019-03-11T16:50:32 | C++ | UTF-8 | C++ | false | false | 1,582 | cpp | // Copyright (C) 2018 ETH Zurich
// Copyright (C) 2018 UT-Battelle, LLC
// All rights reserved.
//
// See LICENSE for terms of usage.
// See CITATION.md for citation guidelines, if DCA++ is used for scientific publications.
//
// Author: Giovanni Balduzzi (gbalduzz@itp.phys.ethz.ch)
//
// This file tests the reading and writing of the CT-AUX configuration to a buffer.
#include <dca/phys/dca_step/cluster_solver/cluster_solver_name.hpp>
#include "dca/phys/dca_step/cluster_solver/ctaux/structs/read_write_config.hpp"
#include "gtest/gtest.h"
#include "dca/math/random/std_random_wrapper.hpp"
#include "dca/phys/dca_step/cluster_solver/ctaux/structs/cv.hpp"
#include "test/unit/phys/dca_step/cluster_solver/test_setup.hpp"
constexpr char input_name[] =
DCA_SOURCE_DIR "/test/unit/phys/dca_step/cluster_solver/ctaux/structs/input.json";
using ReadWriteConfigTest =
dca::testing::G0Setup<dca::testing::LatticeBilayer, dca::phys::solver::CT_AUX, input_name>;
TEST_F(ReadWriteConfigTest, All) {
std::vector<double> random(100);
for (auto& x : random)
x = static_cast<double>(std::rand()) / RAND_MAX;
Parameters::random_number_generator stub_rng(random);
dca::phys::solver::ctaux::CV<Parameters>::get_H_interaction() = data_->H_interactions;
dca::phys::solver::ctaux::CT_AUX_HS_configuration<Parameters> config(parameters_, stub_rng);
config.initialize();
dca::io::Buffer buffer;
buffer << config;
dca::phys::solver::ctaux::CT_AUX_HS_configuration<Parameters> config2(parameters_, stub_rng);
buffer >> config2;
EXPECT_EQ(config, config2);
}
| [
"gbalduzz@itp.phys.ethz.ch"
] | gbalduzz@itp.phys.ethz.ch |
3b0f2dc8fb28b9fbfb3695f1de2b076804da1ab2 | e3587c7dce8512f9b83cc884054a2b5dc442d80e | /3rdparty-linux/image_stone/example/002/wnd_bottom_status.h | 153322bdf8ee90d4a501b18a81b5bebf62fec0c3 | [] | no_license | love-xunmeng/SmartPlatform | 1a79283e7d294e5155ae8ee490197154b743fef9 | cf311d9d414be50c0691c73dd2d4945ccaa532c6 | refs/heads/master | 2021-01-02T22:33:57.254300 | 2017-09-13T02:31:32 | 2017-09-13T02:31:32 | 99,339,644 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,703 | h | #pragma once
#include "Resource.h"
//-------------------------------------------------------------------------------------
class CWndBottomStatus : public CStatusBar
{
enum
{
PROGRESS_INDEX = 0,
POSITION_INDEX = 1,
ZOOM_INDEX = 2,
TRACK_SIZE_INDEX = 3,
IDC_PROGRESS_BAR = 2000,
};
CProgressCtrl m_progress ;
static CWndBottomStatus * g_obj ;
public:
CWndBottomStatus()
{
g_obj = this ;
}
~CWndBottomStatus()
{
g_obj = NULL ;
}
// ptOnCanvas start from 0, but we show from 1, so we need add 1
static void SetPosition (CPoint ptOnCanvas)
{
CWndBottomStatus * p = g_obj ;
if (!p)
return ;
static CString sName = L"Position" ;
CString s ;
if (ptOnCanvas != CPoint(-1,-1))
{
ptOnCanvas += CPoint(1,1) ; // start from 1
CString t ;
t.Format (L" ( %d , %d )", ptOnCanvas.x, ptOnCanvas.y) ;
s = sName + t ;
}
p->SetPaneText (POSITION_INDEX, s) ;
}
static void SetZoom (int nScale)
{
CWndBottomStatus * p = g_obj ;
if (p)
{
CString s ;
if (abs(nScale) == 1)
{
// no zoom
s = L"Actual View" ;
}
else
{
CString fs = ((nScale > 1) ? L"x %d View" : L"1 / %d View") ;
s.Format (fs, abs(nScale)) ;
}
p->SetPaneText (ZOOM_INDEX, s) ;
}
}
static void SetTrackSize (int w, int h)
{
CWndBottomStatus * p = g_obj ;
if (!p)
return ;
static CString sName = L"Size" ;
CString s ;
s.Format (L" ( %d , %d )", w, h) ;
p->SetPaneText (TRACK_SIZE_INDEX, sName + s) ;
}
static void SetMoveSize (CSize sz)
{
CWndBottomStatus * p = g_obj ;
if (!p)
return ;
static CString sName = L"Move" ;
CString s ;
s.Format (L" ( %d , %d )", sz.cx, sz.cy) ;
p->SetPaneText (TRACK_SIZE_INDEX, sName + s) ;
}
static void SetProgress (int nProgress)
{
CWndBottomStatus * p = g_obj ;
if (p)
{
if (nProgress == 100)
{
p->m_progress.ShowWindow(SW_HIDE) ;
}
else
{
if (!p->m_progress.IsWindowVisible())
{
CRect rc ;
p->GetItemRect (PROGRESS_INDEX, rc) ;
p->m_progress.SetWindowPos (NULL, rc.left, rc.top, rc.Width(), rc.Height(), SWP_NOZORDER|SWP_NOACTIVATE) ;
p->m_progress.SetPos(0) ;
p->m_progress.ShowWindow(SW_SHOWNA) ;
}
p->m_progress.SetPos(nProgress) ;
}
}
}
static void HideProgress()
{
if (g_obj)
{
g_obj->m_progress.ShowWindow(SW_HIDE) ;
}
}
void CreateBar (CWnd* pParentWnd)
{
const UINT indicators[] =
{
ID_INDICATOR1,
ID_INDICATOR2, // status line indicator
ID_INDICATOR_ZOOM,
ID_SEPARATOR,
};
Create (pParentWnd) ;
SetIndicators (indicators, sizeof(indicators)/sizeof(UINT)) ;
// create progress control
m_progress.Create (WS_CHILD, CRect(0,0,5,5), this, IDC_PROGRESS_BAR) ;
m_progress.SetRange (0, 100) ;
m_progress.SetStep(1) ;
}
};
__declspec(selectany) CWndBottomStatus* CWndBottomStatus::g_obj = NULL ;
| [
"1985082200@qq.com"
] | 1985082200@qq.com |
1356222090118b92255100784f6036a7e30a8323 | 41a5aa8e5c76aecb353c508e31065b0f04575a14 | /CPP/Student/src/Student.cpp | b39680199157b0e7be0585fda0f2d36fe1093aa6 | [] | no_license | gayatrikerkar/1713 | 10357faf201541710b7d1d0b0b5e90518e0715d9 | b3b9d9c68701e1fb3481141e54e877b54a1f9d6e | refs/heads/master | 2020-03-22T17:46:22.738714 | 2018-10-29T11:18:43 | 2018-10-29T11:18:43 | 140,414,726 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 339 | cpp | #include "Student.h"
#include<string>
#include<iostream>
using namespace std;
Student::Student(string name,int roll_no,int age)
{
cout<<"output:"<<endl;
cout<<"name:"<< name << endl;
cout<<"roll no:"<< roll_no << endl;
cout<<"age:"<< age << endl;
}
Student::~Student()
{
cout<< "staff object destroyed" <<endl;
}
| [
"gayatrikerkar11@gmail.com"
] | gayatrikerkar11@gmail.com |
cb0397eb65ea9febb0bb9d71a07ff3eb36e86afa | 5e6b67a01bf4c160930610e942cd35a0504e3967 | /tesis/ww39_neuronal_new_IP/IP_2020_latest_Jan/IP_latest_2020_Enero/solution1/.autopilot/db/V_read.pp.0.cpp | b868b41cc59f2eafc8b5e1473f8d63cce228ca37 | [] | no_license | mespinoza86/Documents_2020 | 40b7d70e63017d9b1b270c431488251b4fd90742 | 35d6b369cd4b136d692277aa6dea8f959b3cc3d9 | refs/heads/master | 2022-04-15T16:15:55.860768 | 2020-04-12T01:04:17 | 2020-04-12T01:04:17 | 254,982,543 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,368,925 | cpp | # 1 "modules/V_read/V_read.cpp"
# 1 "modules/V_read/V_read.cpp" 1
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 155 "<built-in>" 3
# 1 "<command line>" 1
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/etc/autopilot_ssdm_op.h" 1
# 157 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/etc/autopilot_ssdm_op.h"
extern "C" {
void _ssdm_op_IfRead(...) __attribute__ ((nothrow));
void _ssdm_op_IfWrite(...) __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfNbRead(...) __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfNbWrite(...) __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfCanRead(...) __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_op_IfCanWrite(...) __attribute__ ((nothrow));
void _ssdm_StreamRead(...) __attribute__ ((nothrow));
void _ssdm_StreamWrite(...) __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamNbRead(...) __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamNbWrite(...) __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamCanRead(...) __attribute__ ((nothrow));
unsigned int __attribute__ ((bitwidth(1))) _ssdm_StreamCanWrite(...) __attribute__ ((nothrow));
unsigned _ssdm_StreamSize(...) __attribute__ ((nothrow));
void _ssdm_op_MemShiftRead(...) __attribute__ ((nothrow));
void _ssdm_op_Wait(...) __attribute__ ((nothrow));
void _ssdm_op_Poll(...) __attribute__ ((nothrow));
void _ssdm_op_Return(...) __attribute__ ((nothrow));
void _ssdm_op_SpecSynModule(...) __attribute__ ((nothrow));
void _ssdm_op_SpecTopModule(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDecl(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProcessDef(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPort(...) __attribute__ ((nothrow));
void _ssdm_op_SpecConnection(...) __attribute__ ((nothrow));
void _ssdm_op_SpecChannel(...) __attribute__ ((nothrow));
void _ssdm_op_SpecSensitive(...) __attribute__ ((nothrow));
void _ssdm_op_SpecModuleInst(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPortMap(...) __attribute__ ((nothrow));
void _ssdm_op_SpecReset(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPlatform(...) __attribute__ ((nothrow));
void _ssdm_op_SpecClockDomain(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPowerDomain(...) __attribute__ ((nothrow));
int _ssdm_op_SpecRegionBegin(...) __attribute__ ((nothrow));
int _ssdm_op_SpecRegionEnd(...) __attribute__ ((nothrow));
void _ssdm_op_SpecLoopName(...) __attribute__ ((nothrow));
void _ssdm_op_SpecLoopTripCount(...) __attribute__ ((nothrow));
int _ssdm_op_SpecStateBegin(...) __attribute__ ((nothrow));
int _ssdm_op_SpecStateEnd(...) __attribute__ ((nothrow));
void _ssdm_op_SpecInterface(...) __attribute__ ((nothrow));
void _ssdm_op_SpecPipeline(...) __attribute__ ((nothrow));
void _ssdm_op_SpecDataflowPipeline(...) __attribute__ ((nothrow));
void _ssdm_op_SpecLatency(...) __attribute__ ((nothrow));
void _ssdm_op_SpecParallel(...) __attribute__ ((nothrow));
void _ssdm_op_SpecProtocol(...) __attribute__ ((nothrow));
void _ssdm_op_SpecOccurrence(...) __attribute__ ((nothrow));
void _ssdm_op_SpecResource(...) __attribute__ ((nothrow));
void _ssdm_op_SpecResourceLimit(...) __attribute__ ((nothrow));
void _ssdm_op_SpecCHCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecFUCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecIFCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecIPCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecKeepValue(...) __attribute__ ((nothrow));
void _ssdm_op_SpecMemCore(...) __attribute__ ((nothrow));
void _ssdm_op_SpecExt(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayDimSize(...) __attribute__ ((nothrow));
void _ssdm_RegionBegin(...) __attribute__ ((nothrow));
void _ssdm_RegionEnd(...) __attribute__ ((nothrow));
void _ssdm_Unroll(...) __attribute__ ((nothrow));
void _ssdm_UnrollRegion(...) __attribute__ ((nothrow));
void _ssdm_InlineAll(...) __attribute__ ((nothrow));
void _ssdm_InlineLoop(...) __attribute__ ((nothrow));
void _ssdm_Inline(...) __attribute__ ((nothrow));
void _ssdm_InlineSelf(...) __attribute__ ((nothrow));
void _ssdm_InlineRegion(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayMap(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayPartition(...) __attribute__ ((nothrow));
void _ssdm_SpecArrayReshape(...) __attribute__ ((nothrow));
void _ssdm_SpecStream(...) __attribute__ ((nothrow));
void _ssdm_SpecExpr(...) __attribute__ ((nothrow));
void _ssdm_SpecExprBalance(...) __attribute__ ((nothrow));
void _ssdm_SpecDependence(...) __attribute__ ((nothrow));
void _ssdm_SpecLoopMerge(...) __attribute__ ((nothrow));
void _ssdm_SpecLoopFlatten(...) __attribute__ ((nothrow));
void _ssdm_SpecLoopRewind(...) __attribute__ ((nothrow));
void _ssdm_SpecFuncInstantiation(...) __attribute__ ((nothrow));
void _ssdm_SpecFuncBuffer(...) __attribute__ ((nothrow));
void _ssdm_SpecFuncExtract(...) __attribute__ ((nothrow));
void _ssdm_SpecConstant(...) __attribute__ ((nothrow));
void _ssdm_DataPack(...) __attribute__ ((nothrow));
void _ssdm_SpecDataPack(...) __attribute__ ((nothrow));
void _ssdm_op_SpecBitsMap(...) __attribute__ ((nothrow));
void _ssdm_op_SpecLicense(...) __attribute__ ((nothrow));
void __xilinx_ip_top(...) __attribute__ ((nothrow));
}
# 8 "<command line>" 2
# 1 "<built-in>" 2
# 1 "modules/V_read/V_read.cpp" 2
# 1 "modules/V_read/V_read.hpp" 1
# 1 "modules/V_read/../../Stream.h" 1
# 1 "/usr/include/assert.h" 1 3 4
# 35 "/usr/include/assert.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 345 "/usr/include/features.h" 3 4
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 346 "/usr/include/features.h" 2 3 4
# 367 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
# 410 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 411 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 368 "/usr/include/features.h" 2 3 4
# 391 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
# 392 "/usr/include/features.h" 2 3 4
# 36 "/usr/include/assert.h" 2 3 4
# 66 "/usr/include/assert.h" 3 4
extern "C" {
extern void __assert_fail (const char *__assertion, const char *__file,
unsigned int __line, const char *__function)
throw () __attribute__ ((__noreturn__));
extern void __assert_perror_fail (int __errnum, const char *__file,
unsigned int __line, const char *__function)
throw () __attribute__ ((__noreturn__));
extern void __assert (const char *__assertion, const char *__file, int __line)
throw () __attribute__ ((__noreturn__));
}
# 6 "modules/V_read/../../Stream.h" 2
# 1 "/opt/vivado2018/Vivado/2018.3/include/gmp.h" 1
# 26 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 1 3
# 38 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 3
# 38 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 3
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 1 3
# 153 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
namespace std
{
typedef long unsigned int size_t;
typedef long int ptrdiff_t;
}
# 393 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 3
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/os_defines.h" 1 3
# 394 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 2 3
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/cpu_defines.h" 1 3
# 397 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/x86_64-unknown-linux-gnu/bits/c++config.h" 2 3
# 40 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 2 3
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stringfwd.h" 1 3
# 39 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stringfwd.h" 3
# 39 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stringfwd.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
template<typename _Alloc>
class allocator;
template<class _CharT>
struct char_traits;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_string;
template<> struct char_traits<char>;
typedef basic_string<char> string;
template<> struct char_traits<wchar_t>;
typedef basic_string<wchar_t> wstring;
# 85 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/stringfwd.h" 3
}
# 41 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 2 3
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 1 3
# 40 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
# 40 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 1 3
# 41 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
# 41 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
# 1 "/usr/include/wchar.h" 1 3 4
# 36 "/usr/include/wchar.h" 3 4
# 1 "/usr/include/stdio.h" 1 3 4
# 44 "/usr/include/stdio.h" 3 4
struct _IO_FILE;
typedef struct _IO_FILE FILE;
# 64 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 37 "/usr/include/wchar.h" 2 3 4
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdarg.h" 1 3 4
# 30 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdarg.h" 3 4
typedef __builtin_va_list va_list;
# 48 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 40 "/usr/include/wchar.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wchar.h" 1 3 4
# 42 "/usr/include/wchar.h" 2 3 4
# 51 "/usr/include/wchar.h" 3 4
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
# 31 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
typedef __typeof__(((int*)0)-((int*)0)) ptrdiff_t;
typedef __typeof__(sizeof(int)) size_t;
# 72 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 3 4
typedef unsigned int wint_t;
# 52 "/usr/include/wchar.h" 2 3 4
# 82 "/usr/include/wchar.h" 3 4
typedef struct
{
int __count;
union
{
unsigned int __wch;
char __wchb[4];
} __value;
} __mbstate_t;
# 106 "/usr/include/wchar.h" 3 4
typedef __mbstate_t mbstate_t;
# 132 "/usr/include/wchar.h" 3 4
extern "C" {
struct tm;
# 147 "/usr/include/wchar.h" 3 4
extern wchar_t *wcscpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcscat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern wchar_t *wcsncat (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2,
size_t __n) throw ();
# 1 "/usr/include/xlocale.h" 1 3 4
# 27 "/usr/include/xlocale.h" 3 4
typedef struct __locale_struct
{
struct __locale_data *__locales[13];
const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;
const char *__names[13];
} *__locale_t;
typedef __locale_t locale_t;
# 184 "/usr/include/wchar.h" 2 3 4
extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
__locale_t __loc) throw ();
extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2,
size_t __n, __locale_t __loc) throw ();
extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) throw ();
extern size_t wcsxfrm (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
# 209 "/usr/include/wchar.h" 3 4
extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2,
__locale_t __loc) throw ();
extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2,
size_t __n, __locale_t __loc) throw ();
extern wchar_t *wcsdup (const wchar_t *__s) throw () __attribute__ ((__malloc__));
# 230 "/usr/include/wchar.h" 3 4
extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc)
throw () __attribute__ ((__pure__));
# 240 "/usr/include/wchar.h" 3 4
extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc)
throw () __attribute__ ((__pure__));
extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc)
throw () __attribute__ ((__pure__));
extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject)
throw () __attribute__ ((__pure__));
extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
# 269 "/usr/include/wchar.h" 3 4
extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept)
throw () __attribute__ ((__pure__));
# 280 "/usr/include/wchar.h" 3 4
extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle)
throw () __attribute__ ((__pure__));
extern wchar_t *wcstok (wchar_t *__restrict __s,
const wchar_t *__restrict __delim,
wchar_t **__restrict __ptr) throw ();
extern size_t wcslen (const wchar_t *__s) throw () __attribute__ ((__pure__));
# 302 "/usr/include/wchar.h" 3 4
extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle)
throw () __attribute__ ((__pure__));
extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen)
throw () __attribute__ ((__pure__));
# 323 "/usr/include/wchar.h" 3 4
extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n)
throw () __attribute__ ((__pure__));
extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n) throw ();
extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n)
throw ();
extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) throw ();
extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
const wchar_t *__restrict __s2, size_t __n)
throw ();
extern wint_t btowc (int __c) throw ();
extern int wctob (wint_t __c) throw ();
extern int mbsinit (const mbstate_t *__ps) throw () __attribute__ ((__pure__));
extern size_t mbrtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n,
mbstate_t *__restrict __p) throw ();
extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
mbstate_t *__restrict __ps) throw ();
extern size_t __mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
extern size_t mbrlen (const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps) throw ();
# 411 "/usr/include/wchar.h" 3 4
extern size_t mbsrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t wcsrtombs (char *__restrict __dst,
const wchar_t **__restrict __src, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
const char **__restrict __src, size_t __nmc,
size_t __len, mbstate_t *__restrict __ps) throw ();
extern size_t wcsnrtombs (char *__restrict __dst,
const wchar_t **__restrict __src,
size_t __nwc, size_t __len,
mbstate_t *__restrict __ps) throw ();
extern int wcwidth (wchar_t __c) throw ();
extern int wcswidth (const wchar_t *__s, size_t __n) throw ();
extern double wcstod (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern float wcstof (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long double wcstold (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr) throw ();
extern long int wcstol (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base) throw ();
extern unsigned long int wcstoul (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern long long int wcstoll (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
__extension__
extern long long int wcstoq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base)
throw ();
__extension__
extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base) throw ();
# 533 "/usr/include/wchar.h" 3 4
extern long int wcstol_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, int __base,
__locale_t __loc) throw ();
extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc) throw ();
__extension__
extern long long int wcstoll_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc) throw ();
__extension__
extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
int __base, __locale_t __loc)
throw ();
extern double wcstod_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, __locale_t __loc)
throw ();
extern float wcstof_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr, __locale_t __loc)
throw ();
extern long double wcstold_l (const wchar_t *__restrict __nptr,
wchar_t **__restrict __endptr,
__locale_t __loc) throw ();
extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src) throw ();
extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
const wchar_t *__restrict __src, size_t __n)
throw ();
extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) throw ();
extern int fwide (__FILE *__fp, int __mode) throw ();
extern int fwprintf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wprintf (const wchar_t *__restrict __format, ...)
;
extern int swprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format, ...)
throw () ;
extern int vfwprintf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwprintf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswprintf (wchar_t *__restrict __s, size_t __n,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
extern int fwscanf (__FILE *__restrict __stream,
const wchar_t *__restrict __format, ...)
;
extern int wscanf (const wchar_t *__restrict __format, ...)
;
extern int swscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format, ...)
throw () ;
# 692 "/usr/include/wchar.h" 3 4
extern int vfwscanf (__FILE *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vwscanf (const wchar_t *__restrict __format,
__gnuc_va_list __arg)
;
extern int vswscanf (const wchar_t *__restrict __s,
const wchar_t *__restrict __format,
__gnuc_va_list __arg)
throw () ;
# 748 "/usr/include/wchar.h" 3 4
extern wint_t fgetwc (__FILE *__stream);
extern wint_t getwc (__FILE *__stream);
extern wint_t getwchar (void);
extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwc (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar (wchar_t __wc);
extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
# 804 "/usr/include/wchar.h" 3 4
extern wint_t getwc_unlocked (__FILE *__stream);
extern wint_t getwchar_unlocked (void);
extern wint_t fgetwc_unlocked (__FILE *__stream);
extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
# 830 "/usr/include/wchar.h" 3 4
extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
extern wint_t putwchar_unlocked (wchar_t __wc);
# 840 "/usr/include/wchar.h" 3 4
extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
__FILE *__restrict __stream);
extern int fputws_unlocked (const wchar_t *__restrict __ws,
__FILE *__restrict __stream);
extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp) throw ();
extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
const wchar_t *__restrict __format,
const struct tm *__restrict __tp,
__locale_t __loc) throw ();
# 894 "/usr/include/wchar.h" 3 4
}
# 46 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 2 3
# 63 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
namespace std
{
using ::mbstate_t;
}
# 136 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
using ::wint_t;
using ::btowc;
using ::fgetwc;
using ::fgetws;
using ::fputwc;
using ::fputws;
using ::fwide;
using ::fwprintf;
using ::fwscanf;
using ::getwc;
using ::getwchar;
using ::mbrlen;
using ::mbrtowc;
using ::mbsinit;
using ::mbsrtowcs;
using ::putwc;
using ::putwchar;
using ::swprintf;
using ::swscanf;
using ::ungetwc;
using ::vfwprintf;
using ::vfwscanf;
using ::vswprintf;
using ::vswscanf;
using ::vwprintf;
using ::vwscanf;
using ::wcrtomb;
using ::wcscat;
using ::wcscmp;
using ::wcscoll;
using ::wcscpy;
using ::wcscspn;
using ::wcsftime;
using ::wcslen;
using ::wcsncat;
using ::wcsncmp;
using ::wcsncpy;
using ::wcsrtombs;
using ::wcsspn;
using ::wcstod;
using ::wcstof;
using ::wcstok;
using ::wcstol;
using ::wcstoul;
using ::wcsxfrm;
using ::wctob;
using ::wmemcmp;
using ::wmemcpy;
using ::wmemmove;
using ::wmemset;
using ::wprintf;
using ::wscanf;
using ::wcschr;
using ::wcspbrk;
using ::wcsrchr;
using ::wcsstr;
using ::wmemchr;
inline wchar_t*
wcschr(wchar_t* __p, wchar_t __c)
{ return wcschr(const_cast<const wchar_t*>(__p), __c); }
inline wchar_t*
wcspbrk(wchar_t* __s1, const wchar_t* __s2)
{ return wcspbrk(const_cast<const wchar_t*>(__s1), __s2); }
inline wchar_t*
wcsrchr(wchar_t* __p, wchar_t __c)
{ return wcsrchr(const_cast<const wchar_t*>(__p), __c); }
inline wchar_t*
wcsstr(wchar_t* __s1, const wchar_t* __s2)
{ return wcsstr(const_cast<const wchar_t*>(__s1), __s2); }
inline wchar_t*
wmemchr(wchar_t* __p, wchar_t __c, size_t __n)
{ return wmemchr(const_cast<const wchar_t*>(__p), __c, __n); }
}
namespace __gnu_cxx
{
using ::wcstold;
# 258 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cwchar" 3
using ::wcstoll;
using ::wcstoull;
}
namespace std
{
using ::__gnu_cxx::wcstold;
using ::__gnu_cxx::wcstoll;
using ::__gnu_cxx::wcstoull;
}
# 42 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 2 3
# 69 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 89 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
typedef long streamoff;
# 99 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
typedef ptrdiff_t streamsize;
# 112 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
template<typename _StateT>
class fpos
{
private:
streamoff _M_off;
_StateT _M_state;
public:
fpos()
: _M_off(0), _M_state() { }
# 134 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
fpos(streamoff __off)
: _M_off(__off), _M_state() { }
operator streamoff() const { return _M_off; }
void
state(_StateT __st)
{ _M_state = __st; }
_StateT
state() const
{ return _M_state; }
fpos&
operator+=(streamoff __off)
{
_M_off += __off;
return *this;
}
fpos&
operator-=(streamoff __off)
{
_M_off -= __off;
return *this;
}
fpos
operator+(streamoff __off) const
{
fpos __pos(*this);
__pos += __off;
return __pos;
}
fpos
operator-(streamoff __off) const
{
fpos __pos(*this);
__pos -= __off;
return __pos;
}
streamoff
operator-(const fpos& __other) const
{ return _M_off - __other._M_off; }
};
template<typename _StateT>
inline bool
operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) == streamoff(__rhs); }
template<typename _StateT>
inline bool
operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs)
{ return streamoff(__lhs) != streamoff(__rhs); }
typedef fpos<mbstate_t> streampos;
typedef fpos<mbstate_t> wstreampos;
# 241 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/bits/postypes.h" 3
}
# 42 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 2 3
namespace std __attribute__ ((__visibility__ ("default")))
{
# 75 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/iosfwd" 3
class ios_base;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ios;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_streambuf;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_istream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ostream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_iostream;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringbuf;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_istringstream;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_ostringstream;
template<typename _CharT, typename _Traits = char_traits<_CharT>,
typename _Alloc = allocator<_CharT> >
class basic_stringstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_filebuf;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ifstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_ofstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class basic_fstream;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class istreambuf_iterator;
template<typename _CharT, typename _Traits = char_traits<_CharT> >
class ostreambuf_iterator;
typedef basic_ios<char> ios;
typedef basic_streambuf<char> streambuf;
typedef basic_istream<char> istream;
typedef basic_ostream<char> ostream;
typedef basic_iostream<char> iostream;
typedef basic_stringbuf<char> stringbuf;
typedef basic_istringstream<char> istringstream;
typedef basic_ostringstream<char> ostringstream;
typedef basic_stringstream<char> stringstream;
typedef basic_filebuf<char> filebuf;
typedef basic_ifstream<char> ifstream;
typedef basic_ofstream<char> ofstream;
typedef basic_fstream<char> fstream;
typedef basic_ios<wchar_t> wios;
typedef basic_streambuf<wchar_t> wstreambuf;
typedef basic_istream<wchar_t> wistream;
typedef basic_ostream<wchar_t> wostream;
typedef basic_iostream<wchar_t> wiostream;
typedef basic_stringbuf<wchar_t> wstringbuf;
typedef basic_istringstream<wchar_t> wistringstream;
typedef basic_ostringstream<wchar_t> wostringstream;
typedef basic_stringstream<wchar_t> wstringstream;
typedef basic_filebuf<wchar_t> wfilebuf;
typedef basic_ifstream<wchar_t> wifstream;
typedef basic_ofstream<wchar_t> wofstream;
typedef basic_fstream<wchar_t> wfstream;
}
# 27 "/opt/vivado2018/Vivado/2018.3/include/gmp.h" 2
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstdio" 1 3
# 41 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstdio" 3
# 41 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstdio" 3
# 1 "/usr/include/stdio.h" 1 3 4
# 29 "/usr/include/stdio.h" 3 4
extern "C" {
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
# 34 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/types.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
typedef long int __quad_t;
typedef unsigned long int __u_quad_t;
# 121 "/usr/include/x86_64-linux-gnu/bits/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/typesizes.h" 1 3 4
# 122 "/usr/include/x86_64-linux-gnu/bits/types.h" 2 3 4
typedef unsigned long int __dev_t;
typedef unsigned int __uid_t;
typedef unsigned int __gid_t;
typedef unsigned long int __ino_t;
typedef unsigned long int __ino64_t;
typedef unsigned int __mode_t;
typedef unsigned long int __nlink_t;
typedef long int __off_t;
typedef long int __off64_t;
typedef int __pid_t;
typedef struct { int __val[2]; } __fsid_t;
typedef long int __clock_t;
typedef unsigned long int __rlim_t;
typedef unsigned long int __rlim64_t;
typedef unsigned int __id_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef int __daddr_t;
typedef int __key_t;
typedef int __clockid_t;
typedef void * __timer_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef long int __blkcnt64_t;
typedef unsigned long int __fsblkcnt_t;
typedef unsigned long int __fsblkcnt64_t;
typedef unsigned long int __fsfilcnt_t;
typedef unsigned long int __fsfilcnt64_t;
typedef long int __fsword_t;
typedef long int __ssize_t;
typedef long int __syscall_slong_t;
typedef unsigned long int __syscall_ulong_t;
typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;
typedef long int __intptr_t;
typedef unsigned int __socklen_t;
# 36 "/usr/include/stdio.h" 2 3 4
# 74 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 31 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 15 "/usr/include/_G_config.h" 3 4
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
# 16 "/usr/include/_G_config.h" 2 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 21 "/usr/include/_G_config.h" 2 3 4
typedef struct
{
__off_t __pos;
__mbstate_t __state;
} _G_fpos_t;
typedef struct
{
__off64_t __pos;
__mbstate_t __state;
} _G_fpos64_t;
# 32 "/usr/include/libio.h" 2 3 4
# 144 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
typedef void _IO_lock_t;
struct _IO_marker {
struct _IO_marker *_next;
struct _IO_FILE *_sbuf;
int _pos;
# 173 "/usr/include/libio.h" 3 4
};
enum __codecvt_result
{
__codecvt_ok,
__codecvt_partial,
__codecvt_error,
__codecvt_noconv
};
# 241 "/usr/include/libio.h" 3 4
struct _IO_FILE {
int _flags;
char* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
char* _IO_buf_base;
char* _IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _flags2;
__off_t _old_offset;
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
# 289 "/usr/include/libio.h" 3 4
__off64_t _offset;
void *__pad1;
void *__pad2;
void *__pad3;
void *__pad4;
size_t __pad5;
int _mode;
char _unused2[15 * sizeof (int) - 4 * sizeof (void *) - sizeof (size_t)];
};
struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
# 333 "/usr/include/libio.h" 3 4
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
typedef __ssize_t __io_write_fn (void *__cookie, const char *__buf,
size_t __n);
typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
typedef int __io_close_fn (void *__cookie);
typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;
typedef struct
{
__io_read_fn *read;
__io_write_fn *write;
__io_seek_fn *seek;
__io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;
struct _IO_cookie_file;
extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
void *__cookie, _IO_cookie_io_functions_t __fns);
extern "C" {
extern int __underflow (_IO_FILE *);
extern int __uflow (_IO_FILE *);
extern int __overflow (_IO_FILE *, int);
# 429 "/usr/include/libio.h" 3 4
extern int _IO_getc (_IO_FILE *__fp);
extern int _IO_putc (int __c, _IO_FILE *__fp);
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();
extern int _IO_peekc_locked (_IO_FILE *__fp);
extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
# 459 "/usr/include/libio.h" 3 4
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
__gnuc_va_list, int *__restrict);
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
__gnuc_va_list);
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t);
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t);
extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int);
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int);
extern void _IO_free_backup_area (_IO_FILE *) throw ();
# 521 "/usr/include/libio.h" 3 4
}
# 75 "/usr/include/stdio.h" 2 3 4
typedef __gnuc_va_list va_list;
# 90 "/usr/include/stdio.h" 3 4
typedef __off_t off_t;
typedef __off64_t off64_t;
typedef __ssize_t ssize_t;
typedef _G_fpos_t fpos_t;
typedef _G_fpos64_t fpos64_t;
# 164 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4
# 165 "/usr/include/stdio.h" 2 3 4
extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;
extern int remove (const char *__filename) throw ();
extern int rename (const char *__old, const char *__new) throw ();
extern int renameat (int __oldfd, const char *__old, int __newfd,
const char *__new) throw ();
# 195 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile (void) ;
# 205 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void) ;
extern char *tmpnam (char *__s) throw () ;
extern char *tmpnam_r (char *__s) throw () ;
# 227 "/usr/include/stdio.h" 3 4
extern char *tempnam (const char *__dir, const char *__pfx)
throw () __attribute__ ((__malloc__)) ;
# 237 "/usr/include/stdio.h" 3 4
extern int fclose (FILE *__stream);
extern int fflush (FILE *__stream);
# 252 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 262 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);
# 272 "/usr/include/stdio.h" 3 4
extern FILE *fopen (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
# 297 "/usr/include/stdio.h" 3 4
extern FILE *fopen64 (const char *__restrict __filename,
const char *__restrict __modes) ;
extern FILE *freopen64 (const char *__restrict __filename,
const char *__restrict __modes,
FILE *__restrict __stream) ;
extern FILE *fdopen (int __fd, const char *__modes) throw () ;
extern FILE *fopencookie (void *__restrict __magic_cookie,
const char *__restrict __modes,
_IO_cookie_io_functions_t __io_funcs) throw () ;
extern FILE *fmemopen (void *__s, size_t __len, const char *__modes)
throw () ;
extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) throw () ;
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) throw ();
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
size_t __size) throw ();
extern void setlinebuf (FILE *__stream) throw ();
# 356 "/usr/include/stdio.h" 3 4
extern int fprintf (FILE *__restrict __stream,
const char *__restrict __format, ...);
extern int printf (const char *__restrict __format, ...);
extern int sprintf (char *__restrict __s,
const char *__restrict __format, ...) throw ();
extern int vfprintf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg);
extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg);
extern int vsprintf (char *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg) throw ();
extern int snprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 3, 4)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vasprintf (char **__restrict __ptr, const char *__restrict __f,
__gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 2, 0))) ;
extern int __asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int asprintf (char **__restrict __ptr,
const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3))) ;
extern int vdprintf (int __fd, const char *__restrict __fmt,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, const char *__restrict __fmt, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
# 425 "/usr/include/stdio.h" 3 4
extern int fscanf (FILE *__restrict __stream,
const char *__restrict __format, ...) ;
extern int scanf (const char *__restrict __format, ...) ;
extern int sscanf (const char *__restrict __s,
const char *__restrict __format, ...) throw ();
# 471 "/usr/include/stdio.h" 3 4
extern int vfscanf (FILE *__restrict __s, const char *__restrict __format,
__gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 2, 0))) ;
extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg)
__attribute__ ((__format__ (__scanf__, 1, 0))) ;
extern int vsscanf (const char *__restrict __s,
const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
# 531 "/usr/include/stdio.h" 3 4
extern int fgetc (FILE *__stream);
extern int getc (FILE *__stream);
extern int getchar (void);
# 550 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 561 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);
# 573 "/usr/include/stdio.h" 3 4
extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);
extern int putchar (int __c);
# 594 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);
extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);
extern int getw (FILE *__stream);
extern int putw (int __w, FILE *__stream);
# 622 "/usr/include/stdio.h" 3 4
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
;
# 638 "/usr/include/stdio.h" 3 4
extern char *gets (char *__s) __attribute__ ((__deprecated__));
# 649 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
FILE *__restrict __stream) ;
# 665 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) ;
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) ;
# 689 "/usr/include/stdio.h" 3 4
extern int fputs (const char *__restrict __s, FILE *__restrict __stream);
extern int puts (const char *__s);
extern int ungetc (int __c, FILE *__stream);
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s);
# 726 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (const char *__restrict __s,
FILE *__restrict __stream);
# 737 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) ;
extern size_t fwrite_unlocked (const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream);
# 749 "/usr/include/stdio.h" 3 4
extern int fseek (FILE *__stream, long int __off, int __whence);
extern long int ftell (FILE *__stream) ;
extern void rewind (FILE *__stream);
# 773 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);
extern __off_t ftello (FILE *__stream) ;
# 798 "/usr/include/stdio.h" 3 4
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);
extern int fsetpos (FILE *__stream, const fpos_t *__pos);
# 818 "/usr/include/stdio.h" 3 4
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream) ;
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos);
extern void clearerr (FILE *__stream) throw ();
extern int feof (FILE *__stream) throw () ;
extern int ferror (FILE *__stream) throw () ;
extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw () ;
extern int ferror_unlocked (FILE *__stream) throw () ;
# 846 "/usr/include/stdio.h" 3 4
extern void perror (const char *__s);
# 1 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern const char *const sys_errlist[];
extern int _sys_nerr;
extern const char *const _sys_errlist[];
# 854 "/usr/include/stdio.h" 2 3 4
extern int fileno (FILE *__stream) throw () ;
extern int fileno_unlocked (FILE *__stream) throw () ;
# 872 "/usr/include/stdio.h" 3 4
extern FILE *popen (const char *__command, const char *__modes) ;
extern int pclose (FILE *__stream);
extern char *ctermid (char *__s) throw ();
extern char *cuserid (char *__s);
struct obstack;
extern int obstack_printf (struct obstack *__restrict __obstack,
const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
const char *__restrict __format,
__gnuc_va_list __args)
throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern void flockfile (FILE *__stream) throw ();
extern int ftrylockfile (FILE *__stream) throw () ;
extern void funlockfile (FILE *__stream) throw ();
# 942 "/usr/include/stdio.h" 3 4
}
# 44 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstdio" 2 3
# 91 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstdio" 3
namespace std
{
using ::FILE;
using ::fpos_t;
using ::clearerr;
using ::fclose;
using ::feof;
using ::ferror;
using ::fflush;
using ::fgetc;
using ::fgetpos;
using ::fgets;
using ::fopen;
using ::fprintf;
using ::fputc;
using ::fputs;
using ::fread;
using ::freopen;
using ::fscanf;
using ::fseek;
using ::fsetpos;
using ::ftell;
using ::fwrite;
using ::getc;
using ::getchar;
using ::gets;
using ::perror;
using ::printf;
using ::putc;
using ::putchar;
using ::puts;
using ::remove;
using ::rename;
using ::rewind;
using ::scanf;
using ::setbuf;
using ::setvbuf;
using ::sprintf;
using ::sscanf;
using ::tmpfile;
using ::tmpnam;
using ::ungetc;
using ::vfprintf;
using ::vprintf;
using ::vsprintf;
}
# 147 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstdio" 3
namespace __gnu_cxx
{
# 165 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstdio" 3
using ::snprintf;
using ::vfscanf;
using ::vscanf;
using ::vsnprintf;
using ::vsscanf;
}
namespace std
{
using ::__gnu_cxx::snprintf;
using ::__gnu_cxx::vfscanf;
using ::__gnu_cxx::vscanf;
using ::__gnu_cxx::vsnprintf;
using ::__gnu_cxx::vsscanf;
}
# 28 "/opt/vivado2018/Vivado/2018.3/include/gmp.h" 2
# 53 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstddef" 1 3
# 41 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstddef" 3
# 41 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstddef" 3
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3
# 44 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstddef" 2 3
# 54 "/opt/vivado2018/Vivado/2018.3/include/gmp.h" 2
# 201 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
typedef unsigned long int mp_limb_t;
typedef long int mp_limb_signed_t;
typedef unsigned long int mp_bitcnt_t;
typedef struct
{
int _mp_alloc;
int _mp_size;
mp_limb_t *_mp_d;
} __mpz_struct;
typedef __mpz_struct mpz_t[1];
typedef mp_limb_t * mp_ptr;
typedef const mp_limb_t * mp_srcptr;
typedef long int mp_size_t;
typedef long int mp_exp_t;
typedef struct
{
__mpz_struct _mp_num;
__mpz_struct _mp_den;
} __mpq_struct;
typedef __mpq_struct mpq_t[1];
typedef struct
{
int _mp_prec;
int _mp_size;
mp_exp_t _mp_exp;
mp_limb_t *_mp_d;
} __mpf_struct;
typedef __mpf_struct mpf_t[1];
typedef enum
{
GMP_RAND_ALG_DEFAULT = 0,
GMP_RAND_ALG_LC = GMP_RAND_ALG_DEFAULT
} gmp_randalg_t;
typedef struct
{
mpz_t _mp_seed;
gmp_randalg_t _mp_alg;
union {
void *_mp_lc;
} _mp_algdata;
} __gmp_randstate_struct;
typedef __gmp_randstate_struct gmp_randstate_t[1];
typedef const __mpz_struct *mpz_srcptr;
typedef __mpz_struct *mpz_ptr;
typedef const __mpf_struct *mpf_srcptr;
typedef __mpf_struct *mpf_ptr;
typedef const __mpq_struct *mpq_srcptr;
typedef __mpq_struct *mpq_ptr;
# 532 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
extern "C" {
using std::FILE;
void __gmp_set_memory_functions (void *(*) (size_t), void *(*) (void *, size_t, size_t), void (*) (void *, size_t)) throw ();
void __gmp_get_memory_functions (void *(**) (size_t), void *(**) (void *, size_t, size_t), void (**) (void *, size_t)) throw ();
extern const int __gmp_bits_per_limb;
extern int __gmp_errno;
extern const char * const __gmp_version;
extern const char * const __mpir_version;
void __gmp_randinit_default (gmp_randstate_t);
void __gmp_randinit_lc_2exp (gmp_randstate_t, mpz_srcptr, unsigned long int, mp_bitcnt_t);
int __gmp_randinit_lc_2exp_size (gmp_randstate_t, mp_bitcnt_t);
void __gmp_randinit_mt (gmp_randstate_t);
void __gmp_randinit_set (gmp_randstate_t, const __gmp_randstate_struct *);
void __gmp_randseed (gmp_randstate_t, mpz_srcptr);
void __gmp_randseed_ui (gmp_randstate_t, unsigned long int);
void __gmp_randclear (gmp_randstate_t);
unsigned long __gmp_urandomb_ui (gmp_randstate_t, unsigned long);
unsigned long __gmp_urandomm_ui (gmp_randstate_t, unsigned long);
int __gmp_asprintf (char **, const char *, ...);
int __gmp_fprintf (FILE *, const char *, ...);
# 615 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
int __gmp_printf (const char *, ...);
int __gmp_snprintf (char *, size_t, const char *, ...);
int __gmp_sprintf (char *, const char *, ...);
int __gmp_vasprintf (char **, const char *, va_list);
int __gmp_vfprintf (FILE *, const char *, va_list);
int __gmp_vprintf (const char *, va_list);
int __gmp_vsnprintf (char *, size_t, const char *, va_list);
int __gmp_vsprintf (char *, const char *, va_list);
int __gmp_fscanf (FILE *, const char *, ...);
int __gmp_scanf (const char *, ...);
int __gmp_sscanf (const char *, const char *, ...);
int __gmp_vfscanf (FILE *, const char *, va_list);
int __gmp_vscanf (const char *, va_list);
int __gmp_vsscanf (const char *, const char *, va_list);
# 684 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
void *__gmpz_realloc (mpz_ptr, mp_size_t);
void __gmpz_abs (mpz_ptr, mpz_srcptr);
void __gmpz_add (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_add_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_addmul (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_addmul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_and (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_array_init (mpz_ptr, mp_size_t, mp_size_t);
void __gmpz_bin_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_bin_uiui (mpz_ptr, unsigned long int, unsigned long int);
void __gmpz_cdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_cdiv_q_2exp (mpz_ptr, mpz_srcptr, unsigned long);
unsigned long int __gmpz_cdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_cdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_cdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_cdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_cdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_cdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
unsigned long int __gmpz_cdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
void __gmpz_clear (mpz_ptr);
void __gmpz_clears (mpz_ptr, ...);
void __gmpz_clrbit (mpz_ptr, mp_bitcnt_t);
int __gmpz_cmp (mpz_srcptr, mpz_srcptr) throw () __attribute__ ((__pure__));
int __gmpz_cmp_d (mpz_srcptr, double) __attribute__ ((__pure__));
int __gmpz_cmp_si (mpz_srcptr, signed long int) throw () __attribute__ ((__pure__));
int __gmpz_cmp_ui (mpz_srcptr, unsigned long int) throw () __attribute__ ((__pure__));
int __gmpz_cmpabs (mpz_srcptr, mpz_srcptr) throw () __attribute__ ((__pure__));
int __gmpz_cmpabs_d (mpz_srcptr, double) __attribute__ ((__pure__));
int __gmpz_cmpabs_ui (mpz_srcptr, unsigned long int) throw () __attribute__ ((__pure__));
void __gmpz_com (mpz_ptr, mpz_srcptr);
void __gmpz_combit (mpz_ptr, mp_bitcnt_t);
int __gmpz_congruent_p (mpz_srcptr, mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_congruent_2exp_p (mpz_srcptr, mpz_srcptr, mp_bitcnt_t) throw () __attribute__ ((__pure__));
int __gmpz_congruent_ui_p (mpz_srcptr, unsigned long, unsigned long) __attribute__ ((__pure__));
void __gmpz_divexact (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_divexact_ui (mpz_ptr, mpz_srcptr, unsigned long);
int __gmpz_divisible_p (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_divisible_ui_p (mpz_srcptr, unsigned long) __attribute__ ((__pure__));
int __gmpz_divisible_2exp_p (mpz_srcptr, mp_bitcnt_t) throw () __attribute__ ((__pure__));
void __gmpz_dump (mpz_srcptr);
void *__gmpz_export (void *, size_t *, int, size_t, int, size_t, mpz_srcptr);
void __gmpz_fac_ui (mpz_ptr, unsigned long int);
void __gmpz_fdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_fdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_fdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_fdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_fdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_fdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_fdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_fdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
unsigned long int __gmpz_fdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
void __gmpz_fib_ui (mpz_ptr, unsigned long int);
void __gmpz_fib2_ui (mpz_ptr, mpz_ptr, unsigned long int);
int __gmpz_fits_sint_p (mpz_srcptr) throw () __attribute__ ((__pure__));
int __gmpz_fits_slong_p (mpz_srcptr) throw () __attribute__ ((__pure__));
int __gmpz_fits_sshort_p (mpz_srcptr) throw () __attribute__ ((__pure__));
int __gmpz_fits_uint_p (mpz_srcptr) throw () __attribute__ ((__pure__));
int __gmpz_fits_ulong_p (mpz_srcptr) throw () __attribute__ ((__pure__));
int __gmpz_fits_ushort_p (mpz_srcptr) throw () __attribute__ ((__pure__));
void __gmpz_gcd (mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_gcd_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_gcdext (mpz_ptr, mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
double __gmpz_get_d (mpz_srcptr) __attribute__ ((__pure__));
double __gmpz_get_d_2exp (signed long int *, mpz_srcptr);
long int __gmpz_get_si (mpz_srcptr) throw () __attribute__ ((__pure__));
char *__gmpz_get_str (char *, int, mpz_srcptr);
unsigned long int __gmpz_get_ui (mpz_srcptr) throw () __attribute__ ((__pure__));
mp_limb_t __gmpz_getlimbn (mpz_srcptr, mp_size_t) throw () __attribute__ ((__pure__));
mp_bitcnt_t __gmpz_hamdist (mpz_srcptr, mpz_srcptr) throw () __attribute__ ((__pure__));
void __gmpz_import (mpz_ptr, size_t, int, size_t, int, size_t, const void *);
void __gmpz_init (mpz_ptr);
void __gmpz_init2 (mpz_ptr, mp_bitcnt_t);
void __gmpz_inits (mpz_ptr, ...);
void __gmpz_init_set (mpz_ptr, mpz_srcptr);
void __gmpz_init_set_d (mpz_ptr, double);
void __gmpz_init_set_si (mpz_ptr, signed long int);
int __gmpz_init_set_str (mpz_ptr, const char *, int);
void __gmpz_init_set_ui (mpz_ptr, unsigned long int);
size_t __gmpz_inp_raw (mpz_ptr, FILE *);
size_t __gmpz_inp_str (mpz_ptr, FILE *, int);
int __gmpz_invert (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_ior (mpz_ptr, mpz_srcptr, mpz_srcptr);
int __gmpz_jacobi (mpz_srcptr, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_kronecker_si (mpz_srcptr, long) __attribute__ ((__pure__));
int __gmpz_kronecker_ui (mpz_srcptr, unsigned long) __attribute__ ((__pure__));
int __gmpz_si_kronecker (long, mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_ui_kronecker (unsigned long, mpz_srcptr) __attribute__ ((__pure__));
void __gmpz_lcm (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_lcm_ui (mpz_ptr, mpz_srcptr, unsigned long);
void __gmpz_lucnum_ui (mpz_ptr, unsigned long int);
void __gmpz_lucnum2_ui (mpz_ptr, mpz_ptr, unsigned long int);
int __gmpz_millerrabin (mpz_srcptr, int) __attribute__ ((__pure__));
void __gmpz_mod (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_mul (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_mul_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
void __gmpz_mul_si (mpz_ptr, mpz_srcptr, long int);
void __gmpz_mul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_neg (mpz_ptr, mpz_srcptr);
void __gmpz_nextprime (mpz_ptr, mpz_srcptr);
void __gmpz_next_likely_prime (mpz_ptr, mpz_srcptr,gmp_randstate_t);
size_t __gmpz_out_raw (FILE *, mpz_srcptr);
size_t __gmpz_out_str (FILE *, int, mpz_srcptr);
int __gmpz_perfect_power_p (mpz_srcptr) __attribute__ ((__pure__));
int __gmpz_perfect_square_p (mpz_srcptr) __attribute__ ((__pure__));
mp_bitcnt_t __gmpz_popcount (mpz_srcptr) throw () __attribute__ ((__pure__));
void __gmpz_pow_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_powm (mpz_ptr, mpz_srcptr, mpz_srcptr, mpz_srcptr);
void __gmpz_powm_ui (mpz_ptr, mpz_srcptr, unsigned long int, mpz_srcptr);
int __gmpz_probab_prime_p (mpz_srcptr, int) __attribute__ ((__pure__));
int __gmpz_probable_prime_p (mpz_srcptr,gmp_randstate_t, int,unsigned long);
int __gmpz_likely_prime_p (mpz_srcptr,gmp_randstate_t, unsigned long);
void __gmpz_realloc2 (mpz_ptr, mp_bitcnt_t);
unsigned long int __gmpz_remove (mpz_ptr, mpz_srcptr, mpz_srcptr);
int __gmpz_root (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_nthroot (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_rootrem (mpz_ptr,mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_rrandomb (mpz_ptr, gmp_randstate_t, mp_bitcnt_t);
mp_bitcnt_t __gmpz_scan0 (mpz_srcptr, mp_bitcnt_t) throw () __attribute__ ((__pure__));
mp_bitcnt_t __gmpz_scan1 (mpz_srcptr, mp_bitcnt_t) throw () __attribute__ ((__pure__));
void __gmpz_set (mpz_ptr, mpz_srcptr);
void __gmpz_set_d (mpz_ptr, double);
void __gmpz_set_f (mpz_ptr, mpf_srcptr);
void __gmpz_set_q (mpz_ptr, mpq_srcptr);
void __gmpz_set_si (mpz_ptr, signed long int);
int __gmpz_set_str (mpz_ptr, const char *, int);
void __gmpz_set_ui (mpz_ptr, unsigned long int);
void __gmpz_setbit (mpz_ptr, mp_bitcnt_t);
size_t __gmpz_size (mpz_srcptr) throw () __attribute__ ((__pure__));
size_t __gmpz_sizeinbase (mpz_srcptr, int) throw () __attribute__ ((__pure__));
void __gmpz_sqrt (mpz_ptr, mpz_srcptr);
void __gmpz_sqrtrem (mpz_ptr, mpz_ptr, mpz_srcptr);
void __gmpz_sub (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_sub_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_ui_sub (mpz_ptr, unsigned long int, mpz_srcptr);
void __gmpz_submul (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_submul_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_swap (mpz_ptr, mpz_ptr) throw ();
unsigned long int __gmpz_tdiv_ui (mpz_srcptr, unsigned long int) __attribute__ ((__pure__));
void __gmpz_tdiv_q (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_tdiv_q_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_tdiv_q_ui (mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_tdiv_qr (mpz_ptr, mpz_ptr, mpz_srcptr, mpz_srcptr);
unsigned long int __gmpz_tdiv_qr_ui (mpz_ptr, mpz_ptr, mpz_srcptr, unsigned long int);
void __gmpz_tdiv_r (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpz_tdiv_r_2exp (mpz_ptr, mpz_srcptr, mp_bitcnt_t);
unsigned long int __gmpz_tdiv_r_ui (mpz_ptr, mpz_srcptr, unsigned long int);
int __gmpz_tstbit (mpz_srcptr, mp_bitcnt_t) throw () __attribute__ ((__pure__));
void __gmpz_ui_pow_ui (mpz_ptr, unsigned long int, unsigned long int);
void __gmpz_urandomb (mpz_ptr, gmp_randstate_t, mp_bitcnt_t);
void __gmpz_urandomm (mpz_ptr, gmp_randstate_t, mpz_srcptr);
void __gmpz_xor (mpz_ptr, mpz_srcptr, mpz_srcptr);
void __gmpq_abs (mpq_ptr, mpq_srcptr);
void __gmpq_add (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_canonicalize (mpq_ptr);
void __gmpq_clear (mpq_ptr);
void __gmpq_clears (mpq_ptr, ...);
int __gmpq_cmp (mpq_srcptr, mpq_srcptr) __attribute__ ((__pure__));
int __gmpq_cmp_si (mpq_srcptr, long, unsigned long) __attribute__ ((__pure__));
int __gmpq_cmp_ui (mpq_srcptr, unsigned long int, unsigned long int) __attribute__ ((__pure__));
void __gmpq_div (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_div_2exp (mpq_ptr, mpq_srcptr, mp_bitcnt_t);
int __gmpq_equal (mpq_srcptr, mpq_srcptr) throw () __attribute__ ((__pure__));
void __gmpq_get_num (mpz_ptr, mpq_srcptr);
void __gmpq_get_den (mpz_ptr, mpq_srcptr);
double __gmpq_get_d (mpq_srcptr) __attribute__ ((__pure__));
char *__gmpq_get_str (char *, int, mpq_srcptr);
void __gmpq_init (mpq_ptr);
void __gmpq_inits (mpq_ptr, ...);
size_t __gmpq_inp_str (mpq_ptr, FILE *, int);
void __gmpq_inv (mpq_ptr, mpq_srcptr);
void __gmpq_mul (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_mul_2exp (mpq_ptr, mpq_srcptr, mp_bitcnt_t);
void __gmpq_neg (mpq_ptr, mpq_srcptr);
size_t __gmpq_out_str (FILE *, int, mpq_srcptr);
void __gmpq_set (mpq_ptr, mpq_srcptr);
void __gmpq_set_d (mpq_ptr, double);
void __gmpq_set_den (mpq_ptr, mpz_srcptr);
void __gmpq_set_f (mpq_ptr, mpf_srcptr);
void __gmpq_set_num (mpq_ptr, mpz_srcptr);
void __gmpq_set_si (mpq_ptr, signed long int, unsigned long int);
int __gmpq_set_str (mpq_ptr, const char *, int);
void __gmpq_set_ui (mpq_ptr, unsigned long int, unsigned long int);
void __gmpq_set_z (mpq_ptr, mpz_srcptr);
void __gmpq_sub (mpq_ptr, mpq_srcptr, mpq_srcptr);
void __gmpq_swap (mpq_ptr, mpq_ptr) throw ();
void __gmpf_abs (mpf_ptr, mpf_srcptr);
void __gmpf_add (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_add_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_ceil (mpf_ptr, mpf_srcptr);
void __gmpf_clear (mpf_ptr);
void __gmpf_clears (mpf_ptr, ...);
int __gmpf_cmp (mpf_srcptr, mpf_srcptr) throw () __attribute__ ((__pure__));
int __gmpf_cmp_d (mpf_srcptr, double) __attribute__ ((__pure__));
int __gmpf_cmp_si (mpf_srcptr, signed long int) throw () __attribute__ ((__pure__));
int __gmpf_cmp_ui (mpf_srcptr, unsigned long int) throw () __attribute__ ((__pure__));
void __gmpf_div (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_div_2exp (mpf_ptr, mpf_srcptr, mp_bitcnt_t);
void __gmpf_div_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_dump (mpf_srcptr);
int __gmpf_eq (mpf_srcptr, mpf_srcptr, unsigned long int) __attribute__ ((__pure__));
int __gmpf_fits_sint_p (mpf_srcptr) throw () __attribute__ ((__pure__));
int __gmpf_fits_slong_p (mpf_srcptr) throw () __attribute__ ((__pure__));
int __gmpf_fits_sshort_p (mpf_srcptr) throw () __attribute__ ((__pure__));
int __gmpf_fits_uint_p (mpf_srcptr) throw () __attribute__ ((__pure__));
int __gmpf_fits_ulong_p (mpf_srcptr) throw () __attribute__ ((__pure__));
int __gmpf_fits_ushort_p (mpf_srcptr) throw () __attribute__ ((__pure__));
void __gmpf_floor (mpf_ptr, mpf_srcptr);
double __gmpf_get_d (mpf_srcptr) __attribute__ ((__pure__));
double __gmpf_get_d_2exp (signed long int *, mpf_srcptr);
mp_bitcnt_t __gmpf_get_default_prec (void) throw () __attribute__ ((__pure__));
mp_bitcnt_t __gmpf_get_prec (mpf_srcptr) throw () __attribute__ ((__pure__));
long __gmpf_get_si (mpf_srcptr) throw () __attribute__ ((__pure__));
char *__gmpf_get_str (char *, mp_exp_t *, int, size_t, mpf_srcptr);
unsigned long __gmpf_get_ui (mpf_srcptr) throw () __attribute__ ((__pure__));
void __gmpf_init (mpf_ptr);
void __gmpf_init2 (mpf_ptr, mp_bitcnt_t);
void __gmpf_inits (mpf_ptr, ...);
void __gmpf_init_set (mpf_ptr, mpf_srcptr);
void __gmpf_init_set_d (mpf_ptr, double);
void __gmpf_init_set_si (mpf_ptr, signed long int);
int __gmpf_init_set_str (mpf_ptr, const char *, int);
void __gmpf_init_set_ui (mpf_ptr, unsigned long int);
size_t __gmpf_inp_str (mpf_ptr, FILE *, int);
int __gmpf_integer_p (mpf_srcptr) throw () __attribute__ ((__pure__));
void __gmpf_mul (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_mul_2exp (mpf_ptr, mpf_srcptr, mp_bitcnt_t);
void __gmpf_mul_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_neg (mpf_ptr, mpf_srcptr);
size_t __gmpf_out_str (FILE *, int, size_t, mpf_srcptr);
void __gmpf_pow_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_random2 (mpf_ptr, mp_size_t, mp_exp_t);
void __gmpf_rrandomb (mpf_ptr, gmp_randstate_t, mp_size_t, mp_exp_t);
void __gmpf_reldiff (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_set (mpf_ptr, mpf_srcptr);
void __gmpf_set_d (mpf_ptr, double);
void __gmpf_set_default_prec (mp_bitcnt_t) throw ();
void __gmpf_set_prec (mpf_ptr, mp_bitcnt_t);
void __gmpf_set_prec_raw (mpf_ptr, mp_bitcnt_t) throw ();
void __gmpf_set_q (mpf_ptr, mpq_srcptr);
void __gmpf_set_si (mpf_ptr, signed long int);
int __gmpf_set_str (mpf_ptr, const char *, int);
void __gmpf_set_ui (mpf_ptr, unsigned long int);
void __gmpf_set_z (mpf_ptr, mpz_srcptr);
size_t __gmpf_size (mpf_srcptr) throw () __attribute__ ((__pure__));
void __gmpf_sqrt (mpf_ptr, mpf_srcptr);
void __gmpf_sqrt_ui (mpf_ptr, unsigned long int);
void __gmpf_sub (mpf_ptr, mpf_srcptr, mpf_srcptr);
void __gmpf_sub_ui (mpf_ptr, mpf_srcptr, unsigned long int);
void __gmpf_swap (mpf_ptr, mpf_ptr) throw ();
void __gmpf_trunc (mpf_ptr, mpf_srcptr);
void __gmpf_ui_div (mpf_ptr, unsigned long int, mpf_srcptr);
void __gmpf_ui_sub (mpf_ptr, unsigned long int, mpf_srcptr);
void __gmpf_urandomb (mpf_t, gmp_randstate_t, mp_bitcnt_t);
# 1516 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
mp_limb_t __gmpn_add (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t);
mp_limb_t __gmpn_add_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t) throw ();
mp_limb_t __gmpn_add_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_addmul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t __gmpn_bdivmod (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, unsigned long int);
mp_limb_t __gmpn_divrem (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr, mp_size_t);
int __gmpn_mulmod_2expp1 (mp_ptr, mp_srcptr, mp_srcptr,int,unsigned long, mp_ptr);
void __gmpn_mulmod_2expm1 (mp_ptr, mp_ptr, mp_ptr,unsigned long, mp_ptr);
int __gmpn_cmp (mp_srcptr, mp_srcptr, mp_size_t) throw () __attribute__ ((__pure__));
mp_limb_t __gmpn_divexact_by3c (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t __gmpn_divrem_1 (mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_limb_t);
mp_limb_t __gmpn_divrem_2 (mp_ptr, mp_size_t, mp_ptr, mp_size_t, mp_srcptr);
void __gmpn_invert (mp_ptr xp, mp_srcptr ap, mp_size_t n);
mp_limb_t __gmpn_sb_divappr_q (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_limb_t dip);
mp_limb_t __gmpn_dc_divappr_q_n (mp_ptr qp, mp_ptr np, mp_srcptr dp, mp_size_t n, mp_limb_t dip, mp_ptr tp);
void __gmpn_dc_bdiv_q_n (mp_ptr qp, mp_ptr wp, mp_ptr np, mp_srcptr dp, mp_size_t n, mp_limb_t dinv, mp_ptr scratch);
mp_limb_t __gmpn_inv_divappr_q_n (mp_ptr qp, mp_ptr np, mp_srcptr dp, mp_size_t n, mp_srcptr dip);
mp_limb_t __gmpn_dc_divappr_q (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t n, mp_limb_t dinv);
mp_limb_t __gmpn_dc_div_q (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_limb_t dinv);
mp_limb_t __gmpn_inv_divappr_q (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t n, mp_srcptr dinv);
mp_limb_t __gmpn_inv_div_q (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_srcptr dinv);
mp_limb_t __gmpn_inv_div_qr (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_srcptr dinv);
mp_limb_t __gmpn_inv_div_qr_n (mp_ptr qp, mp_ptr np, mp_srcptr dp, mp_size_t dn, mp_srcptr dinv);
mp_limb_t __gmpn_dc_div_qr (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_limb_t dinv);
mp_limb_t __gmpn_dc_div_qr_n (mp_ptr qp, mp_ptr np, mp_srcptr dp, mp_size_t n, mp_limb_t dinv, mp_ptr tp);
mp_limb_t __gmpn_sb_div_q (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_limb_t dinv);
void __gmpn_sb_bdiv_q (mp_ptr qp, mp_ptr wp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_limb_t dinv);
void __gmpn_dc_bdiv_q (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_limb_t dinv);
mp_limb_t __gmpn_dc_bdiv_qr (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_limb_t dinv);
mp_limb_t __gmpn_dc_bdiv_qr_n (mp_ptr qp, mp_ptr np, mp_srcptr dp, mp_size_t n, mp_limb_t dinv, mp_ptr tp);
mp_limb_t __gmpn_sb_div_qr (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_limb_t dinv);
mp_limb_t __gmpn_sb_bdiv_qr (mp_ptr qp, mp_ptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn, mp_limb_t dinv);
void __gmpn_tdiv_q (mp_ptr qp, mp_srcptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn);
void __gmpn_divexact (mp_ptr qp, mp_srcptr np, mp_size_t nn, mp_srcptr dp, mp_size_t dn);
void __gmpn_redc_1 (mp_ptr, mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
mp_size_t __gmpn_gcd (mp_ptr, mp_ptr, mp_size_t, mp_ptr, mp_size_t);
mp_limb_t __gmpn_gcd_1 (mp_srcptr, mp_size_t, mp_limb_t) __attribute__ ((__pure__));
mp_size_t __gmpn_gcdext (mp_ptr, mp_ptr, mp_size_t *, mp_ptr, mp_size_t, mp_ptr, mp_size_t);
size_t __gmpn_get_str (unsigned char *, int, mp_ptr, mp_size_t);
mp_bitcnt_t __gmpn_hamdist (mp_srcptr, mp_srcptr, mp_size_t) throw () __attribute__ ((__pure__));
mp_limb_t __gmpn_lshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
mp_limb_t __gmpn_mod_1 (mp_srcptr, mp_size_t, mp_limb_t) __attribute__ ((__pure__));
mp_limb_t __gmpn_mul (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_mul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
void __gmpn_mul_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_sqr (mp_ptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_neg_n (mp_ptr, mp_srcptr, mp_size_t);
void __gmpn_com_n (mp_ptr, mp_srcptr, mp_size_t);
int __gmpn_perfect_square_p (mp_srcptr, mp_size_t) __attribute__ ((__pure__));
mp_bitcnt_t __gmpn_popcount (mp_srcptr, mp_size_t) throw () __attribute__ ((__pure__));
mp_size_t __gmpn_pow_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t, mp_ptr);
mp_limb_t __gmpn_preinv_mod_1 (mp_srcptr, mp_size_t, mp_limb_t, mp_limb_t) __attribute__ ((__pure__));
void __gmpn_random (mp_ptr, mp_size_t);
void __gmpn_random2 (mp_ptr, mp_size_t);
void __gmpn_urandomb (mp_ptr, gmp_randstate_t, unsigned long);
void __gmpn_urandomm (mp_ptr, gmp_randstate_t, mp_srcptr, mp_size_t);
void __gmpn_randomb (mp_ptr, gmp_randstate_t, mp_size_t);
void __gmpn_rrandom (mp_ptr, gmp_randstate_t, mp_size_t);
mp_limb_t __gmpn_rshift (mp_ptr, mp_srcptr, mp_size_t, unsigned int);
mp_bitcnt_t __gmpn_scan0 (mp_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));
mp_bitcnt_t __gmpn_scan1 (mp_srcptr, mp_bitcnt_t) __attribute__ ((__pure__));
mp_size_t __gmpn_set_str (mp_ptr, const unsigned char *, size_t, int);
mp_size_t __gmpn_sqrtrem (mp_ptr, mp_ptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_sub (mp_ptr, mp_srcptr, mp_size_t, mp_srcptr,mp_size_t);
mp_limb_t __gmpn_sub_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t) throw ();
mp_limb_t __gmpn_sub_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
mp_limb_t __gmpn_submul_1 (mp_ptr, mp_srcptr, mp_size_t, mp_limb_t);
void __gmpn_tdiv_qr (mp_ptr, mp_ptr, mp_size_t, mp_srcptr, mp_size_t, mp_srcptr, mp_size_t);
void __gmpn_and_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_andn_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_nand_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_ior_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_iorn_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_nior_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_xor_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_xnor_n (mp_ptr, mp_srcptr, mp_srcptr, mp_size_t);
void __gmpn_copyi (mp_ptr, mp_srcptr, mp_size_t);
void __gmpn_copyd (mp_ptr, mp_srcptr, mp_size_t);
void __gmpn_zero (mp_ptr, mp_size_t);
# 1799 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
extern __inline__ __attribute__((__gnu_inline__)) void
__gmpz_abs (mpz_ptr __gmp_w, mpz_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpz_set (__gmp_w, __gmp_u);
__gmp_w->_mp_size = ((__gmp_w->_mp_size) >= 0 ? (__gmp_w->_mp_size) : -(__gmp_w->_mp_size));
}
# 1823 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
extern __inline__ __attribute__((__gnu_inline__))
int
__gmpz_fits_uint_p (mpz_srcptr __gmp_z) throw ()
{
mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= (~ (unsigned) 0)));;
}
extern __inline__ __attribute__((__gnu_inline__))
int
__gmpz_fits_ulong_p (mpz_srcptr __gmp_z) throw ()
{
mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= (~ (unsigned long) 0)));;
}
extern __inline__ __attribute__((__gnu_inline__))
int
__gmpz_fits_ushort_p (mpz_srcptr __gmp_z) throw ()
{
mp_size_t __gmp_n = __gmp_z->_mp_size; mp_ptr __gmp_p = __gmp_z->_mp_d; return (__gmp_n == 0 || (__gmp_n == 1 && __gmp_p[0] <= ((unsigned short) ~0)));;
}
extern __inline__ __attribute__((__gnu_inline__))
unsigned long
__gmpz_get_ui (mpz_srcptr __gmp_z) throw ()
{
mp_ptr __gmp_p = __gmp_z->_mp_d;
mp_size_t __gmp_n = __gmp_z->_mp_size;
mp_limb_t __gmp_l = __gmp_p[0];
return (unsigned long)(__gmp_n != 0 ? __gmp_l : 0);
# 1879 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
}
extern __inline__ __attribute__((__gnu_inline__))
mp_limb_t
__gmpz_getlimbn (mpz_srcptr __gmp_z, mp_size_t __gmp_n) throw ()
{
mp_limb_t __gmp_result = 0;
if (__builtin_expect ((__gmp_n >= 0 && __gmp_n < ((__gmp_z->_mp_size) >= 0 ? (__gmp_z->_mp_size) : -(__gmp_z->_mp_size))) != 0, 1))
__gmp_result = __gmp_z->_mp_d[__gmp_n];
return __gmp_result;
}
extern __inline__ __attribute__((__gnu_inline__)) void
__gmpz_neg (mpz_ptr __gmp_w, mpz_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpz_set (__gmp_w, __gmp_u);
__gmp_w->_mp_size = - __gmp_w->_mp_size;
}
extern __inline__ __attribute__((__gnu_inline__))
int
__gmpz_perfect_square_p (mpz_srcptr __gmp_a)
{
mp_size_t __gmp_asize;
int __gmp_result;
__gmp_asize = __gmp_a->_mp_size;
__gmp_result = (__gmp_asize >= 0);
if (__builtin_expect ((__gmp_asize > 0) != 0, 1))
__gmp_result = __gmpn_perfect_square_p (__gmp_a->_mp_d, __gmp_asize);
return __gmp_result;
}
extern __inline__ __attribute__((__gnu_inline__))
mp_bitcnt_t
__gmpz_popcount (mpz_srcptr __gmp_u) throw ()
{
mp_size_t __gmp_usize;
mp_bitcnt_t __gmp_result;
__gmp_usize = __gmp_u->_mp_size;
__gmp_result = (__gmp_usize < 0 ? (~ (unsigned long) 0) : 0);
if (__builtin_expect ((__gmp_usize > 0) != 0, 1))
__gmp_result = __gmpn_popcount (__gmp_u->_mp_d, __gmp_usize);
return __gmp_result;
}
extern __inline__ __attribute__((__gnu_inline__))
void
__gmpz_set_q (mpz_ptr __gmp_w, mpq_srcptr __gmp_u)
{
__gmpz_tdiv_q (__gmp_w, (&((__gmp_u)->_mp_num)), (&((__gmp_u)->_mp_den)));
}
extern __inline__ __attribute__((__gnu_inline__))
size_t
__gmpz_size (mpz_srcptr __gmp_z) throw ()
{
return ((__gmp_z->_mp_size) >= 0 ? (__gmp_z->_mp_size) : -(__gmp_z->_mp_size));
}
extern __inline__ __attribute__((__gnu_inline__)) void
__gmpq_abs (mpq_ptr __gmp_w, mpq_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpq_set (__gmp_w, __gmp_u);
__gmp_w->_mp_num._mp_size = ((__gmp_w->_mp_num._mp_size) >= 0 ? (__gmp_w->_mp_num._mp_size) : -(__gmp_w->_mp_num._mp_size));
}
extern __inline__ __attribute__((__gnu_inline__)) void
__gmpq_neg (mpq_ptr __gmp_w, mpq_srcptr __gmp_u)
{
if (__gmp_w != __gmp_u)
__gmpq_set (__gmp_w, __gmp_u);
__gmp_w->_mp_num._mp_size = - __gmp_w->_mp_num._mp_size;
}
# 2220 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
extern __inline__ __attribute__((__gnu_inline__))
mp_limb_t
__gmpn_add (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize)
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x; __gmp_i = (__gmp_ysize); if (__gmp_i != 0) { if (__gmpn_add_n (__gmp_wp, __gmp_xp, __gmp_yp, __gmp_i)) { do { if (__gmp_i >= (__gmp_xsize)) { (__gmp_c) = 1; goto __gmp_done; } __gmp_x = (__gmp_xp)[__gmp_i]; } while ((((__gmp_wp)[__gmp_i++] = (__gmp_x + 1) & ((~ (static_cast<mp_limb_t> (0))) >> 0)) == 0)); } } if ((__gmp_wp) != (__gmp_xp)) do { mp_size_t __gmp_j; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_xsize); __gmp_j++) (__gmp_wp)[__gmp_j] = (__gmp_xp)[__gmp_j]; } while (0); (__gmp_c) = 0; __gmp_done: ; } while (0);
return __gmp_c;
}
extern __inline__ __attribute__((__gnu_inline__))
mp_limb_t
__gmpn_add_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n) throw ()
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_r; __gmp_x = (__gmp_src)[0]; __gmp_r = __gmp_x + (__gmp_n); (__gmp_dst)[0] = __gmp_r; if (((__gmp_r) < ((__gmp_n)))) { (__gmp_c) = 1; for (__gmp_i = 1; __gmp_i < (__gmp_size);) { __gmp_x = (__gmp_src)[__gmp_i]; __gmp_r = __gmp_x + 1; (__gmp_dst)[__gmp_i] = __gmp_r; ++__gmp_i; if (!((__gmp_r) < (1))) { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; break; } } } else { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; for (__gmp_j = (1); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; } } while (0);
return __gmp_c;
}
extern __inline__ __attribute__((__gnu_inline__))
int
__gmpn_cmp (mp_srcptr __gmp_xp, mp_srcptr __gmp_yp, mp_size_t __gmp_size) throw ()
{
int __gmp_result;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_y; (__gmp_result) = 0; __gmp_i = (__gmp_size); while (--__gmp_i >= 0) { __gmp_x = (__gmp_xp)[__gmp_i]; __gmp_y = (__gmp_yp)[__gmp_i]; if (__gmp_x != __gmp_y) { (__gmp_result) = (__gmp_x > __gmp_y ? 1 : -1); break; } } } while (0);
return __gmp_result;
}
extern __inline__ __attribute__((__gnu_inline__))
mp_limb_t
__gmpn_sub (mp_ptr __gmp_wp, mp_srcptr __gmp_xp, mp_size_t __gmp_xsize, mp_srcptr __gmp_yp, mp_size_t __gmp_ysize)
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x; __gmp_i = (__gmp_ysize); if (__gmp_i != 0) { if (__gmpn_sub_n (__gmp_wp, __gmp_xp, __gmp_yp, __gmp_i)) { do { if (__gmp_i >= (__gmp_xsize)) { (__gmp_c) = 1; goto __gmp_done; } __gmp_x = (__gmp_xp)[__gmp_i]; } while ((((__gmp_wp)[__gmp_i++] = (__gmp_x - 1) & ((~ (static_cast<mp_limb_t> (0))) >> 0)), __gmp_x == 0)); } } if ((__gmp_wp) != (__gmp_xp)) do { mp_size_t __gmp_j; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_xsize); __gmp_j++) (__gmp_wp)[__gmp_j] = (__gmp_xp)[__gmp_j]; } while (0); (__gmp_c) = 0; __gmp_done: ; } while (0);
return __gmp_c;
}
extern __inline__ __attribute__((__gnu_inline__))
mp_limb_t
__gmpn_sub_1 (mp_ptr __gmp_dst, mp_srcptr __gmp_src, mp_size_t __gmp_size, mp_limb_t __gmp_n) throw ()
{
mp_limb_t __gmp_c;
do { mp_size_t __gmp_i; mp_limb_t __gmp_x, __gmp_r; __gmp_x = (__gmp_src)[0]; __gmp_r = __gmp_x - (__gmp_n); (__gmp_dst)[0] = __gmp_r; if (((__gmp_x) < ((__gmp_n)))) { (__gmp_c) = 1; for (__gmp_i = 1; __gmp_i < (__gmp_size);) { __gmp_x = (__gmp_src)[__gmp_i]; __gmp_r = __gmp_x - 1; (__gmp_dst)[__gmp_i] = __gmp_r; ++__gmp_i; if (!((__gmp_x) < (1))) { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; for (__gmp_j = (__gmp_i); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; break; } } } else { if ((__gmp_src) != (__gmp_dst)) do { mp_size_t __gmp_j; for (__gmp_j = (1); __gmp_j < (__gmp_size); __gmp_j++) (__gmp_dst)[__gmp_j] = (__gmp_src)[__gmp_j]; } while (0); (__gmp_c) = 0; } } while (0);
return __gmp_c;
}
}
# 2328 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
std::ostream& operator<< (std::ostream &, mpz_srcptr);
std::ostream& operator<< (std::ostream &, mpq_srcptr);
std::ostream& operator<< (std::ostream &, mpf_srcptr);
std::istream& operator>> (std::istream &, mpz_ptr);
std::istream& operator>> (std::istream &, mpq_ptr);
std::istream& operator>> (std::istream &, mpf_ptr);
# 2348 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
typedef __mpz_struct MP_INT;
typedef __mpq_struct MP_RAT;
# 2358 "/opt/vivado2018/Vivado/2018.3/include/gmp.h"
enum
{
GMP_ERROR_NONE = 0,
GMP_ERROR_UNSUPPORTED_ARGUMENT = 1,
GMP_ERROR_DIVISION_BY_ZERO = 2,
GMP_ERROR_SQRT_OF_NEGATIVE = 4,
GMP_ERROR_INVALID_ARGUMENT = 8
};
# 8 "modules/V_read/../../Stream.h" 2
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/hls_stream.h" 1
# 66 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/hls_stream.h"
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/etc/autopilot_enum.h" 1
# 58 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/etc/autopilot_enum.h"
enum SsdmDataTypes {
_ssdm_sc_int = 0,
_ssdm_c_int = _ssdm_sc_int,
_ssdm_sc_uint = 1,
_ssdm_c_uint = _ssdm_sc_uint,
_ssdm_sc_bigint = 2,
_ssdm_sc_biguint = 3,
};
enum SsdmPortTypes {
_ssdm_sc_in = 0,
_ssdm_sc_out = 1,
_ssdm_sc_inout = 2,
_ssdm_sc_in_clk,
_ssdm_fifo_in,
_ssdm_sc_fifo_in = _ssdm_fifo_in,
_ssdm_tlm_fifo_in = _ssdm_fifo_in,
_ssdm_fifo_out,
_ssdm_sc_fifo_out = _ssdm_fifo_out,
_ssdm_tlm_fifo_out = _ssdm_fifo_out,
_ssdm_fifo_inout,
_ssdm_sc_fifo_inout = _ssdm_fifo_inout,
_ssdm_tlm_fifo_inout = _ssdm_fifo_inout,
_ssdm_sc_bus,
_ssdm_hls_bus_port = _ssdm_sc_bus,
_ssdm_AXI4M_bus_port = _ssdm_sc_bus,
_ssdm_port_end,
};
enum SsdmProcessTypes {
_ssdm_method = 0,
_ssdm_sc_method = _ssdm_method,
_ssdm_thread = 1,
_ssdm_sc_thread = _ssdm_thread,
_ssdm_cthread = 2,
_ssdm_sc_cthread = _ssdm_cthread,
_ssdm_process_end,
};
enum SsdmSensitiveTypes {
_ssdm_sensitive = 0,
_ssdm_sensitive_pos,
_ssdm_sensitive_neg,
_ssdm_sensitive_reset0,
_ssdm_sensitive_reset1,
_ssdm_sensitive_end,
};
enum SsdmChannelTypes {
_ssdm_sc_sig,
_ssdm_fifo,
_ssdm_sc_fifo = _ssdm_fifo,
_ssdm_mem_fifo,
_ssdm_sc_mem_fifo = _ssdm_mem_fifo,
};
enum SsdmRegionTypes {
_ssdm_region_reset,
_ssdm_region_protocol,
_ssdm_region_pipeline,
_ssdm_region_parallel,
};
# 67 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/hls_stream.h" 2
namespace hls {
# 78 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/hls_stream.h"
template<typename __STREAM_T__>
class stream
{
public:
inline __attribute__((always_inline)) stream() {
}
inline __attribute__((always_inline)) stream(const char* name) {
}
private:
inline __attribute__((always_inline)) stream(const stream< __STREAM_T__ >& chn):V(chn.V) {
}
inline __attribute__((always_inline)) stream& operator= (const stream< __STREAM_T__ >& chn) {
V = chn.V;
return *this;
}
public:
inline __attribute__((always_inline)) void operator >> (__STREAM_T__& rdata) {
read(rdata);
}
inline __attribute__((always_inline)) void operator << (const __STREAM_T__& wdata) {
write(wdata);
}
public:
inline __attribute__((always_inline)) bool empty() const {
bool tmp = _ssdm_StreamCanRead(&V);
return !tmp;
}
inline __attribute__((always_inline)) bool full() const {
bool tmp = _ssdm_StreamCanWrite(&V);
return !tmp;
}
inline __attribute__((always_inline)) void read(__STREAM_T__& dout) {
__STREAM_T__ tmp;
_ssdm_StreamRead(&V, &tmp);
dout = tmp;
}
inline __attribute__((always_inline)) __STREAM_T__ read() {
__STREAM_T__ tmp;
_ssdm_StreamRead(&V, &tmp);
return tmp;
}
inline __attribute__((always_inline)) bool read_nb(__STREAM_T__& dout) {
__STREAM_T__ tmp;
bool empty_n = _ssdm_StreamNbRead(&V, &tmp);
dout = tmp;
return empty_n;
}
inline __attribute__((always_inline)) void write(const __STREAM_T__& din) {
__STREAM_T__ tmp = din;
_ssdm_StreamWrite(&V, &tmp);
}
inline __attribute__((always_inline)) bool write_nb(const __STREAM_T__& din) {
__STREAM_T__ tmp = din;
bool full_n = _ssdm_StreamNbWrite(&V, &tmp);
return full_n;
}
inline __attribute__((always_inline)) unsigned size() {
unsigned size = _ssdm_StreamSize(&V);
return size;
}
public:
__STREAM_T__ V;
};
}
# 9 "modules/V_read/../../Stream.h" 2
# 1 "/usr/include/stdlib.h" 1 3 4
# 32 "/usr/include/stdlib.h" 3 4
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
# 33 "/usr/include/stdlib.h" 2 3 4
extern "C" {
# 1 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 1 3 4
# 50 "/usr/include/x86_64-linux-gnu/bits/waitflags.h" 3 4
typedef enum
{
P_ALL,
P_PID,
P_PGID
} idtype_t;
# 42 "/usr/include/stdlib.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 1 3 4
# 64 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 3 4
# 1 "/usr/include/endian.h" 1 3 4
# 36 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/endian.h" 1 3 4
# 37 "/usr/include/endian.h" 2 3 4
# 60 "/usr/include/endian.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 29 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/byteswap-16.h" 1 3 4
# 36 "/usr/include/x86_64-linux-gnu/bits/byteswap.h" 2 3 4
# 61 "/usr/include/endian.h" 2 3 4
# 65 "/usr/include/x86_64-linux-gnu/bits/waitstatus.h" 2 3 4
union wait
{
int w_status;
struct
{
unsigned int __w_termsig:7;
unsigned int __w_coredump:1;
unsigned int __w_retcode:8;
unsigned int:16;
} __wait_terminated;
struct
{
unsigned int __w_stopval:8;
unsigned int __w_stopsig:8;
unsigned int:16;
} __wait_stopped;
};
# 43 "/usr/include/stdlib.h" 2 3 4
# 97 "/usr/include/stdlib.h" 3 4
typedef struct
{
int quot;
int rem;
} div_t;
typedef struct
{
long int quot;
long int rem;
} ldiv_t;
__extension__ typedef struct
{
long long int quot;
long long int rem;
} lldiv_t;
# 139 "/usr/include/stdlib.h" 3 4
extern size_t __ctype_get_mb_cur_max (void) throw () ;
extern double atof (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern int atoi (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern long int atol (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
__extension__ extern long long int atoll (const char *__nptr)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
extern double strtod (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern float strtof (const char *__restrict __nptr,
char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1)));
extern long double strtold (const char *__restrict __nptr,
char **__restrict __endptr)
throw () __attribute__ ((__nonnull__ (1)));
extern long int strtol (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
extern unsigned long int strtoul (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtouq (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern long long int strtoll (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
__extension__
extern unsigned long long int strtoull (const char *__restrict __nptr,
char **__restrict __endptr, int __base)
throw () __attribute__ ((__nonnull__ (1)));
# 239 "/usr/include/stdlib.h" 3 4
extern long int strtol_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc) throw () __attribute__ ((__nonnull__ (1, 4)));
extern unsigned long int strtoul_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern long long int strtoll_l (const char *__restrict __nptr,
char **__restrict __endptr, int __base,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
__extension__
extern unsigned long long int strtoull_l (const char *__restrict __nptr,
char **__restrict __endptr,
int __base, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 4)));
extern double strtod_l (const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern float strtof_l (const char *__restrict __nptr,
char **__restrict __endptr, __locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
extern long double strtold_l (const char *__restrict __nptr,
char **__restrict __endptr,
__locale_t __loc)
throw () __attribute__ ((__nonnull__ (1, 3)));
# 305 "/usr/include/stdlib.h" 3 4
extern char *l64a (long int __n) throw () ;
extern long int a64l (const char *__s)
throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ;
# 1 "/usr/include/x86_64-linux-gnu/sys/types.h" 1 3 4
# 27 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
extern "C" {
typedef __u_char u_char;
typedef __u_short u_short;
typedef __u_int u_int;
typedef __u_long u_long;
typedef __quad_t quad_t;
typedef __u_quad_t u_quad_t;
typedef __fsid_t fsid_t;
typedef __loff_t loff_t;
typedef __ino_t ino_t;
typedef __ino64_t ino64_t;
typedef __dev_t dev_t;
typedef __gid_t gid_t;
typedef __mode_t mode_t;
typedef __nlink_t nlink_t;
typedef __uid_t uid_t;
# 98 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __pid_t pid_t;
typedef __id_t id_t;
# 115 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __daddr_t daddr_t;
typedef __caddr_t caddr_t;
typedef __key_t key_t;
# 132 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/time.h" 1 3 4
# 59 "/usr/include/time.h" 3 4
typedef __clock_t clock_t;
# 75 "/usr/include/time.h" 3 4
typedef __time_t time_t;
# 91 "/usr/include/time.h" 3 4
typedef __clockid_t clockid_t;
# 103 "/usr/include/time.h" 3 4
typedef __timer_t timer_t;
# 133 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __useconds_t useconds_t;
typedef __suseconds_t suseconds_t;
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
# 147 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef unsigned long int ulong;
typedef unsigned short int ushort;
typedef unsigned int uint;
# 194 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef int int8_t __attribute__ ((__mode__ (__QI__)));
typedef int int16_t __attribute__ ((__mode__ (__HI__)));
typedef int int32_t __attribute__ ((__mode__ (__SI__)));
typedef int int64_t __attribute__ ((__mode__ (__DI__)));
typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__)));
typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__)));
typedef int register_t __attribute__ ((__mode__ (__word__)));
# 219 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/select.h" 1 3 4
# 30 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/select.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/select.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 23 "/usr/include/x86_64-linux-gnu/bits/select.h" 2 3 4
# 31 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/sigset.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/sigset.h" 3 4
typedef int __sig_atomic_t;
typedef struct
{
unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))];
} __sigset_t;
# 34 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
typedef __sigset_t sigset_t;
# 1 "/usr/include/time.h" 1 3 4
# 120 "/usr/include/time.h" 3 4
struct timespec
{
__time_t tv_sec;
__syscall_slong_t tv_nsec;
};
# 44 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/time.h" 1 3 4
# 30 "/usr/include/x86_64-linux-gnu/bits/time.h" 3 4
struct timeval
{
__time_t tv_sec;
__suseconds_t tv_usec;
};
# 46 "/usr/include/x86_64-linux-gnu/sys/select.h" 2 3 4
typedef long int __fd_mask;
# 64 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
typedef struct
{
__fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))];
} fd_set;
typedef __fd_mask fd_mask;
# 96 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern "C" {
# 106 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int select (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
struct timeval *__restrict __timeout);
# 118 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
extern int pselect (int __nfds, fd_set *__restrict __readfds,
fd_set *__restrict __writefds,
fd_set *__restrict __exceptfds,
const struct timespec *__restrict __timeout,
const __sigset_t *__restrict __sigmask);
# 131 "/usr/include/x86_64-linux-gnu/sys/select.h" 3 4
}
# 220 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 1 3 4
# 24 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 3 4
extern "C" {
__extension__
extern unsigned int gnu_dev_major (unsigned long long int __dev)
throw () __attribute__ ((__const__));
__extension__
extern unsigned int gnu_dev_minor (unsigned long long int __dev)
throw () __attribute__ ((__const__));
__extension__
extern unsigned long long int gnu_dev_makedev (unsigned int __major,
unsigned int __minor)
throw () __attribute__ ((__const__));
# 58 "/usr/include/x86_64-linux-gnu/sys/sysmacros.h" 3 4
}
# 223 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
typedef __blksize_t blksize_t;
typedef __blkcnt_t blkcnt_t;
typedef __fsblkcnt_t fsblkcnt_t;
typedef __fsfilcnt_t fsfilcnt_t;
# 262 "/usr/include/x86_64-linux-gnu/sys/types.h" 3 4
typedef __blkcnt64_t blkcnt64_t;
typedef __fsblkcnt64_t fsblkcnt64_t;
typedef __fsfilcnt64_t fsfilcnt64_t;
# 1 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 1 3 4
# 21 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 22 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 2 3 4
# 60 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
typedef unsigned long int pthread_t;
union pthread_attr_t
{
char __size[56];
long int __align;
};
typedef union pthread_attr_t pthread_attr_t;
typedef struct __pthread_internal_list
{
struct __pthread_internal_list *__prev;
struct __pthread_internal_list *__next;
} __pthread_list_t;
# 90 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
typedef union
{
struct __pthread_mutex_s
{
int __lock;
unsigned int __count;
int __owner;
unsigned int __nusers;
int __kind;
short __spins;
short __elision;
__pthread_list_t __list;
# 125 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
} __data;
char __size[40];
long int __align;
} pthread_mutex_t;
typedef union
{
char __size[4];
int __align;
} pthread_mutexattr_t;
typedef union
{
struct
{
int __lock;
unsigned int __futex;
__extension__ unsigned long long int __total_seq;
__extension__ unsigned long long int __wakeup_seq;
__extension__ unsigned long long int __woken_seq;
void *__mutex;
unsigned int __nwaiters;
unsigned int __broadcast_seq;
} __data;
char __size[48];
__extension__ long long int __align;
} pthread_cond_t;
typedef union
{
char __size[4];
int __align;
} pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef int pthread_once_t;
typedef union
{
struct
{
int __lock;
unsigned int __nr_readers;
unsigned int __readers_wakeup;
unsigned int __writer_wakeup;
unsigned int __nr_readers_queued;
unsigned int __nr_writers_queued;
int __writer;
int __shared;
signed char __rwelision;
unsigned char __pad1[7];
unsigned long int __pad2;
unsigned int __flags;
} __data;
# 220 "/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h" 3 4
char __size[56];
long int __align;
} pthread_rwlock_t;
typedef union
{
char __size[8];
long int __align;
} pthread_rwlockattr_t;
typedef volatile int pthread_spinlock_t;
typedef union
{
char __size[32];
long int __align;
} pthread_barrier_t;
typedef union
{
char __size[4];
int __align;
} pthread_barrierattr_t;
# 271 "/usr/include/x86_64-linux-gnu/sys/types.h" 2 3 4
}
# 315 "/usr/include/stdlib.h" 2 3 4
extern long int random (void) throw ();
extern void srandom (unsigned int __seed) throw ();
extern char *initstate (unsigned int __seed, char *__statebuf,
size_t __statelen) throw () __attribute__ ((__nonnull__ (2)));
extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1)));
struct random_data
{
int32_t *fptr;
int32_t *rptr;
int32_t *state;
int rand_type;
int rand_deg;
int rand_sep;
int32_t *end_ptr;
};
extern int random_r (struct random_data *__restrict __buf,
int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srandom_r (unsigned int __seed, struct random_data *__buf)
throw () __attribute__ ((__nonnull__ (2)));
extern int initstate_r (unsigned int __seed, char *__restrict __statebuf,
size_t __statelen,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (2, 4)));
extern int setstate_r (char *__restrict __statebuf,
struct random_data *__restrict __buf)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int rand (void) throw ();
extern void srand (unsigned int __seed) throw ();
extern int rand_r (unsigned int *__seed) throw ();
extern double drand48 (void) throw ();
extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1)));
extern long int lrand48 (void) throw ();
extern long int nrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern long int mrand48 (void) throw ();
extern long int jrand48 (unsigned short int __xsubi[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void srand48 (long int __seedval) throw ();
extern unsigned short int *seed48 (unsigned short int __seed16v[3])
throw () __attribute__ ((__nonnull__ (1)));
extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1)));
struct drand48_data
{
unsigned short int __x[3];
unsigned short int __old_x[3];
unsigned short int __c;
unsigned short int __init;
__extension__ unsigned long long int __a;
};
extern int drand48_r (struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int nrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int mrand48_r (struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int jrand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
long int *__restrict __result)
throw () __attribute__ ((__nonnull__ (1, 2)));
extern int srand48_r (long int __seedval, struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (2)));
extern int seed48_r (unsigned short int __seed16v[3],
struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2)));
extern int lcong48_r (unsigned short int __param[7],
struct drand48_data *__buffer)
throw () __attribute__ ((__nonnull__ (1, 2)));
# 466 "/usr/include/stdlib.h" 3 4
extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
extern void *calloc (size_t __nmemb, size_t __size)
throw () __attribute__ ((__malloc__)) ;
# 480 "/usr/include/stdlib.h" 3 4
extern void *realloc (void *__ptr, size_t __size)
throw () __attribute__ ((__warn_unused_result__));
extern void free (void *__ptr) throw ();
extern void cfree (void *__ptr) throw ();
# 1 "/usr/include/alloca.h" 1 3 4
# 24 "/usr/include/alloca.h" 3 4
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3 4
# 25 "/usr/include/alloca.h" 2 3 4
extern "C" {
extern void *alloca (size_t __size) throw ();
}
# 493 "/usr/include/stdlib.h" 2 3 4
extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ;
extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size)
throw () __attribute__ ((__nonnull__ (1))) ;
extern void *aligned_alloc (size_t __alignment, size_t __size)
throw () __attribute__ ((__malloc__)) ;
extern void abort (void) throw () __attribute__ ((__noreturn__));
extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1)));
extern "C++" int at_quick_exit (void (*__func) (void))
throw () __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1)));
# 535 "/usr/include/stdlib.h" 3 4
extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg)
throw () __attribute__ ((__nonnull__ (1)));
extern void exit (int __status) throw () __attribute__ ((__noreturn__));
extern void quick_exit (int __status) throw () __attribute__ ((__noreturn__));
extern void _Exit (int __status) throw () __attribute__ ((__noreturn__));
extern char *getenv (const char *__name) throw () __attribute__ ((__nonnull__ (1))) ;
extern char *secure_getenv (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1)));
extern int setenv (const char *__name, const char *__value, int __replace)
throw () __attribute__ ((__nonnull__ (2)));
extern int unsetenv (const char *__name) throw () __attribute__ ((__nonnull__ (1)));
extern int clearenv (void) throw ();
# 606 "/usr/include/stdlib.h" 3 4
extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1)));
# 619 "/usr/include/stdlib.h" 3 4
extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 629 "/usr/include/stdlib.h" 3 4
extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ;
# 641 "/usr/include/stdlib.h" 3 4
extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ;
# 651 "/usr/include/stdlib.h" 3 4
extern int mkstemps64 (char *__template, int __suffixlen)
__attribute__ ((__nonnull__ (1))) ;
# 662 "/usr/include/stdlib.h" 3 4
extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ;
# 673 "/usr/include/stdlib.h" 3 4
extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 683 "/usr/include/stdlib.h" 3 4
extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ;
# 693 "/usr/include/stdlib.h" 3 4
extern int mkostemps (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
# 705 "/usr/include/stdlib.h" 3 4
extern int mkostemps64 (char *__template, int __suffixlen, int __flags)
__attribute__ ((__nonnull__ (1))) ;
# 716 "/usr/include/stdlib.h" 3 4
extern int system (const char *__command) ;
extern char *canonicalize_file_name (const char *__name)
throw () __attribute__ ((__nonnull__ (1))) ;
# 733 "/usr/include/stdlib.h" 3 4
extern char *realpath (const char *__restrict __name,
char *__restrict __resolved) throw () ;
typedef int (*__compar_fn_t) (const void *, const void *);
typedef __compar_fn_t comparison_fn_t;
typedef int (*__compar_d_fn_t) (const void *, const void *, void *);
extern void *bsearch (const void *__key, const void *__base,
size_t __nmemb, size_t __size, __compar_fn_t __compar)
__attribute__ ((__nonnull__ (1, 2, 5))) ;
extern void qsort (void *__base, size_t __nmemb, size_t __size,
__compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4)));
extern void qsort_r (void *__base, size_t __nmemb, size_t __size,
__compar_d_fn_t __compar, void *__arg)
__attribute__ ((__nonnull__ (1, 4)));
extern int abs (int __x) throw () __attribute__ ((__const__)) ;
extern long int labs (long int __x) throw () __attribute__ ((__const__)) ;
__extension__ extern long long int llabs (long long int __x)
throw () __attribute__ ((__const__)) ;
extern div_t div (int __numer, int __denom)
throw () __attribute__ ((__const__)) ;
extern ldiv_t ldiv (long int __numer, long int __denom)
throw () __attribute__ ((__const__)) ;
__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
throw () __attribute__ ((__const__)) ;
# 811 "/usr/include/stdlib.h" 3 4
extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign) throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *gcvt (double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern char *qecvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qfcvt (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign)
throw () __attribute__ ((__nonnull__ (3, 4))) ;
extern char *qgcvt (long double __value, int __ndigit, char *__buf)
throw () __attribute__ ((__nonnull__ (3))) ;
extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt,
int *__restrict __sign, char *__restrict __buf,
size_t __len) throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qecvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int qfcvt_r (long double __value, int __ndigit,
int *__restrict __decpt, int *__restrict __sign,
char *__restrict __buf, size_t __len)
throw () __attribute__ ((__nonnull__ (3, 4, 5)));
extern int mblen (const char *__s, size_t __n) throw ();
extern int mbtowc (wchar_t *__restrict __pwc,
const char *__restrict __s, size_t __n) throw ();
extern int wctomb (char *__s, wchar_t __wchar) throw ();
extern size_t mbstowcs (wchar_t *__restrict __pwcs,
const char *__restrict __s, size_t __n) throw ();
extern size_t wcstombs (char *__restrict __s,
const wchar_t *__restrict __pwcs, size_t __n)
throw ();
# 887 "/usr/include/stdlib.h" 3 4
extern int rpmatch (const char *__response) throw () __attribute__ ((__nonnull__ (1))) ;
# 898 "/usr/include/stdlib.h" 3 4
extern int getsubopt (char **__restrict __optionp,
char *const *__restrict __tokens,
char **__restrict __valuep)
throw () __attribute__ ((__nonnull__ (1, 2, 3))) ;
extern void setkey (const char *__key) throw () __attribute__ ((__nonnull__ (1)));
extern int posix_openpt (int __oflag) ;
extern int grantpt (int __fd) throw ();
extern int unlockpt (int __fd) throw ();
extern char *ptsname (int __fd) throw () ;
extern int ptsname_r (int __fd, char *__buf, size_t __buflen)
throw () __attribute__ ((__nonnull__ (2)));
extern int getpt (void);
extern int getloadavg (double __loadavg[], int __nelem)
throw () __attribute__ ((__nonnull__ (1)));
# 1 "/usr/include/x86_64-linux-gnu/bits/stdlib-float.h" 1 3 4
# 955 "/usr/include/stdlib.h" 2 3 4
# 967 "/usr/include/stdlib.h" 3 4
}
# 11 "modules/V_read/../../Stream.h" 2
# 1 "/usr/include/math.h" 1 3 4
# 28 "/usr/include/math.h" 3 4
extern "C" {
# 1 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 1 3 4
# 25 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h" 1 3 4
# 26 "/usr/include/x86_64-linux-gnu/bits/math-vector.h" 2 3 4
# 32 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/huge_val.h" 1 3 4
# 36 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/huge_valf.h" 1 3 4
# 38 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/huge_vall.h" 1 3 4
# 39 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/inf.h" 1 3 4
# 42 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/nan.h" 1 3 4
# 45 "/usr/include/math.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathdef.h" 1 3 4
# 28 "/usr/include/x86_64-linux-gnu/bits/mathdef.h" 3 4
typedef float float_t;
typedef double double_t;
# 49 "/usr/include/math.h" 2 3 4
# 83 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 54 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern double acos (double __x) throw (); extern double __acos (double __x) throw ();
extern double asin (double __x) throw (); extern double __asin (double __x) throw ();
extern double atan (double __x) throw (); extern double __atan (double __x) throw ();
extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw ();
extern double cos (double __x) throw (); extern double __cos (double __x) throw ();
extern double sin (double __x) throw (); extern double __sin (double __x) throw ();
extern double tan (double __x) throw (); extern double __tan (double __x) throw ();
extern double cosh (double __x) throw (); extern double __cosh (double __x) throw ();
extern double sinh (double __x) throw (); extern double __sinh (double __x) throw ();
extern double tanh (double __x) throw (); extern double __tanh (double __x) throw ();
extern void sincos (double __x, double *__sinx, double *__cosx) throw (); extern void __sincos (double __x, double *__sinx, double *__cosx) throw ();
extern double acosh (double __x) throw (); extern double __acosh (double __x) throw ();
extern double asinh (double __x) throw (); extern double __asinh (double __x) throw ();
extern double atanh (double __x) throw (); extern double __atanh (double __x) throw ();
extern double exp (double __x) throw (); extern double __exp (double __x) throw ();
extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw ();
extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw ();
extern double log (double __x) throw (); extern double __log (double __x) throw ();
extern double log10 (double __x) throw (); extern double __log10 (double __x) throw ();
extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern double exp10 (double __x) throw (); extern double __exp10 (double __x) throw ();
extern double pow10 (double __x) throw (); extern double __pow10 (double __x) throw ();
extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw ();
extern double log1p (double __x) throw (); extern double __log1p (double __x) throw ();
extern double logb (double __x) throw (); extern double __logb (double __x) throw ();
extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw ();
extern double log2 (double __x) throw (); extern double __log2 (double __x) throw ();
# 153 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw ();
extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw ();
extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw ();
extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw ();
# 178 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__));
extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__));
extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__));
extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw ();
extern int __isinf (double __value) throw () __attribute__ ((__const__));
extern int __finite (double __value) throw () __attribute__ ((__const__));
# 204 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int isinf (double __value) throw () __attribute__ ((__const__));
extern int finite (double __value) throw () __attribute__ ((__const__));
extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw ();
extern double significand (double __x) throw (); extern double __significand (double __x) throw ();
extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__));
extern double nan (const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnan (double __value) throw () __attribute__ ((__const__));
extern int isnan (double __value) throw () __attribute__ ((__const__));
extern double j0 (double) throw (); extern double __j0 (double) throw ();
extern double j1 (double) throw (); extern double __j1 (double) throw ();
extern double jn (int, double) throw (); extern double __jn (int, double) throw ();
extern double y0 (double) throw (); extern double __y0 (double) throw ();
extern double y1 (double) throw (); extern double __y1 (double) throw ();
extern double yn (int, double) throw (); extern double __yn (int, double) throw ();
extern double erf (double) throw (); extern double __erf (double) throw ();
extern double erfc (double) throw (); extern double __erfc (double) throw ();
extern double lgamma (double) throw (); extern double __lgamma (double) throw ();
extern double tgamma (double) throw (); extern double __tgamma (double) throw ();
extern double gamma (double) throw (); extern double __gamma (double) throw ();
extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw ();
extern double rint (double __x) throw (); extern double __rint (double __x) throw ();
extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__));
extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__));
extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw ();
extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw ();
extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw ();
extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw ();
extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw ();
extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__));
extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__));
extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw ();
extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw ();
__extension__
extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw ();
extern long int lround (double __x) throw (); extern long int __lround (double __x) throw ();
__extension__
extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw ();
extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw ();
extern double fmax (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmax (double __x, double __y) throw () __attribute__ ((__const__));
extern double fmin (double __x, double __y) throw () __attribute__ ((__const__)); extern double __fmin (double __x, double __y) throw () __attribute__ ((__const__));
extern int __fpclassify (double __value) throw ()
__attribute__ ((__const__));
extern int __signbit (double __value) throw ()
__attribute__ ((__const__));
extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw ();
# 375 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int __issignaling (double __value) throw ()
__attribute__ ((__const__));
extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw ();
# 84 "/usr/include/math.h" 2 3 4
# 104 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 54 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern float acosf (float __x) throw (); extern float __acosf (float __x) throw ();
extern float asinf (float __x) throw (); extern float __asinf (float __x) throw ();
extern float atanf (float __x) throw (); extern float __atanf (float __x) throw ();
extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw ();
extern float cosf (float __x) throw (); extern float __cosf (float __x) throw ();
extern float sinf (float __x) throw (); extern float __sinf (float __x) throw ();
extern float tanf (float __x) throw (); extern float __tanf (float __x) throw ();
extern float coshf (float __x) throw (); extern float __coshf (float __x) throw ();
extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw ();
extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw ();
extern void sincosf (float __x, float *__sinx, float *__cosx) throw (); extern void __sincosf (float __x, float *__sinx, float *__cosx) throw ();
extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw ();
extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw ();
extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw ();
extern float expf (float __x) throw (); extern float __expf (float __x) throw ();
extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw ();
extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw ();
extern float logf (float __x) throw (); extern float __logf (float __x) throw ();
extern float log10f (float __x) throw (); extern float __log10f (float __x) throw ();
extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern float exp10f (float __x) throw (); extern float __exp10f (float __x) throw ();
extern float pow10f (float __x) throw (); extern float __pow10f (float __x) throw ();
extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw ();
extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw ();
extern float logbf (float __x) throw (); extern float __logbf (float __x) throw ();
extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw ();
extern float log2f (float __x) throw (); extern float __log2f (float __x) throw ();
# 153 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw ();
extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw ();
extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw ();
extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw ();
# 178 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__));
extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__));
extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__));
extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw ();
extern int __isinff (float __value) throw () __attribute__ ((__const__));
extern int __finitef (float __value) throw () __attribute__ ((__const__));
# 204 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int isinff (float __value) throw () __attribute__ ((__const__));
extern int finitef (float __value) throw () __attribute__ ((__const__));
extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw ();
extern float significandf (float __x) throw (); extern float __significandf (float __x) throw ();
extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__));
extern float nanf (const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnanf (float __value) throw () __attribute__ ((__const__));
extern int isnanf (float __value) throw () __attribute__ ((__const__));
extern float j0f (float) throw (); extern float __j0f (float) throw ();
extern float j1f (float) throw (); extern float __j1f (float) throw ();
extern float jnf (int, float) throw (); extern float __jnf (int, float) throw ();
extern float y0f (float) throw (); extern float __y0f (float) throw ();
extern float y1f (float) throw (); extern float __y1f (float) throw ();
extern float ynf (int, float) throw (); extern float __ynf (int, float) throw ();
extern float erff (float) throw (); extern float __erff (float) throw ();
extern float erfcf (float) throw (); extern float __erfcf (float) throw ();
extern float lgammaf (float) throw (); extern float __lgammaf (float) throw ();
extern float tgammaf (float) throw (); extern float __tgammaf (float) throw ();
extern float gammaf (float) throw (); extern float __gammaf (float) throw ();
extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw ();
extern float rintf (float __x) throw (); extern float __rintf (float __x) throw ();
extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__));
extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__));
extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw ();
extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw ();
extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw ();
extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw ();
extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw ();
extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__));
extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__));
extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw ();
extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw ();
__extension__
extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw ();
extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw ();
__extension__
extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw ();
extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw ();
extern float fmaxf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) throw () __attribute__ ((__const__));
extern float fminf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __fminf (float __x, float __y) throw () __attribute__ ((__const__));
extern int __fpclassifyf (float __value) throw ()
__attribute__ ((__const__));
extern int __signbitf (float __value) throw ()
__attribute__ ((__const__));
extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw ();
# 375 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int __issignalingf (float __value) throw ()
__attribute__ ((__const__));
extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw ();
# 105 "/usr/include/math.h" 2 3 4
# 151 "/usr/include/math.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 1 3 4
# 54 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern long double acosl (long double __x) throw (); extern long double __acosl (long double __x) throw ();
extern long double asinl (long double __x) throw (); extern long double __asinl (long double __x) throw ();
extern long double atanl (long double __x) throw (); extern long double __atanl (long double __x) throw ();
extern long double atan2l (long double __y, long double __x) throw (); extern long double __atan2l (long double __y, long double __x) throw ();
extern long double cosl (long double __x) throw (); extern long double __cosl (long double __x) throw ();
extern long double sinl (long double __x) throw (); extern long double __sinl (long double __x) throw ();
extern long double tanl (long double __x) throw (); extern long double __tanl (long double __x) throw ();
extern long double coshl (long double __x) throw (); extern long double __coshl (long double __x) throw ();
extern long double sinhl (long double __x) throw (); extern long double __sinhl (long double __x) throw ();
extern long double tanhl (long double __x) throw (); extern long double __tanhl (long double __x) throw ();
extern void sincosl (long double __x, long double *__sinx, long double *__cosx) throw (); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) throw ();
extern long double acoshl (long double __x) throw (); extern long double __acoshl (long double __x) throw ();
extern long double asinhl (long double __x) throw (); extern long double __asinhl (long double __x) throw ();
extern long double atanhl (long double __x) throw (); extern long double __atanhl (long double __x) throw ();
extern long double expl (long double __x) throw (); extern long double __expl (long double __x) throw ();
extern long double frexpl (long double __x, int *__exponent) throw (); extern long double __frexpl (long double __x, int *__exponent) throw ();
extern long double ldexpl (long double __x, int __exponent) throw (); extern long double __ldexpl (long double __x, int __exponent) throw ();
extern long double logl (long double __x) throw (); extern long double __logl (long double __x) throw ();
extern long double log10l (long double __x) throw (); extern long double __log10l (long double __x) throw ();
extern long double modfl (long double __x, long double *__iptr) throw (); extern long double __modfl (long double __x, long double *__iptr) throw () __attribute__ ((__nonnull__ (2)));
extern long double exp10l (long double __x) throw (); extern long double __exp10l (long double __x) throw ();
extern long double pow10l (long double __x) throw (); extern long double __pow10l (long double __x) throw ();
extern long double expm1l (long double __x) throw (); extern long double __expm1l (long double __x) throw ();
extern long double log1pl (long double __x) throw (); extern long double __log1pl (long double __x) throw ();
extern long double logbl (long double __x) throw (); extern long double __logbl (long double __x) throw ();
extern long double exp2l (long double __x) throw (); extern long double __exp2l (long double __x) throw ();
extern long double log2l (long double __x) throw (); extern long double __log2l (long double __x) throw ();
# 153 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern long double powl (long double __x, long double __y) throw (); extern long double __powl (long double __x, long double __y) throw ();
extern long double sqrtl (long double __x) throw (); extern long double __sqrtl (long double __x) throw ();
extern long double hypotl (long double __x, long double __y) throw (); extern long double __hypotl (long double __x, long double __y) throw ();
extern long double cbrtl (long double __x) throw (); extern long double __cbrtl (long double __x) throw ();
# 178 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern long double ceill (long double __x) throw () __attribute__ ((__const__)); extern long double __ceill (long double __x) throw () __attribute__ ((__const__));
extern long double fabsl (long double __x) throw () __attribute__ ((__const__)); extern long double __fabsl (long double __x) throw () __attribute__ ((__const__));
extern long double floorl (long double __x) throw () __attribute__ ((__const__)); extern long double __floorl (long double __x) throw () __attribute__ ((__const__));
extern long double fmodl (long double __x, long double __y) throw (); extern long double __fmodl (long double __x, long double __y) throw ();
extern int __isinfl (long double __value) throw () __attribute__ ((__const__));
extern int __finitel (long double __value) throw () __attribute__ ((__const__));
# 204 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int isinfl (long double __value) throw () __attribute__ ((__const__));
extern int finitel (long double __value) throw () __attribute__ ((__const__));
extern long double dreml (long double __x, long double __y) throw (); extern long double __dreml (long double __x, long double __y) throw ();
extern long double significandl (long double __x) throw (); extern long double __significandl (long double __x) throw ();
extern long double copysignl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double nanl (const char *__tagb) throw () __attribute__ ((__const__)); extern long double __nanl (const char *__tagb) throw () __attribute__ ((__const__));
extern int __isnanl (long double __value) throw () __attribute__ ((__const__));
extern int isnanl (long double __value) throw () __attribute__ ((__const__));
extern long double j0l (long double) throw (); extern long double __j0l (long double) throw ();
extern long double j1l (long double) throw (); extern long double __j1l (long double) throw ();
extern long double jnl (int, long double) throw (); extern long double __jnl (int, long double) throw ();
extern long double y0l (long double) throw (); extern long double __y0l (long double) throw ();
extern long double y1l (long double) throw (); extern long double __y1l (long double) throw ();
extern long double ynl (int, long double) throw (); extern long double __ynl (int, long double) throw ();
extern long double erfl (long double) throw (); extern long double __erfl (long double) throw ();
extern long double erfcl (long double) throw (); extern long double __erfcl (long double) throw ();
extern long double lgammal (long double) throw (); extern long double __lgammal (long double) throw ();
extern long double tgammal (long double) throw (); extern long double __tgammal (long double) throw ();
extern long double gammal (long double) throw (); extern long double __gammal (long double) throw ();
extern long double lgammal_r (long double, int *__signgamp) throw (); extern long double __lgammal_r (long double, int *__signgamp) throw ();
extern long double rintl (long double __x) throw (); extern long double __rintl (long double __x) throw ();
extern long double nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nextafterl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __nexttowardl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double remainderl (long double __x, long double __y) throw (); extern long double __remainderl (long double __x, long double __y) throw ();
extern long double scalbnl (long double __x, int __n) throw (); extern long double __scalbnl (long double __x, int __n) throw ();
extern int ilogbl (long double __x) throw (); extern int __ilogbl (long double __x) throw ();
extern long double scalblnl (long double __x, long int __n) throw (); extern long double __scalblnl (long double __x, long int __n) throw ();
extern long double nearbyintl (long double __x) throw (); extern long double __nearbyintl (long double __x) throw ();
extern long double roundl (long double __x) throw () __attribute__ ((__const__)); extern long double __roundl (long double __x) throw () __attribute__ ((__const__));
extern long double truncl (long double __x) throw () __attribute__ ((__const__)); extern long double __truncl (long double __x) throw () __attribute__ ((__const__));
extern long double remquol (long double __x, long double __y, int *__quo) throw (); extern long double __remquol (long double __x, long double __y, int *__quo) throw ();
extern long int lrintl (long double __x) throw (); extern long int __lrintl (long double __x) throw ();
__extension__
extern long long int llrintl (long double __x) throw (); extern long long int __llrintl (long double __x) throw ();
extern long int lroundl (long double __x) throw (); extern long int __lroundl (long double __x) throw ();
__extension__
extern long long int llroundl (long double __x) throw (); extern long long int __llroundl (long double __x) throw ();
extern long double fdiml (long double __x, long double __y) throw (); extern long double __fdiml (long double __x, long double __y) throw ();
extern long double fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern long double fminl (long double __x, long double __y) throw () __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) throw () __attribute__ ((__const__));
extern int __fpclassifyl (long double __value) throw ()
__attribute__ ((__const__));
extern int __signbitl (long double __value) throw ()
__attribute__ ((__const__));
extern long double fmal (long double __x, long double __y, long double __z) throw (); extern long double __fmal (long double __x, long double __y, long double __z) throw ();
# 375 "/usr/include/x86_64-linux-gnu/bits/mathcalls.h" 3 4
extern int __issignalingl (long double __value) throw ()
__attribute__ ((__const__));
extern long double scalbl (long double __x, long double __n) throw (); extern long double __scalbl (long double __x, long double __n) throw ();
# 152 "/usr/include/math.h" 2 3 4
# 168 "/usr/include/math.h" 3 4
extern int signgam;
# 209 "/usr/include/math.h" 3 4
enum
{
FP_NAN =
0,
FP_INFINITE =
1,
FP_ZERO =
2,
FP_SUBNORMAL =
3,
FP_NORMAL =
4
};
# 347 "/usr/include/math.h" 3 4
typedef enum
{
_IEEE_ = -1,
_SVID_,
_XOPEN_,
_POSIX_,
_ISOC_
} _LIB_VERSION_TYPE;
extern _LIB_VERSION_TYPE _LIB_VERSION;
# 370 "/usr/include/math.h" 3 4
struct __exception
{
int type;
char *name;
double arg1;
double arg2;
double retval;
};
extern int matherr (struct __exception *__exc) throw ();
# 534 "/usr/include/math.h" 3 4
}
# 12 "modules/V_read/../../Stream.h" 2
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdint.h" 1 3
# 33 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdint.h" 3
# 1 "/usr/include/stdint.h" 1 3 4
# 27 "/usr/include/stdint.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 28 "/usr/include/stdint.h" 2 3 4
# 48 "/usr/include/stdint.h" 3 4
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long int uint64_t;
# 65 "/usr/include/stdint.h" 3 4
typedef signed char int_least8_t;
typedef short int int_least16_t;
typedef int int_least32_t;
typedef long int int_least64_t;
typedef unsigned char uint_least8_t;
typedef unsigned short int uint_least16_t;
typedef unsigned int uint_least32_t;
typedef unsigned long int uint_least64_t;
# 90 "/usr/include/stdint.h" 3 4
typedef signed char int_fast8_t;
typedef long int int_fast16_t;
typedef long int int_fast32_t;
typedef long int int_fast64_t;
# 103 "/usr/include/stdint.h" 3 4
typedef unsigned char uint_fast8_t;
typedef unsigned long int uint_fast16_t;
typedef unsigned long int uint_fast32_t;
typedef unsigned long int uint_fast64_t;
# 119 "/usr/include/stdint.h" 3 4
typedef long int intptr_t;
typedef unsigned long int uintptr_t;
# 134 "/usr/include/stdint.h" 3 4
typedef long int intmax_t;
typedef unsigned long int uintmax_t;
# 34 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stdint.h" 2 3
# 13 "modules/V_read/../../Stream.h" 2
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int.h" 1
# 54 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int.h"
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h" 1
# 56 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h"
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_decl.h" 1
# 100 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_decl.h"
enum ap_q_mode {
AP_RND,
AP_RND_ZERO,
AP_RND_MIN_INF,
AP_RND_INF,
AP_RND_CONV,
AP_TRN,
AP_TRN_ZERO,
};
# 122 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_decl.h"
enum ap_o_mode {
AP_SAT,
AP_SAT_ZERO,
AP_SAT_SYM,
AP_WRAP,
AP_WRAP_SM,
};
# 179 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_decl.h"
template <int _AP_W, bool _AP_S>
struct ap_int_base;
template <int _AP_W>
struct ap_int;
template <int _AP_W>
struct ap_uint;
template <int _AP_W, bool _AP_S>
struct ap_range_ref;
template <int _AP_W, bool _AP_S>
struct ap_bit_ref;
template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2>
struct ap_concat_ref;
template <int _AP_W, int _AP_I, bool _AP_S = true, ap_q_mode _AP_Q = AP_TRN,
ap_o_mode _AP_O = AP_WRAP, int _AP_N = 0>
struct ap_fixed_base;
template <int _AP_W, int _AP_I, ap_q_mode _AP_Q = AP_TRN,
ap_o_mode _AP_O = AP_WRAP, int _AP_N = 0>
struct ap_fixed;
template <int _AP_W, int _AP_I, ap_q_mode _AP_Q = AP_TRN,
ap_o_mode _AP_O = AP_WRAP, int _AP_N = 0>
struct ap_ufixed;
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
struct af_range_ref;
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
struct af_bit_ref;
enum BaseMode { AP_BIN = 2, AP_OCT = 8, AP_DEC = 10, AP_HEX = 16 };
# 232 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_decl.h"
typedef signed long long ap_slong;
typedef unsigned long long ap_ulong;
enum {
_AP_SIZE_char = 8,
_AP_SIZE_short = sizeof(short) * 8,
_AP_SIZE_int = sizeof(int) * 8,
_AP_SIZE_long = sizeof(long) * 8,
_AP_SIZE_ap_slong = sizeof(ap_slong) * 8
};
# 57 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h" 2
# 156 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h"
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/climits" 1 3
# 41 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/climits" 3
# 41 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/climits" 3
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/limits.h" 1 3
# 38 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/limits.h" 3
# 1 "/usr/include/limits.h" 1 3 4
# 143 "/usr/include/limits.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 1 3 4
# 160 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 1 3 4
# 38 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 39 "/usr/include/x86_64-linux-gnu/bits/local_lim.h" 2 3 4
# 161 "/usr/include/x86_64-linux-gnu/bits/posix1_lim.h" 2 3 4
# 144 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/posix2_lim.h" 1 3 4
# 148 "/usr/include/limits.h" 2 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 1 3 4
# 33 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/stdio_lim.h" 1 3 4
# 34 "/usr/include/x86_64-linux-gnu/bits/xopen_lim.h" 2 3 4
# 152 "/usr/include/limits.h" 2 3 4
# 39 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/limits.h" 2 3
# 43 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/climits" 2 3
# 157 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h" 2
enum { CHAR_IS_SIGNED = (-127 -1) < 0 };
namespace _ap_type {
template <typename _Tp>
struct is_signed {
static const bool value = _Tp(-1) < _Tp(1);
};
template <typename _Tp>
struct is_integral {
static const bool value = false;
};
template <> struct is_integral<bool> { static const bool value = true; };
template <> struct is_integral<char> { static const bool value = true; };
template <> struct is_integral<signed char> { static const bool value = true; };
template <> struct is_integral<unsigned char> { static const bool value = true; };
template <> struct is_integral<short> { static const bool value = true; };
template <> struct is_integral<unsigned short> { static const bool value = true; };
template <> struct is_integral<int> { static const bool value = true; };
template <> struct is_integral<unsigned int> { static const bool value = true; };
template <> struct is_integral<long> { static const bool value = true; };
template <> struct is_integral<unsigned long> { static const bool value = true; };
template <> struct is_integral<ap_slong> { static const bool value = true; };
template <> struct is_integral<ap_ulong> { static const bool value = true; };
template <bool, typename _Tp = void>
struct enable_if {};
template <typename _Tp>
struct enable_if<true, _Tp> {
typedef _Tp type;
};
template <typename _Tp>
struct remove_const {
typedef _Tp type;
};
template <typename _Tp>
struct remove_const<_Tp const> {
typedef _Tp type;
};
}
# 220 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h"
template <int _AP_N, bool _AP_S>
struct ssdm_int;
# 238 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h"
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/etc/autopilot_dt.def" 1
template <> struct ssdm_int<1 + 1024 * 0, true> { int V __attribute__((bitwidth(1 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<2 + 1024 * 0, true> { int V __attribute__((bitwidth(2 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<2 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<2 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(2 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<2 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<3 + 1024 * 0, true> { int V __attribute__((bitwidth(3 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<3 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<3 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(3 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<3 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<4 + 1024 * 0, true> { int V __attribute__((bitwidth(4 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<4 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<4 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(4 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<4 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<5 + 1024 * 0, true> { int V __attribute__((bitwidth(5 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<5 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<5 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(5 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<5 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<6 + 1024 * 0, true> { int V __attribute__((bitwidth(6 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<6 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<6 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(6 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<6 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<7 + 1024 * 0, true> { int V __attribute__((bitwidth(7 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<7 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<7 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(7 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<7 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<8 + 1024 * 0, true> { int V __attribute__((bitwidth(8 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<8 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<8 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(8 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<8 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<9 + 1024 * 0, true> { int V __attribute__((bitwidth(9 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<9 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<9 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(9 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<9 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<10 + 1024 * 0, true> { int V __attribute__((bitwidth(10 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<10 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<10 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(10 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<10 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<11 + 1024 * 0, true> { int V __attribute__((bitwidth(11 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<11 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<11 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(11 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<11 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<12 + 1024 * 0, true> { int V __attribute__((bitwidth(12 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<12 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<12 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(12 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<12 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<13 + 1024 * 0, true> { int V __attribute__((bitwidth(13 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<13 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<13 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(13 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<13 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<14 + 1024 * 0, true> { int V __attribute__((bitwidth(14 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<14 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<14 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(14 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<14 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<15 + 1024 * 0, true> { int V __attribute__((bitwidth(15 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<15 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<15 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(15 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<15 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<16 + 1024 * 0, true> { int V __attribute__((bitwidth(16 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<16 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<16 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(16 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<16 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<17 + 1024 * 0, true> { int V __attribute__((bitwidth(17 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<17 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<17 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(17 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<17 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<18 + 1024 * 0, true> { int V __attribute__((bitwidth(18 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<18 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<18 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(18 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<18 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<19 + 1024 * 0, true> { int V __attribute__((bitwidth(19 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<19 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<19 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(19 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<19 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<20 + 1024 * 0, true> { int V __attribute__((bitwidth(20 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<20 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<20 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(20 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<20 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<21 + 1024 * 0, true> { int V __attribute__((bitwidth(21 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<21 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<21 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(21 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<21 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<22 + 1024 * 0, true> { int V __attribute__((bitwidth(22 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<22 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<22 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(22 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<22 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<23 + 1024 * 0, true> { int V __attribute__((bitwidth(23 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<23 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<23 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(23 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<23 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<24 + 1024 * 0, true> { int V __attribute__((bitwidth(24 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<24 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<24 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(24 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<24 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<25 + 1024 * 0, true> { int V __attribute__((bitwidth(25 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<25 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<25 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(25 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<25 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<26 + 1024 * 0, true> { int V __attribute__((bitwidth(26 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<26 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<26 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(26 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<26 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<27 + 1024 * 0, true> { int V __attribute__((bitwidth(27 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<27 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<27 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(27 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<27 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<28 + 1024 * 0, true> { int V __attribute__((bitwidth(28 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<28 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<28 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(28 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<28 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<29 + 1024 * 0, true> { int V __attribute__((bitwidth(29 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<29 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<29 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(29 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<29 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<30 + 1024 * 0, true> { int V __attribute__((bitwidth(30 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<30 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<30 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(30 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<30 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<31 + 1024 * 0, true> { int V __attribute__((bitwidth(31 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<31 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<31 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(31 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<31 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<32 + 1024 * 0, true> { int V __attribute__((bitwidth(32 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<32 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<32 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(32 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<32 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<33 + 1024 * 0, true> { int V __attribute__((bitwidth(33 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<33 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<33 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(33 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<33 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<34 + 1024 * 0, true> { int V __attribute__((bitwidth(34 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<34 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<34 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(34 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<34 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<35 + 1024 * 0, true> { int V __attribute__((bitwidth(35 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<35 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<35 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(35 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<35 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<36 + 1024 * 0, true> { int V __attribute__((bitwidth(36 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<36 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<36 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(36 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<36 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<37 + 1024 * 0, true> { int V __attribute__((bitwidth(37 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<37 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<37 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(37 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<37 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<38 + 1024 * 0, true> { int V __attribute__((bitwidth(38 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<38 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<38 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(38 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<38 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<39 + 1024 * 0, true> { int V __attribute__((bitwidth(39 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<39 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<39 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(39 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<39 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<40 + 1024 * 0, true> { int V __attribute__((bitwidth(40 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<40 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<40 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(40 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<40 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<41 + 1024 * 0, true> { int V __attribute__((bitwidth(41 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<41 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<41 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(41 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<41 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<42 + 1024 * 0, true> { int V __attribute__((bitwidth(42 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<42 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<42 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(42 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<42 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<43 + 1024 * 0, true> { int V __attribute__((bitwidth(43 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<43 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<43 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(43 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<43 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<44 + 1024 * 0, true> { int V __attribute__((bitwidth(44 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<44 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<44 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(44 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<44 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<45 + 1024 * 0, true> { int V __attribute__((bitwidth(45 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<45 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<45 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(45 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<45 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<46 + 1024 * 0, true> { int V __attribute__((bitwidth(46 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<46 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<46 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(46 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<46 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<47 + 1024 * 0, true> { int V __attribute__((bitwidth(47 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<47 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<47 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(47 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<47 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<48 + 1024 * 0, true> { int V __attribute__((bitwidth(48 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<48 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<48 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(48 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<48 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<49 + 1024 * 0, true> { int V __attribute__((bitwidth(49 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<49 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<49 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(49 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<49 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<50 + 1024 * 0, true> { int V __attribute__((bitwidth(50 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<50 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<50 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(50 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<50 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<51 + 1024 * 0, true> { int V __attribute__((bitwidth(51 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<51 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<51 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(51 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<51 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<52 + 1024 * 0, true> { int V __attribute__((bitwidth(52 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<52 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<52 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(52 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<52 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<53 + 1024 * 0, true> { int V __attribute__((bitwidth(53 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<53 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<53 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(53 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<53 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<54 + 1024 * 0, true> { int V __attribute__((bitwidth(54 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<54 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<54 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(54 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<54 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<55 + 1024 * 0, true> { int V __attribute__((bitwidth(55 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<55 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<55 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(55 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<55 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<56 + 1024 * 0, true> { int V __attribute__((bitwidth(56 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<56 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<56 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(56 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<56 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<57 + 1024 * 0, true> { int V __attribute__((bitwidth(57 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<57 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<57 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(57 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<57 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<58 + 1024 * 0, true> { int V __attribute__((bitwidth(58 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<58 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<58 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(58 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<58 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<59 + 1024 * 0, true> { int V __attribute__((bitwidth(59 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<59 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<59 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(59 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<59 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<60 + 1024 * 0, true> { int V __attribute__((bitwidth(60 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<60 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<60 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(60 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<60 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<61 + 1024 * 0, true> { int V __attribute__((bitwidth(61 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<61 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<61 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(61 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<61 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<62 + 1024 * 0, true> { int V __attribute__((bitwidth(62 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<62 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<62 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(62 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<62 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<63 + 1024 * 0, true> { int V __attribute__((bitwidth(63 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<63 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<63 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(63 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<63 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<64 + 1024 * 0, true> { int V __attribute__((bitwidth(64 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<64 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<64 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(64 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<64 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<65 + 1024 * 0, true> { int V __attribute__((bitwidth(65 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<65 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<65 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(65 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<65 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<66 + 1024 * 0, true> { int V __attribute__((bitwidth(66 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<66 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<66 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(66 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<66 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<67 + 1024 * 0, true> { int V __attribute__((bitwidth(67 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<67 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<67 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(67 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<67 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<68 + 1024 * 0, true> { int V __attribute__((bitwidth(68 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<68 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<68 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(68 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<68 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<69 + 1024 * 0, true> { int V __attribute__((bitwidth(69 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<69 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<69 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(69 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<69 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<70 + 1024 * 0, true> { int V __attribute__((bitwidth(70 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<70 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<70 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(70 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<70 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<71 + 1024 * 0, true> { int V __attribute__((bitwidth(71 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<71 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<71 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(71 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<71 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<72 + 1024 * 0, true> { int V __attribute__((bitwidth(72 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<72 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<72 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(72 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<72 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<73 + 1024 * 0, true> { int V __attribute__((bitwidth(73 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<73 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<73 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(73 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<73 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<74 + 1024 * 0, true> { int V __attribute__((bitwidth(74 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<74 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<74 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(74 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<74 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<75 + 1024 * 0, true> { int V __attribute__((bitwidth(75 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<75 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<75 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(75 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<75 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<76 + 1024 * 0, true> { int V __attribute__((bitwidth(76 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<76 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<76 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(76 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<76 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<77 + 1024 * 0, true> { int V __attribute__((bitwidth(77 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<77 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<77 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(77 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<77 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<78 + 1024 * 0, true> { int V __attribute__((bitwidth(78 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<78 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<78 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(78 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<78 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<79 + 1024 * 0, true> { int V __attribute__((bitwidth(79 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<79 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<79 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(79 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<79 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<80 + 1024 * 0, true> { int V __attribute__((bitwidth(80 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<80 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<80 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(80 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<80 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<81 + 1024 * 0, true> { int V __attribute__((bitwidth(81 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<81 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<81 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(81 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<81 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<82 + 1024 * 0, true> { int V __attribute__((bitwidth(82 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<82 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<82 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(82 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<82 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<83 + 1024 * 0, true> { int V __attribute__((bitwidth(83 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<83 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<83 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(83 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<83 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<84 + 1024 * 0, true> { int V __attribute__((bitwidth(84 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<84 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<84 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(84 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<84 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<85 + 1024 * 0, true> { int V __attribute__((bitwidth(85 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<85 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<85 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(85 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<85 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<86 + 1024 * 0, true> { int V __attribute__((bitwidth(86 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<86 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<86 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(86 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<86 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<87 + 1024 * 0, true> { int V __attribute__((bitwidth(87 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<87 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<87 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(87 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<87 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<88 + 1024 * 0, true> { int V __attribute__((bitwidth(88 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<88 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<88 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(88 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<88 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<89 + 1024 * 0, true> { int V __attribute__((bitwidth(89 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<89 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<89 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(89 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<89 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<90 + 1024 * 0, true> { int V __attribute__((bitwidth(90 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<90 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<90 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(90 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<90 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<91 + 1024 * 0, true> { int V __attribute__((bitwidth(91 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<91 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<91 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(91 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<91 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<92 + 1024 * 0, true> { int V __attribute__((bitwidth(92 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<92 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<92 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(92 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<92 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<93 + 1024 * 0, true> { int V __attribute__((bitwidth(93 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<93 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<93 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(93 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<93 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<94 + 1024 * 0, true> { int V __attribute__((bitwidth(94 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<94 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<94 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(94 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<94 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<95 + 1024 * 0, true> { int V __attribute__((bitwidth(95 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<95 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<95 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(95 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<95 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<96 + 1024 * 0, true> { int V __attribute__((bitwidth(96 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<96 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<96 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(96 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<96 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<97 + 1024 * 0, true> { int V __attribute__((bitwidth(97 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<97 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<97 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(97 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<97 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<98 + 1024 * 0, true> { int V __attribute__((bitwidth(98 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<98 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<98 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(98 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<98 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<99 + 1024 * 0, true> { int V __attribute__((bitwidth(99 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<99 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<99 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(99 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<99 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<100 + 1024 * 0, true> { int V __attribute__((bitwidth(100 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<100 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<100 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(100 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<100 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<101 + 1024 * 0, true> { int V __attribute__((bitwidth(101 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<101 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<101 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(101 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<101 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<102 + 1024 * 0, true> { int V __attribute__((bitwidth(102 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<102 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<102 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(102 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<102 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<103 + 1024 * 0, true> { int V __attribute__((bitwidth(103 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<103 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<103 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(103 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<103 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<104 + 1024 * 0, true> { int V __attribute__((bitwidth(104 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<104 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<104 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(104 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<104 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<105 + 1024 * 0, true> { int V __attribute__((bitwidth(105 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<105 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<105 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(105 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<105 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<106 + 1024 * 0, true> { int V __attribute__((bitwidth(106 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<106 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<106 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(106 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<106 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<107 + 1024 * 0, true> { int V __attribute__((bitwidth(107 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<107 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<107 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(107 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<107 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<108 + 1024 * 0, true> { int V __attribute__((bitwidth(108 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<108 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<108 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(108 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<108 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<109 + 1024 * 0, true> { int V __attribute__((bitwidth(109 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<109 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<109 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(109 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<109 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<110 + 1024 * 0, true> { int V __attribute__((bitwidth(110 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<110 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<110 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(110 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<110 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<111 + 1024 * 0, true> { int V __attribute__((bitwidth(111 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<111 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<111 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(111 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<111 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<112 + 1024 * 0, true> { int V __attribute__((bitwidth(112 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<112 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<112 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(112 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<112 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<113 + 1024 * 0, true> { int V __attribute__((bitwidth(113 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<113 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<113 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(113 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<113 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<114 + 1024 * 0, true> { int V __attribute__((bitwidth(114 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<114 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<114 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(114 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<114 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<115 + 1024 * 0, true> { int V __attribute__((bitwidth(115 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<115 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<115 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(115 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<115 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<116 + 1024 * 0, true> { int V __attribute__((bitwidth(116 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<116 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<116 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(116 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<116 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<117 + 1024 * 0, true> { int V __attribute__((bitwidth(117 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<117 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<117 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(117 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<117 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<118 + 1024 * 0, true> { int V __attribute__((bitwidth(118 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<118 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<118 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(118 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<118 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<119 + 1024 * 0, true> { int V __attribute__((bitwidth(119 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<119 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<119 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(119 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<119 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<120 + 1024 * 0, true> { int V __attribute__((bitwidth(120 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<120 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<120 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(120 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<120 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<121 + 1024 * 0, true> { int V __attribute__((bitwidth(121 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<121 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<121 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(121 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<121 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<122 + 1024 * 0, true> { int V __attribute__((bitwidth(122 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<122 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<122 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(122 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<122 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<123 + 1024 * 0, true> { int V __attribute__((bitwidth(123 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<123 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<123 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(123 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<123 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<124 + 1024 * 0, true> { int V __attribute__((bitwidth(124 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<124 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<124 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(124 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<124 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<125 + 1024 * 0, true> { int V __attribute__((bitwidth(125 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<125 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<125 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(125 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<125 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<126 + 1024 * 0, true> { int V __attribute__((bitwidth(126 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<126 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<126 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(126 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<126 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<127 + 1024 * 0, true> { int V __attribute__((bitwidth(127 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<127 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<127 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(127 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<127 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<128 + 1024 * 0, true> { int V __attribute__((bitwidth(128 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<128 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<128 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(128 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<128 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<129 + 1024 * 0, true> { int V __attribute__((bitwidth(129 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<129 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<129 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(129 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<129 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<130 + 1024 * 0, true> { int V __attribute__((bitwidth(130 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<130 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<130 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(130 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<130 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<131 + 1024 * 0, true> { int V __attribute__((bitwidth(131 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<131 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<131 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(131 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<131 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<132 + 1024 * 0, true> { int V __attribute__((bitwidth(132 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<132 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<132 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(132 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<132 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<133 + 1024 * 0, true> { int V __attribute__((bitwidth(133 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<133 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<133 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(133 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<133 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<134 + 1024 * 0, true> { int V __attribute__((bitwidth(134 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<134 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<134 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(134 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<134 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<135 + 1024 * 0, true> { int V __attribute__((bitwidth(135 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<135 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<135 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(135 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<135 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<136 + 1024 * 0, true> { int V __attribute__((bitwidth(136 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<136 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<136 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(136 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<136 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<137 + 1024 * 0, true> { int V __attribute__((bitwidth(137 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<137 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<137 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(137 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<137 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<138 + 1024 * 0, true> { int V __attribute__((bitwidth(138 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<138 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<138 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(138 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<138 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<139 + 1024 * 0, true> { int V __attribute__((bitwidth(139 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<139 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<139 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(139 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<139 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<140 + 1024 * 0, true> { int V __attribute__((bitwidth(140 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<140 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<140 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(140 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<140 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<141 + 1024 * 0, true> { int V __attribute__((bitwidth(141 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<141 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<141 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(141 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<141 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<142 + 1024 * 0, true> { int V __attribute__((bitwidth(142 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<142 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<142 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(142 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<142 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<143 + 1024 * 0, true> { int V __attribute__((bitwidth(143 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<143 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<143 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(143 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<143 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<144 + 1024 * 0, true> { int V __attribute__((bitwidth(144 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<144 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<144 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(144 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<144 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<145 + 1024 * 0, true> { int V __attribute__((bitwidth(145 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<145 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<145 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(145 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<145 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<146 + 1024 * 0, true> { int V __attribute__((bitwidth(146 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<146 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<146 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(146 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<146 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<147 + 1024 * 0, true> { int V __attribute__((bitwidth(147 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<147 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<147 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(147 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<147 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<148 + 1024 * 0, true> { int V __attribute__((bitwidth(148 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<148 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<148 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(148 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<148 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<149 + 1024 * 0, true> { int V __attribute__((bitwidth(149 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<149 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<149 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(149 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<149 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<150 + 1024 * 0, true> { int V __attribute__((bitwidth(150 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<150 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<150 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(150 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<150 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<151 + 1024 * 0, true> { int V __attribute__((bitwidth(151 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<151 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<151 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(151 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<151 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<152 + 1024 * 0, true> { int V __attribute__((bitwidth(152 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<152 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<152 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(152 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<152 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<153 + 1024 * 0, true> { int V __attribute__((bitwidth(153 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<153 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<153 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(153 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<153 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<154 + 1024 * 0, true> { int V __attribute__((bitwidth(154 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<154 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<154 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(154 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<154 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<155 + 1024 * 0, true> { int V __attribute__((bitwidth(155 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<155 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<155 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(155 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<155 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<156 + 1024 * 0, true> { int V __attribute__((bitwidth(156 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<156 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<156 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(156 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<156 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<157 + 1024 * 0, true> { int V __attribute__((bitwidth(157 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<157 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<157 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(157 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<157 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<158 + 1024 * 0, true> { int V __attribute__((bitwidth(158 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<158 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<158 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(158 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<158 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<159 + 1024 * 0, true> { int V __attribute__((bitwidth(159 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<159 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<159 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(159 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<159 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<160 + 1024 * 0, true> { int V __attribute__((bitwidth(160 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<160 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<160 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(160 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<160 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<161 + 1024 * 0, true> { int V __attribute__((bitwidth(161 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<161 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<161 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(161 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<161 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<162 + 1024 * 0, true> { int V __attribute__((bitwidth(162 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<162 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<162 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(162 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<162 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<163 + 1024 * 0, true> { int V __attribute__((bitwidth(163 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<163 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<163 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(163 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<163 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<164 + 1024 * 0, true> { int V __attribute__((bitwidth(164 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<164 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<164 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(164 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<164 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<165 + 1024 * 0, true> { int V __attribute__((bitwidth(165 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<165 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<165 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(165 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<165 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<166 + 1024 * 0, true> { int V __attribute__((bitwidth(166 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<166 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<166 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(166 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<166 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<167 + 1024 * 0, true> { int V __attribute__((bitwidth(167 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<167 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<167 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(167 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<167 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<168 + 1024 * 0, true> { int V __attribute__((bitwidth(168 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<168 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<168 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(168 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<168 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<169 + 1024 * 0, true> { int V __attribute__((bitwidth(169 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<169 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<169 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(169 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<169 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<170 + 1024 * 0, true> { int V __attribute__((bitwidth(170 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<170 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<170 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(170 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<170 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<171 + 1024 * 0, true> { int V __attribute__((bitwidth(171 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<171 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<171 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(171 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<171 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<172 + 1024 * 0, true> { int V __attribute__((bitwidth(172 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<172 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<172 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(172 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<172 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<173 + 1024 * 0, true> { int V __attribute__((bitwidth(173 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<173 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<173 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(173 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<173 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<174 + 1024 * 0, true> { int V __attribute__((bitwidth(174 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<174 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<174 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(174 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<174 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<175 + 1024 * 0, true> { int V __attribute__((bitwidth(175 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<175 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<175 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(175 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<175 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<176 + 1024 * 0, true> { int V __attribute__((bitwidth(176 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<176 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<176 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(176 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<176 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<177 + 1024 * 0, true> { int V __attribute__((bitwidth(177 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<177 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<177 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(177 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<177 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<178 + 1024 * 0, true> { int V __attribute__((bitwidth(178 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<178 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<178 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(178 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<178 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<179 + 1024 * 0, true> { int V __attribute__((bitwidth(179 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<179 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<179 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(179 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<179 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<180 + 1024 * 0, true> { int V __attribute__((bitwidth(180 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<180 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<180 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(180 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<180 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<181 + 1024 * 0, true> { int V __attribute__((bitwidth(181 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<181 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<181 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(181 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<181 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<182 + 1024 * 0, true> { int V __attribute__((bitwidth(182 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<182 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<182 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(182 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<182 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<183 + 1024 * 0, true> { int V __attribute__((bitwidth(183 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<183 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<183 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(183 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<183 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<184 + 1024 * 0, true> { int V __attribute__((bitwidth(184 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<184 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<184 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(184 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<184 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<185 + 1024 * 0, true> { int V __attribute__((bitwidth(185 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<185 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<185 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(185 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<185 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<186 + 1024 * 0, true> { int V __attribute__((bitwidth(186 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<186 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<186 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(186 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<186 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<187 + 1024 * 0, true> { int V __attribute__((bitwidth(187 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<187 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<187 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(187 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<187 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<188 + 1024 * 0, true> { int V __attribute__((bitwidth(188 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<188 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<188 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(188 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<188 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<189 + 1024 * 0, true> { int V __attribute__((bitwidth(189 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<189 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<189 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(189 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<189 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<190 + 1024 * 0, true> { int V __attribute__((bitwidth(190 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<190 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<190 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(190 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<190 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<191 + 1024 * 0, true> { int V __attribute__((bitwidth(191 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<191 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<191 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(191 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<191 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<192 + 1024 * 0, true> { int V __attribute__((bitwidth(192 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<192 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<192 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(192 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<192 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<193 + 1024 * 0, true> { int V __attribute__((bitwidth(193 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<193 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<193 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(193 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<193 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<194 + 1024 * 0, true> { int V __attribute__((bitwidth(194 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<194 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<194 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(194 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<194 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<195 + 1024 * 0, true> { int V __attribute__((bitwidth(195 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<195 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<195 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(195 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<195 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<196 + 1024 * 0, true> { int V __attribute__((bitwidth(196 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<196 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<196 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(196 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<196 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<197 + 1024 * 0, true> { int V __attribute__((bitwidth(197 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<197 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<197 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(197 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<197 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<198 + 1024 * 0, true> { int V __attribute__((bitwidth(198 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<198 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<198 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(198 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<198 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<199 + 1024 * 0, true> { int V __attribute__((bitwidth(199 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<199 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<199 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(199 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<199 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<200 + 1024 * 0, true> { int V __attribute__((bitwidth(200 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<200 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<200 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(200 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<200 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<201 + 1024 * 0, true> { int V __attribute__((bitwidth(201 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<201 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<201 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(201 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<201 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<202 + 1024 * 0, true> { int V __attribute__((bitwidth(202 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<202 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<202 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(202 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<202 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<203 + 1024 * 0, true> { int V __attribute__((bitwidth(203 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<203 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<203 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(203 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<203 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<204 + 1024 * 0, true> { int V __attribute__((bitwidth(204 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<204 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<204 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(204 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<204 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<205 + 1024 * 0, true> { int V __attribute__((bitwidth(205 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<205 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<205 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(205 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<205 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<206 + 1024 * 0, true> { int V __attribute__((bitwidth(206 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<206 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<206 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(206 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<206 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<207 + 1024 * 0, true> { int V __attribute__((bitwidth(207 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<207 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<207 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(207 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<207 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<208 + 1024 * 0, true> { int V __attribute__((bitwidth(208 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<208 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<208 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(208 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<208 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<209 + 1024 * 0, true> { int V __attribute__((bitwidth(209 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<209 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<209 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(209 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<209 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<210 + 1024 * 0, true> { int V __attribute__((bitwidth(210 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<210 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<210 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(210 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<210 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<211 + 1024 * 0, true> { int V __attribute__((bitwidth(211 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<211 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<211 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(211 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<211 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<212 + 1024 * 0, true> { int V __attribute__((bitwidth(212 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<212 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<212 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(212 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<212 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<213 + 1024 * 0, true> { int V __attribute__((bitwidth(213 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<213 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<213 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(213 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<213 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<214 + 1024 * 0, true> { int V __attribute__((bitwidth(214 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<214 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<214 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(214 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<214 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<215 + 1024 * 0, true> { int V __attribute__((bitwidth(215 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<215 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<215 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(215 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<215 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<216 + 1024 * 0, true> { int V __attribute__((bitwidth(216 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<216 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<216 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(216 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<216 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<217 + 1024 * 0, true> { int V __attribute__((bitwidth(217 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<217 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<217 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(217 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<217 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<218 + 1024 * 0, true> { int V __attribute__((bitwidth(218 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<218 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<218 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(218 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<218 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<219 + 1024 * 0, true> { int V __attribute__((bitwidth(219 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<219 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<219 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(219 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<219 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<220 + 1024 * 0, true> { int V __attribute__((bitwidth(220 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<220 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<220 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(220 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<220 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<221 + 1024 * 0, true> { int V __attribute__((bitwidth(221 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<221 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<221 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(221 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<221 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<222 + 1024 * 0, true> { int V __attribute__((bitwidth(222 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<222 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<222 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(222 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<222 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<223 + 1024 * 0, true> { int V __attribute__((bitwidth(223 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<223 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<223 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(223 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<223 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<224 + 1024 * 0, true> { int V __attribute__((bitwidth(224 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<224 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<224 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(224 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<224 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<225 + 1024 * 0, true> { int V __attribute__((bitwidth(225 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<225 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<225 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(225 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<225 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<226 + 1024 * 0, true> { int V __attribute__((bitwidth(226 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<226 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<226 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(226 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<226 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<227 + 1024 * 0, true> { int V __attribute__((bitwidth(227 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<227 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<227 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(227 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<227 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<228 + 1024 * 0, true> { int V __attribute__((bitwidth(228 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<228 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<228 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(228 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<228 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<229 + 1024 * 0, true> { int V __attribute__((bitwidth(229 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<229 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<229 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(229 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<229 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<230 + 1024 * 0, true> { int V __attribute__((bitwidth(230 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<230 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<230 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(230 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<230 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<231 + 1024 * 0, true> { int V __attribute__((bitwidth(231 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<231 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<231 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(231 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<231 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<232 + 1024 * 0, true> { int V __attribute__((bitwidth(232 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<232 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<232 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(232 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<232 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<233 + 1024 * 0, true> { int V __attribute__((bitwidth(233 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<233 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<233 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(233 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<233 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<234 + 1024 * 0, true> { int V __attribute__((bitwidth(234 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<234 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<234 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(234 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<234 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<235 + 1024 * 0, true> { int V __attribute__((bitwidth(235 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<235 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<235 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(235 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<235 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<236 + 1024 * 0, true> { int V __attribute__((bitwidth(236 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<236 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<236 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(236 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<236 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<237 + 1024 * 0, true> { int V __attribute__((bitwidth(237 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<237 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<237 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(237 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<237 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<238 + 1024 * 0, true> { int V __attribute__((bitwidth(238 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<238 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<238 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(238 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<238 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<239 + 1024 * 0, true> { int V __attribute__((bitwidth(239 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<239 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<239 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(239 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<239 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<240 + 1024 * 0, true> { int V __attribute__((bitwidth(240 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<240 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<240 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(240 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<240 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<241 + 1024 * 0, true> { int V __attribute__((bitwidth(241 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<241 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<241 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(241 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<241 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<242 + 1024 * 0, true> { int V __attribute__((bitwidth(242 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<242 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<242 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(242 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<242 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<243 + 1024 * 0, true> { int V __attribute__((bitwidth(243 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<243 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<243 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(243 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<243 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<244 + 1024 * 0, true> { int V __attribute__((bitwidth(244 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<244 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<244 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(244 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<244 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<245 + 1024 * 0, true> { int V __attribute__((bitwidth(245 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<245 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<245 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(245 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<245 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<246 + 1024 * 0, true> { int V __attribute__((bitwidth(246 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<246 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<246 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(246 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<246 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<247 + 1024 * 0, true> { int V __attribute__((bitwidth(247 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<247 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<247 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(247 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<247 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<248 + 1024 * 0, true> { int V __attribute__((bitwidth(248 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<248 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<248 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(248 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<248 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<249 + 1024 * 0, true> { int V __attribute__((bitwidth(249 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<249 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<249 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(249 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<249 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<250 + 1024 * 0, true> { int V __attribute__((bitwidth(250 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<250 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<250 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(250 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<250 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<251 + 1024 * 0, true> { int V __attribute__((bitwidth(251 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<251 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<251 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(251 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<251 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<252 + 1024 * 0, true> { int V __attribute__((bitwidth(252 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<252 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<252 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(252 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<252 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<253 + 1024 * 0, true> { int V __attribute__((bitwidth(253 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<253 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<253 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(253 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<253 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<254 + 1024 * 0, true> { int V __attribute__((bitwidth(254 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<254 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<254 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(254 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<254 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<255 + 1024 * 0, true> { int V __attribute__((bitwidth(255 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<255 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<255 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(255 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<255 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<256 + 1024 * 0, true> { int V __attribute__((bitwidth(256 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<256 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<256 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(256 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<256 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<257 + 1024 * 0, true> { int V __attribute__((bitwidth(257 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<257 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<257 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(257 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<257 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<258 + 1024 * 0, true> { int V __attribute__((bitwidth(258 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<258 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<258 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(258 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<258 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<259 + 1024 * 0, true> { int V __attribute__((bitwidth(259 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<259 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<259 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(259 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<259 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<260 + 1024 * 0, true> { int V __attribute__((bitwidth(260 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<260 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<260 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(260 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<260 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<261 + 1024 * 0, true> { int V __attribute__((bitwidth(261 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<261 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<261 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(261 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<261 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<262 + 1024 * 0, true> { int V __attribute__((bitwidth(262 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<262 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<262 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(262 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<262 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<263 + 1024 * 0, true> { int V __attribute__((bitwidth(263 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<263 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<263 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(263 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<263 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<264 + 1024 * 0, true> { int V __attribute__((bitwidth(264 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<264 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<264 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(264 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<264 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<265 + 1024 * 0, true> { int V __attribute__((bitwidth(265 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<265 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<265 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(265 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<265 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<266 + 1024 * 0, true> { int V __attribute__((bitwidth(266 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<266 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<266 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(266 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<266 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<267 + 1024 * 0, true> { int V __attribute__((bitwidth(267 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<267 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<267 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(267 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<267 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<268 + 1024 * 0, true> { int V __attribute__((bitwidth(268 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<268 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<268 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(268 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<268 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<269 + 1024 * 0, true> { int V __attribute__((bitwidth(269 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<269 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<269 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(269 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<269 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<270 + 1024 * 0, true> { int V __attribute__((bitwidth(270 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<270 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<270 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(270 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<270 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<271 + 1024 * 0, true> { int V __attribute__((bitwidth(271 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<271 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<271 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(271 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<271 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<272 + 1024 * 0, true> { int V __attribute__((bitwidth(272 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<272 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<272 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(272 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<272 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<273 + 1024 * 0, true> { int V __attribute__((bitwidth(273 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<273 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<273 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(273 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<273 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<274 + 1024 * 0, true> { int V __attribute__((bitwidth(274 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<274 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<274 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(274 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<274 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<275 + 1024 * 0, true> { int V __attribute__((bitwidth(275 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<275 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<275 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(275 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<275 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<276 + 1024 * 0, true> { int V __attribute__((bitwidth(276 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<276 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<276 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(276 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<276 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<277 + 1024 * 0, true> { int V __attribute__((bitwidth(277 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<277 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<277 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(277 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<277 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<278 + 1024 * 0, true> { int V __attribute__((bitwidth(278 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<278 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<278 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(278 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<278 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<279 + 1024 * 0, true> { int V __attribute__((bitwidth(279 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<279 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<279 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(279 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<279 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<280 + 1024 * 0, true> { int V __attribute__((bitwidth(280 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<280 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<280 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(280 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<280 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<281 + 1024 * 0, true> { int V __attribute__((bitwidth(281 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<281 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<281 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(281 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<281 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<282 + 1024 * 0, true> { int V __attribute__((bitwidth(282 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<282 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<282 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(282 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<282 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<283 + 1024 * 0, true> { int V __attribute__((bitwidth(283 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<283 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<283 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(283 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<283 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<284 + 1024 * 0, true> { int V __attribute__((bitwidth(284 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<284 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<284 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(284 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<284 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<285 + 1024 * 0, true> { int V __attribute__((bitwidth(285 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<285 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<285 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(285 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<285 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<286 + 1024 * 0, true> { int V __attribute__((bitwidth(286 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<286 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<286 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(286 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<286 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<287 + 1024 * 0, true> { int V __attribute__((bitwidth(287 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<287 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<287 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(287 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<287 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<288 + 1024 * 0, true> { int V __attribute__((bitwidth(288 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<288 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<288 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(288 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<288 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<289 + 1024 * 0, true> { int V __attribute__((bitwidth(289 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<289 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<289 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(289 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<289 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<290 + 1024 * 0, true> { int V __attribute__((bitwidth(290 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<290 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<290 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(290 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<290 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<291 + 1024 * 0, true> { int V __attribute__((bitwidth(291 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<291 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<291 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(291 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<291 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<292 + 1024 * 0, true> { int V __attribute__((bitwidth(292 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<292 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<292 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(292 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<292 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<293 + 1024 * 0, true> { int V __attribute__((bitwidth(293 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<293 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<293 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(293 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<293 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<294 + 1024 * 0, true> { int V __attribute__((bitwidth(294 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<294 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<294 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(294 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<294 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<295 + 1024 * 0, true> { int V __attribute__((bitwidth(295 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<295 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<295 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(295 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<295 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<296 + 1024 * 0, true> { int V __attribute__((bitwidth(296 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<296 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<296 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(296 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<296 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<297 + 1024 * 0, true> { int V __attribute__((bitwidth(297 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<297 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<297 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(297 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<297 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<298 + 1024 * 0, true> { int V __attribute__((bitwidth(298 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<298 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<298 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(298 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<298 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<299 + 1024 * 0, true> { int V __attribute__((bitwidth(299 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<299 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<299 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(299 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<299 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<300 + 1024 * 0, true> { int V __attribute__((bitwidth(300 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<300 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<300 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(300 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<300 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<301 + 1024 * 0, true> { int V __attribute__((bitwidth(301 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<301 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<301 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(301 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<301 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<302 + 1024 * 0, true> { int V __attribute__((bitwidth(302 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<302 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<302 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(302 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<302 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<303 + 1024 * 0, true> { int V __attribute__((bitwidth(303 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<303 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<303 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(303 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<303 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<304 + 1024 * 0, true> { int V __attribute__((bitwidth(304 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<304 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<304 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(304 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<304 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<305 + 1024 * 0, true> { int V __attribute__((bitwidth(305 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<305 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<305 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(305 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<305 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<306 + 1024 * 0, true> { int V __attribute__((bitwidth(306 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<306 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<306 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(306 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<306 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<307 + 1024 * 0, true> { int V __attribute__((bitwidth(307 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<307 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<307 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(307 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<307 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<308 + 1024 * 0, true> { int V __attribute__((bitwidth(308 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<308 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<308 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(308 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<308 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<309 + 1024 * 0, true> { int V __attribute__((bitwidth(309 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<309 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<309 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(309 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<309 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<310 + 1024 * 0, true> { int V __attribute__((bitwidth(310 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<310 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<310 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(310 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<310 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<311 + 1024 * 0, true> { int V __attribute__((bitwidth(311 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<311 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<311 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(311 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<311 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<312 + 1024 * 0, true> { int V __attribute__((bitwidth(312 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<312 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<312 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(312 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<312 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<313 + 1024 * 0, true> { int V __attribute__((bitwidth(313 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<313 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<313 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(313 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<313 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<314 + 1024 * 0, true> { int V __attribute__((bitwidth(314 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<314 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<314 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(314 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<314 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<315 + 1024 * 0, true> { int V __attribute__((bitwidth(315 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<315 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<315 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(315 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<315 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<316 + 1024 * 0, true> { int V __attribute__((bitwidth(316 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<316 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<316 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(316 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<316 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<317 + 1024 * 0, true> { int V __attribute__((bitwidth(317 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<317 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<317 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(317 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<317 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<318 + 1024 * 0, true> { int V __attribute__((bitwidth(318 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<318 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<318 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(318 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<318 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<319 + 1024 * 0, true> { int V __attribute__((bitwidth(319 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<319 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<319 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(319 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<319 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<320 + 1024 * 0, true> { int V __attribute__((bitwidth(320 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<320 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<320 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(320 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<320 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<321 + 1024 * 0, true> { int V __attribute__((bitwidth(321 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<321 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<321 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(321 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<321 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<322 + 1024 * 0, true> { int V __attribute__((bitwidth(322 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<322 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<322 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(322 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<322 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<323 + 1024 * 0, true> { int V __attribute__((bitwidth(323 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<323 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<323 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(323 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<323 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<324 + 1024 * 0, true> { int V __attribute__((bitwidth(324 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<324 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<324 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(324 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<324 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<325 + 1024 * 0, true> { int V __attribute__((bitwidth(325 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<325 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<325 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(325 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<325 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<326 + 1024 * 0, true> { int V __attribute__((bitwidth(326 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<326 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<326 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(326 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<326 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<327 + 1024 * 0, true> { int V __attribute__((bitwidth(327 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<327 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<327 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(327 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<327 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<328 + 1024 * 0, true> { int V __attribute__((bitwidth(328 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<328 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<328 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(328 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<328 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<329 + 1024 * 0, true> { int V __attribute__((bitwidth(329 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<329 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<329 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(329 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<329 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<330 + 1024 * 0, true> { int V __attribute__((bitwidth(330 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<330 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<330 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(330 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<330 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<331 + 1024 * 0, true> { int V __attribute__((bitwidth(331 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<331 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<331 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(331 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<331 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<332 + 1024 * 0, true> { int V __attribute__((bitwidth(332 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<332 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<332 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(332 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<332 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<333 + 1024 * 0, true> { int V __attribute__((bitwidth(333 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<333 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<333 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(333 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<333 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<334 + 1024 * 0, true> { int V __attribute__((bitwidth(334 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<334 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<334 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(334 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<334 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<335 + 1024 * 0, true> { int V __attribute__((bitwidth(335 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<335 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<335 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(335 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<335 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<336 + 1024 * 0, true> { int V __attribute__((bitwidth(336 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<336 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<336 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(336 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<336 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<337 + 1024 * 0, true> { int V __attribute__((bitwidth(337 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<337 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<337 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(337 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<337 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<338 + 1024 * 0, true> { int V __attribute__((bitwidth(338 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<338 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<338 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(338 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<338 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<339 + 1024 * 0, true> { int V __attribute__((bitwidth(339 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<339 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<339 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(339 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<339 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<340 + 1024 * 0, true> { int V __attribute__((bitwidth(340 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<340 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<340 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(340 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<340 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<341 + 1024 * 0, true> { int V __attribute__((bitwidth(341 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<341 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<341 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(341 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<341 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<342 + 1024 * 0, true> { int V __attribute__((bitwidth(342 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<342 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<342 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(342 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<342 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<343 + 1024 * 0, true> { int V __attribute__((bitwidth(343 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<343 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<343 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(343 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<343 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<344 + 1024 * 0, true> { int V __attribute__((bitwidth(344 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<344 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<344 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(344 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<344 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<345 + 1024 * 0, true> { int V __attribute__((bitwidth(345 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<345 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<345 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(345 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<345 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<346 + 1024 * 0, true> { int V __attribute__((bitwidth(346 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<346 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<346 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(346 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<346 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<347 + 1024 * 0, true> { int V __attribute__((bitwidth(347 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<347 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<347 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(347 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<347 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<348 + 1024 * 0, true> { int V __attribute__((bitwidth(348 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<348 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<348 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(348 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<348 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<349 + 1024 * 0, true> { int V __attribute__((bitwidth(349 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<349 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<349 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(349 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<349 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<350 + 1024 * 0, true> { int V __attribute__((bitwidth(350 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<350 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<350 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(350 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<350 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<351 + 1024 * 0, true> { int V __attribute__((bitwidth(351 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<351 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<351 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(351 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<351 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<352 + 1024 * 0, true> { int V __attribute__((bitwidth(352 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<352 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<352 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(352 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<352 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<353 + 1024 * 0, true> { int V __attribute__((bitwidth(353 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<353 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<353 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(353 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<353 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<354 + 1024 * 0, true> { int V __attribute__((bitwidth(354 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<354 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<354 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(354 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<354 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<355 + 1024 * 0, true> { int V __attribute__((bitwidth(355 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<355 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<355 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(355 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<355 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<356 + 1024 * 0, true> { int V __attribute__((bitwidth(356 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<356 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<356 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(356 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<356 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<357 + 1024 * 0, true> { int V __attribute__((bitwidth(357 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<357 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<357 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(357 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<357 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<358 + 1024 * 0, true> { int V __attribute__((bitwidth(358 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<358 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<358 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(358 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<358 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<359 + 1024 * 0, true> { int V __attribute__((bitwidth(359 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<359 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<359 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(359 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<359 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<360 + 1024 * 0, true> { int V __attribute__((bitwidth(360 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<360 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<360 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(360 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<360 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<361 + 1024 * 0, true> { int V __attribute__((bitwidth(361 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<361 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<361 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(361 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<361 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<362 + 1024 * 0, true> { int V __attribute__((bitwidth(362 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<362 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<362 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(362 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<362 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<363 + 1024 * 0, true> { int V __attribute__((bitwidth(363 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<363 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<363 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(363 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<363 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<364 + 1024 * 0, true> { int V __attribute__((bitwidth(364 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<364 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<364 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(364 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<364 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<365 + 1024 * 0, true> { int V __attribute__((bitwidth(365 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<365 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<365 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(365 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<365 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<366 + 1024 * 0, true> { int V __attribute__((bitwidth(366 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<366 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<366 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(366 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<366 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<367 + 1024 * 0, true> { int V __attribute__((bitwidth(367 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<367 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<367 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(367 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<367 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<368 + 1024 * 0, true> { int V __attribute__((bitwidth(368 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<368 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<368 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(368 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<368 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<369 + 1024 * 0, true> { int V __attribute__((bitwidth(369 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<369 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<369 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(369 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<369 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<370 + 1024 * 0, true> { int V __attribute__((bitwidth(370 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<370 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<370 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(370 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<370 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<371 + 1024 * 0, true> { int V __attribute__((bitwidth(371 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<371 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<371 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(371 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<371 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<372 + 1024 * 0, true> { int V __attribute__((bitwidth(372 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<372 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<372 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(372 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<372 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<373 + 1024 * 0, true> { int V __attribute__((bitwidth(373 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<373 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<373 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(373 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<373 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<374 + 1024 * 0, true> { int V __attribute__((bitwidth(374 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<374 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<374 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(374 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<374 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<375 + 1024 * 0, true> { int V __attribute__((bitwidth(375 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<375 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<375 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(375 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<375 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<376 + 1024 * 0, true> { int V __attribute__((bitwidth(376 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<376 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<376 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(376 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<376 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<377 + 1024 * 0, true> { int V __attribute__((bitwidth(377 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<377 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<377 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(377 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<377 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<378 + 1024 * 0, true> { int V __attribute__((bitwidth(378 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<378 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<378 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(378 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<378 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<379 + 1024 * 0, true> { int V __attribute__((bitwidth(379 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<379 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<379 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(379 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<379 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<380 + 1024 * 0, true> { int V __attribute__((bitwidth(380 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<380 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<380 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(380 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<380 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<381 + 1024 * 0, true> { int V __attribute__((bitwidth(381 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<381 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<381 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(381 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<381 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<382 + 1024 * 0, true> { int V __attribute__((bitwidth(382 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<382 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<382 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(382 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<382 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<383 + 1024 * 0, true> { int V __attribute__((bitwidth(383 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<383 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<383 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(383 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<383 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<384 + 1024 * 0, true> { int V __attribute__((bitwidth(384 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<384 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<384 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(384 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<384 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<385 + 1024 * 0, true> { int V __attribute__((bitwidth(385 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<385 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<385 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(385 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<385 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<386 + 1024 * 0, true> { int V __attribute__((bitwidth(386 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<386 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<386 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(386 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<386 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<387 + 1024 * 0, true> { int V __attribute__((bitwidth(387 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<387 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<387 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(387 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<387 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<388 + 1024 * 0, true> { int V __attribute__((bitwidth(388 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<388 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<388 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(388 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<388 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<389 + 1024 * 0, true> { int V __attribute__((bitwidth(389 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<389 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<389 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(389 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<389 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<390 + 1024 * 0, true> { int V __attribute__((bitwidth(390 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<390 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<390 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(390 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<390 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<391 + 1024 * 0, true> { int V __attribute__((bitwidth(391 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<391 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<391 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(391 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<391 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<392 + 1024 * 0, true> { int V __attribute__((bitwidth(392 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<392 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<392 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(392 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<392 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<393 + 1024 * 0, true> { int V __attribute__((bitwidth(393 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<393 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<393 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(393 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<393 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<394 + 1024 * 0, true> { int V __attribute__((bitwidth(394 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<394 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<394 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(394 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<394 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<395 + 1024 * 0, true> { int V __attribute__((bitwidth(395 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<395 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<395 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(395 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<395 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<396 + 1024 * 0, true> { int V __attribute__((bitwidth(396 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<396 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<396 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(396 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<396 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<397 + 1024 * 0, true> { int V __attribute__((bitwidth(397 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<397 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<397 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(397 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<397 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<398 + 1024 * 0, true> { int V __attribute__((bitwidth(398 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<398 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<398 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(398 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<398 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<399 + 1024 * 0, true> { int V __attribute__((bitwidth(399 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<399 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<399 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(399 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<399 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<400 + 1024 * 0, true> { int V __attribute__((bitwidth(400 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<400 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<400 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(400 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<400 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<401 + 1024 * 0, true> { int V __attribute__((bitwidth(401 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<401 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<401 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(401 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<401 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<402 + 1024 * 0, true> { int V __attribute__((bitwidth(402 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<402 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<402 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(402 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<402 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<403 + 1024 * 0, true> { int V __attribute__((bitwidth(403 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<403 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<403 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(403 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<403 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<404 + 1024 * 0, true> { int V __attribute__((bitwidth(404 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<404 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<404 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(404 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<404 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<405 + 1024 * 0, true> { int V __attribute__((bitwidth(405 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<405 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<405 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(405 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<405 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<406 + 1024 * 0, true> { int V __attribute__((bitwidth(406 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<406 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<406 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(406 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<406 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<407 + 1024 * 0, true> { int V __attribute__((bitwidth(407 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<407 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<407 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(407 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<407 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<408 + 1024 * 0, true> { int V __attribute__((bitwidth(408 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<408 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<408 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(408 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<408 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<409 + 1024 * 0, true> { int V __attribute__((bitwidth(409 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<409 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<409 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(409 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<409 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<410 + 1024 * 0, true> { int V __attribute__((bitwidth(410 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<410 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<410 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(410 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<410 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<411 + 1024 * 0, true> { int V __attribute__((bitwidth(411 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<411 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<411 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(411 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<411 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<412 + 1024 * 0, true> { int V __attribute__((bitwidth(412 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<412 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<412 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(412 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<412 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<413 + 1024 * 0, true> { int V __attribute__((bitwidth(413 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<413 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<413 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(413 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<413 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<414 + 1024 * 0, true> { int V __attribute__((bitwidth(414 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<414 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<414 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(414 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<414 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<415 + 1024 * 0, true> { int V __attribute__((bitwidth(415 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<415 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<415 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(415 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<415 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<416 + 1024 * 0, true> { int V __attribute__((bitwidth(416 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<416 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<416 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(416 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<416 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<417 + 1024 * 0, true> { int V __attribute__((bitwidth(417 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<417 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<417 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(417 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<417 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<418 + 1024 * 0, true> { int V __attribute__((bitwidth(418 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<418 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<418 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(418 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<418 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<419 + 1024 * 0, true> { int V __attribute__((bitwidth(419 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<419 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<419 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(419 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<419 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<420 + 1024 * 0, true> { int V __attribute__((bitwidth(420 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<420 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<420 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(420 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<420 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<421 + 1024 * 0, true> { int V __attribute__((bitwidth(421 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<421 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<421 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(421 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<421 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<422 + 1024 * 0, true> { int V __attribute__((bitwidth(422 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<422 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<422 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(422 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<422 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<423 + 1024 * 0, true> { int V __attribute__((bitwidth(423 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<423 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<423 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(423 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<423 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<424 + 1024 * 0, true> { int V __attribute__((bitwidth(424 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<424 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<424 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(424 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<424 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<425 + 1024 * 0, true> { int V __attribute__((bitwidth(425 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<425 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<425 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(425 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<425 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<426 + 1024 * 0, true> { int V __attribute__((bitwidth(426 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<426 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<426 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(426 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<426 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<427 + 1024 * 0, true> { int V __attribute__((bitwidth(427 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<427 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<427 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(427 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<427 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<428 + 1024 * 0, true> { int V __attribute__((bitwidth(428 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<428 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<428 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(428 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<428 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<429 + 1024 * 0, true> { int V __attribute__((bitwidth(429 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<429 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<429 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(429 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<429 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<430 + 1024 * 0, true> { int V __attribute__((bitwidth(430 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<430 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<430 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(430 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<430 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<431 + 1024 * 0, true> { int V __attribute__((bitwidth(431 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<431 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<431 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(431 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<431 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<432 + 1024 * 0, true> { int V __attribute__((bitwidth(432 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<432 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<432 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(432 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<432 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<433 + 1024 * 0, true> { int V __attribute__((bitwidth(433 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<433 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<433 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(433 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<433 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<434 + 1024 * 0, true> { int V __attribute__((bitwidth(434 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<434 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<434 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(434 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<434 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<435 + 1024 * 0, true> { int V __attribute__((bitwidth(435 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<435 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<435 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(435 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<435 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<436 + 1024 * 0, true> { int V __attribute__((bitwidth(436 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<436 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<436 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(436 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<436 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<437 + 1024 * 0, true> { int V __attribute__((bitwidth(437 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<437 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<437 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(437 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<437 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<438 + 1024 * 0, true> { int V __attribute__((bitwidth(438 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<438 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<438 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(438 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<438 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<439 + 1024 * 0, true> { int V __attribute__((bitwidth(439 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<439 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<439 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(439 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<439 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<440 + 1024 * 0, true> { int V __attribute__((bitwidth(440 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<440 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<440 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(440 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<440 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<441 + 1024 * 0, true> { int V __attribute__((bitwidth(441 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<441 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<441 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(441 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<441 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<442 + 1024 * 0, true> { int V __attribute__((bitwidth(442 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<442 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<442 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(442 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<442 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<443 + 1024 * 0, true> { int V __attribute__((bitwidth(443 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<443 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<443 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(443 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<443 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<444 + 1024 * 0, true> { int V __attribute__((bitwidth(444 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<444 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<444 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(444 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<444 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<445 + 1024 * 0, true> { int V __attribute__((bitwidth(445 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<445 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<445 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(445 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<445 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<446 + 1024 * 0, true> { int V __attribute__((bitwidth(446 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<446 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<446 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(446 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<446 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<447 + 1024 * 0, true> { int V __attribute__((bitwidth(447 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<447 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<447 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(447 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<447 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<448 + 1024 * 0, true> { int V __attribute__((bitwidth(448 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<448 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<448 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(448 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<448 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<449 + 1024 * 0, true> { int V __attribute__((bitwidth(449 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<449 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<449 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(449 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<449 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<450 + 1024 * 0, true> { int V __attribute__((bitwidth(450 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<450 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<450 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(450 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<450 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<451 + 1024 * 0, true> { int V __attribute__((bitwidth(451 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<451 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<451 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(451 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<451 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<452 + 1024 * 0, true> { int V __attribute__((bitwidth(452 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<452 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<452 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(452 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<452 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<453 + 1024 * 0, true> { int V __attribute__((bitwidth(453 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<453 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<453 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(453 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<453 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<454 + 1024 * 0, true> { int V __attribute__((bitwidth(454 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<454 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<454 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(454 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<454 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<455 + 1024 * 0, true> { int V __attribute__((bitwidth(455 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<455 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<455 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(455 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<455 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<456 + 1024 * 0, true> { int V __attribute__((bitwidth(456 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<456 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<456 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(456 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<456 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<457 + 1024 * 0, true> { int V __attribute__((bitwidth(457 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<457 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<457 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(457 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<457 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<458 + 1024 * 0, true> { int V __attribute__((bitwidth(458 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<458 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<458 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(458 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<458 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<459 + 1024 * 0, true> { int V __attribute__((bitwidth(459 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<459 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<459 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(459 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<459 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<460 + 1024 * 0, true> { int V __attribute__((bitwidth(460 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<460 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<460 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(460 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<460 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<461 + 1024 * 0, true> { int V __attribute__((bitwidth(461 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<461 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<461 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(461 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<461 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<462 + 1024 * 0, true> { int V __attribute__((bitwidth(462 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<462 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<462 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(462 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<462 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<463 + 1024 * 0, true> { int V __attribute__((bitwidth(463 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<463 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<463 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(463 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<463 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<464 + 1024 * 0, true> { int V __attribute__((bitwidth(464 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<464 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<464 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(464 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<464 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<465 + 1024 * 0, true> { int V __attribute__((bitwidth(465 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<465 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<465 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(465 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<465 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<466 + 1024 * 0, true> { int V __attribute__((bitwidth(466 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<466 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<466 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(466 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<466 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<467 + 1024 * 0, true> { int V __attribute__((bitwidth(467 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<467 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<467 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(467 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<467 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<468 + 1024 * 0, true> { int V __attribute__((bitwidth(468 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<468 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<468 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(468 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<468 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<469 + 1024 * 0, true> { int V __attribute__((bitwidth(469 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<469 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<469 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(469 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<469 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<470 + 1024 * 0, true> { int V __attribute__((bitwidth(470 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<470 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<470 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(470 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<470 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<471 + 1024 * 0, true> { int V __attribute__((bitwidth(471 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<471 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<471 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(471 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<471 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<472 + 1024 * 0, true> { int V __attribute__((bitwidth(472 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<472 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<472 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(472 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<472 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<473 + 1024 * 0, true> { int V __attribute__((bitwidth(473 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<473 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<473 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(473 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<473 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<474 + 1024 * 0, true> { int V __attribute__((bitwidth(474 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<474 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<474 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(474 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<474 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<475 + 1024 * 0, true> { int V __attribute__((bitwidth(475 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<475 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<475 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(475 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<475 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<476 + 1024 * 0, true> { int V __attribute__((bitwidth(476 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<476 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<476 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(476 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<476 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<477 + 1024 * 0, true> { int V __attribute__((bitwidth(477 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<477 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<477 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(477 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<477 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<478 + 1024 * 0, true> { int V __attribute__((bitwidth(478 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<478 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<478 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(478 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<478 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<479 + 1024 * 0, true> { int V __attribute__((bitwidth(479 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<479 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<479 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(479 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<479 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<480 + 1024 * 0, true> { int V __attribute__((bitwidth(480 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<480 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<480 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(480 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<480 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<481 + 1024 * 0, true> { int V __attribute__((bitwidth(481 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<481 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<481 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(481 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<481 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<482 + 1024 * 0, true> { int V __attribute__((bitwidth(482 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<482 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<482 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(482 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<482 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<483 + 1024 * 0, true> { int V __attribute__((bitwidth(483 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<483 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<483 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(483 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<483 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<484 + 1024 * 0, true> { int V __attribute__((bitwidth(484 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<484 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<484 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(484 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<484 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<485 + 1024 * 0, true> { int V __attribute__((bitwidth(485 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<485 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<485 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(485 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<485 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<486 + 1024 * 0, true> { int V __attribute__((bitwidth(486 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<486 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<486 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(486 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<486 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<487 + 1024 * 0, true> { int V __attribute__((bitwidth(487 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<487 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<487 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(487 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<487 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<488 + 1024 * 0, true> { int V __attribute__((bitwidth(488 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<488 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<488 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(488 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<488 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<489 + 1024 * 0, true> { int V __attribute__((bitwidth(489 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<489 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<489 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(489 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<489 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<490 + 1024 * 0, true> { int V __attribute__((bitwidth(490 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<490 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<490 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(490 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<490 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<491 + 1024 * 0, true> { int V __attribute__((bitwidth(491 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<491 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<491 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(491 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<491 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<492 + 1024 * 0, true> { int V __attribute__((bitwidth(492 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<492 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<492 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(492 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<492 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<493 + 1024 * 0, true> { int V __attribute__((bitwidth(493 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<493 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<493 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(493 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<493 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<494 + 1024 * 0, true> { int V __attribute__((bitwidth(494 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<494 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<494 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(494 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<494 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<495 + 1024 * 0, true> { int V __attribute__((bitwidth(495 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<495 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<495 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(495 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<495 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<496 + 1024 * 0, true> { int V __attribute__((bitwidth(496 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<496 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<496 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(496 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<496 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<497 + 1024 * 0, true> { int V __attribute__((bitwidth(497 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<497 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<497 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(497 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<497 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<498 + 1024 * 0, true> { int V __attribute__((bitwidth(498 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<498 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<498 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(498 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<498 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<499 + 1024 * 0, true> { int V __attribute__((bitwidth(499 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<499 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<499 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(499 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<499 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<500 + 1024 * 0, true> { int V __attribute__((bitwidth(500 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<500 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<500 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(500 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<500 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<501 + 1024 * 0, true> { int V __attribute__((bitwidth(501 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<501 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<501 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(501 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<501 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<502 + 1024 * 0, true> { int V __attribute__((bitwidth(502 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<502 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<502 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(502 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<502 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<503 + 1024 * 0, true> { int V __attribute__((bitwidth(503 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<503 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<503 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(503 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<503 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<504 + 1024 * 0, true> { int V __attribute__((bitwidth(504 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<504 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<504 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(504 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<504 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<505 + 1024 * 0, true> { int V __attribute__((bitwidth(505 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<505 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<505 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(505 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<505 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<506 + 1024 * 0, true> { int V __attribute__((bitwidth(506 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<506 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<506 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(506 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<506 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<507 + 1024 * 0, true> { int V __attribute__((bitwidth(507 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<507 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<507 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(507 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<507 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<508 + 1024 * 0, true> { int V __attribute__((bitwidth(508 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<508 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<508 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(508 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<508 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<509 + 1024 * 0, true> { int V __attribute__((bitwidth(509 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<509 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<509 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(509 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<509 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<510 + 1024 * 0, true> { int V __attribute__((bitwidth(510 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<510 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<510 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(510 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<510 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<511 + 1024 * 0, true> { int V __attribute__((bitwidth(511 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<511 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<511 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(511 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<511 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<512 + 1024 * 0, true> { int V __attribute__((bitwidth(512 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<512 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<512 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(512 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<512 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<513 + 1024 * 0, true> { int V __attribute__((bitwidth(513 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<513 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<513 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(513 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<513 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<514 + 1024 * 0, true> { int V __attribute__((bitwidth(514 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<514 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<514 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(514 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<514 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<515 + 1024 * 0, true> { int V __attribute__((bitwidth(515 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<515 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<515 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(515 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<515 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<516 + 1024 * 0, true> { int V __attribute__((bitwidth(516 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<516 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<516 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(516 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<516 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<517 + 1024 * 0, true> { int V __attribute__((bitwidth(517 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<517 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<517 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(517 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<517 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<518 + 1024 * 0, true> { int V __attribute__((bitwidth(518 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<518 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<518 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(518 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<518 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<519 + 1024 * 0, true> { int V __attribute__((bitwidth(519 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<519 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<519 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(519 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<519 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<520 + 1024 * 0, true> { int V __attribute__((bitwidth(520 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<520 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<520 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(520 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<520 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<521 + 1024 * 0, true> { int V __attribute__((bitwidth(521 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<521 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<521 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(521 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<521 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<522 + 1024 * 0, true> { int V __attribute__((bitwidth(522 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<522 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<522 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(522 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<522 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<523 + 1024 * 0, true> { int V __attribute__((bitwidth(523 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<523 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<523 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(523 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<523 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<524 + 1024 * 0, true> { int V __attribute__((bitwidth(524 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<524 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<524 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(524 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<524 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<525 + 1024 * 0, true> { int V __attribute__((bitwidth(525 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<525 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<525 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(525 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<525 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<526 + 1024 * 0, true> { int V __attribute__((bitwidth(526 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<526 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<526 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(526 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<526 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<527 + 1024 * 0, true> { int V __attribute__((bitwidth(527 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<527 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<527 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(527 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<527 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<528 + 1024 * 0, true> { int V __attribute__((bitwidth(528 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<528 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<528 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(528 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<528 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<529 + 1024 * 0, true> { int V __attribute__((bitwidth(529 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<529 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<529 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(529 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<529 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<530 + 1024 * 0, true> { int V __attribute__((bitwidth(530 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<530 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<530 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(530 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<530 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<531 + 1024 * 0, true> { int V __attribute__((bitwidth(531 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<531 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<531 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(531 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<531 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<532 + 1024 * 0, true> { int V __attribute__((bitwidth(532 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<532 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<532 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(532 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<532 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<533 + 1024 * 0, true> { int V __attribute__((bitwidth(533 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<533 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<533 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(533 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<533 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<534 + 1024 * 0, true> { int V __attribute__((bitwidth(534 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<534 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<534 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(534 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<534 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<535 + 1024 * 0, true> { int V __attribute__((bitwidth(535 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<535 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<535 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(535 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<535 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<536 + 1024 * 0, true> { int V __attribute__((bitwidth(536 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<536 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<536 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(536 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<536 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<537 + 1024 * 0, true> { int V __attribute__((bitwidth(537 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<537 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<537 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(537 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<537 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<538 + 1024 * 0, true> { int V __attribute__((bitwidth(538 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<538 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<538 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(538 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<538 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<539 + 1024 * 0, true> { int V __attribute__((bitwidth(539 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<539 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<539 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(539 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<539 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<540 + 1024 * 0, true> { int V __attribute__((bitwidth(540 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<540 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<540 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(540 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<540 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<541 + 1024 * 0, true> { int V __attribute__((bitwidth(541 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<541 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<541 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(541 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<541 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<542 + 1024 * 0, true> { int V __attribute__((bitwidth(542 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<542 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<542 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(542 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<542 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<543 + 1024 * 0, true> { int V __attribute__((bitwidth(543 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<543 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<543 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(543 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<543 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<544 + 1024 * 0, true> { int V __attribute__((bitwidth(544 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<544 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<544 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(544 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<544 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<545 + 1024 * 0, true> { int V __attribute__((bitwidth(545 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<545 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<545 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(545 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<545 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<546 + 1024 * 0, true> { int V __attribute__((bitwidth(546 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<546 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<546 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(546 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<546 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<547 + 1024 * 0, true> { int V __attribute__((bitwidth(547 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<547 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<547 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(547 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<547 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<548 + 1024 * 0, true> { int V __attribute__((bitwidth(548 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<548 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<548 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(548 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<548 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<549 + 1024 * 0, true> { int V __attribute__((bitwidth(549 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<549 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<549 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(549 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<549 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<550 + 1024 * 0, true> { int V __attribute__((bitwidth(550 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<550 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<550 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(550 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<550 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<551 + 1024 * 0, true> { int V __attribute__((bitwidth(551 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<551 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<551 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(551 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<551 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<552 + 1024 * 0, true> { int V __attribute__((bitwidth(552 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<552 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<552 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(552 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<552 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<553 + 1024 * 0, true> { int V __attribute__((bitwidth(553 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<553 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<553 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(553 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<553 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<554 + 1024 * 0, true> { int V __attribute__((bitwidth(554 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<554 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<554 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(554 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<554 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<555 + 1024 * 0, true> { int V __attribute__((bitwidth(555 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<555 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<555 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(555 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<555 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<556 + 1024 * 0, true> { int V __attribute__((bitwidth(556 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<556 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<556 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(556 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<556 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<557 + 1024 * 0, true> { int V __attribute__((bitwidth(557 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<557 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<557 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(557 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<557 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<558 + 1024 * 0, true> { int V __attribute__((bitwidth(558 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<558 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<558 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(558 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<558 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<559 + 1024 * 0, true> { int V __attribute__((bitwidth(559 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<559 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<559 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(559 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<559 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<560 + 1024 * 0, true> { int V __attribute__((bitwidth(560 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<560 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<560 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(560 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<560 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<561 + 1024 * 0, true> { int V __attribute__((bitwidth(561 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<561 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<561 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(561 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<561 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<562 + 1024 * 0, true> { int V __attribute__((bitwidth(562 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<562 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<562 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(562 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<562 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<563 + 1024 * 0, true> { int V __attribute__((bitwidth(563 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<563 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<563 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(563 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<563 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<564 + 1024 * 0, true> { int V __attribute__((bitwidth(564 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<564 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<564 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(564 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<564 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<565 + 1024 * 0, true> { int V __attribute__((bitwidth(565 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<565 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<565 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(565 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<565 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<566 + 1024 * 0, true> { int V __attribute__((bitwidth(566 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<566 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<566 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(566 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<566 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<567 + 1024 * 0, true> { int V __attribute__((bitwidth(567 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<567 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<567 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(567 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<567 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<568 + 1024 * 0, true> { int V __attribute__((bitwidth(568 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<568 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<568 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(568 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<568 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<569 + 1024 * 0, true> { int V __attribute__((bitwidth(569 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<569 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<569 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(569 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<569 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<570 + 1024 * 0, true> { int V __attribute__((bitwidth(570 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<570 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<570 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(570 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<570 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<571 + 1024 * 0, true> { int V __attribute__((bitwidth(571 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<571 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<571 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(571 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<571 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<572 + 1024 * 0, true> { int V __attribute__((bitwidth(572 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<572 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<572 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(572 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<572 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<573 + 1024 * 0, true> { int V __attribute__((bitwidth(573 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<573 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<573 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(573 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<573 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<574 + 1024 * 0, true> { int V __attribute__((bitwidth(574 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<574 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<574 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(574 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<574 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<575 + 1024 * 0, true> { int V __attribute__((bitwidth(575 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<575 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<575 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(575 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<575 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<576 + 1024 * 0, true> { int V __attribute__((bitwidth(576 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<576 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<576 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(576 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<576 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<577 + 1024 * 0, true> { int V __attribute__((bitwidth(577 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<577 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<577 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(577 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<577 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<578 + 1024 * 0, true> { int V __attribute__((bitwidth(578 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<578 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<578 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(578 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<578 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<579 + 1024 * 0, true> { int V __attribute__((bitwidth(579 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<579 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<579 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(579 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<579 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<580 + 1024 * 0, true> { int V __attribute__((bitwidth(580 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<580 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<580 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(580 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<580 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<581 + 1024 * 0, true> { int V __attribute__((bitwidth(581 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<581 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<581 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(581 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<581 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<582 + 1024 * 0, true> { int V __attribute__((bitwidth(582 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<582 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<582 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(582 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<582 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<583 + 1024 * 0, true> { int V __attribute__((bitwidth(583 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<583 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<583 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(583 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<583 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<584 + 1024 * 0, true> { int V __attribute__((bitwidth(584 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<584 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<584 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(584 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<584 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<585 + 1024 * 0, true> { int V __attribute__((bitwidth(585 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<585 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<585 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(585 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<585 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<586 + 1024 * 0, true> { int V __attribute__((bitwidth(586 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<586 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<586 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(586 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<586 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<587 + 1024 * 0, true> { int V __attribute__((bitwidth(587 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<587 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<587 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(587 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<587 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<588 + 1024 * 0, true> { int V __attribute__((bitwidth(588 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<588 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<588 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(588 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<588 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<589 + 1024 * 0, true> { int V __attribute__((bitwidth(589 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<589 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<589 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(589 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<589 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<590 + 1024 * 0, true> { int V __attribute__((bitwidth(590 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<590 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<590 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(590 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<590 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<591 + 1024 * 0, true> { int V __attribute__((bitwidth(591 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<591 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<591 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(591 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<591 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<592 + 1024 * 0, true> { int V __attribute__((bitwidth(592 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<592 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<592 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(592 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<592 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<593 + 1024 * 0, true> { int V __attribute__((bitwidth(593 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<593 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<593 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(593 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<593 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<594 + 1024 * 0, true> { int V __attribute__((bitwidth(594 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<594 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<594 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(594 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<594 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<595 + 1024 * 0, true> { int V __attribute__((bitwidth(595 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<595 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<595 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(595 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<595 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<596 + 1024 * 0, true> { int V __attribute__((bitwidth(596 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<596 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<596 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(596 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<596 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<597 + 1024 * 0, true> { int V __attribute__((bitwidth(597 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<597 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<597 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(597 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<597 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<598 + 1024 * 0, true> { int V __attribute__((bitwidth(598 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<598 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<598 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(598 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<598 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<599 + 1024 * 0, true> { int V __attribute__((bitwidth(599 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<599 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<599 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(599 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<599 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<600 + 1024 * 0, true> { int V __attribute__((bitwidth(600 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<600 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<600 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(600 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<600 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<601 + 1024 * 0, true> { int V __attribute__((bitwidth(601 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<601 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<601 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(601 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<601 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<602 + 1024 * 0, true> { int V __attribute__((bitwidth(602 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<602 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<602 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(602 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<602 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<603 + 1024 * 0, true> { int V __attribute__((bitwidth(603 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<603 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<603 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(603 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<603 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<604 + 1024 * 0, true> { int V __attribute__((bitwidth(604 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<604 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<604 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(604 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<604 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<605 + 1024 * 0, true> { int V __attribute__((bitwidth(605 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<605 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<605 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(605 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<605 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<606 + 1024 * 0, true> { int V __attribute__((bitwidth(606 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<606 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<606 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(606 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<606 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<607 + 1024 * 0, true> { int V __attribute__((bitwidth(607 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<607 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<607 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(607 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<607 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<608 + 1024 * 0, true> { int V __attribute__((bitwidth(608 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<608 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<608 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(608 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<608 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<609 + 1024 * 0, true> { int V __attribute__((bitwidth(609 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<609 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<609 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(609 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<609 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<610 + 1024 * 0, true> { int V __attribute__((bitwidth(610 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<610 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<610 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(610 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<610 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<611 + 1024 * 0, true> { int V __attribute__((bitwidth(611 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<611 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<611 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(611 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<611 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<612 + 1024 * 0, true> { int V __attribute__((bitwidth(612 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<612 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<612 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(612 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<612 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<613 + 1024 * 0, true> { int V __attribute__((bitwidth(613 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<613 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<613 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(613 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<613 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<614 + 1024 * 0, true> { int V __attribute__((bitwidth(614 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<614 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<614 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(614 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<614 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<615 + 1024 * 0, true> { int V __attribute__((bitwidth(615 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<615 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<615 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(615 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<615 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<616 + 1024 * 0, true> { int V __attribute__((bitwidth(616 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<616 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<616 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(616 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<616 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<617 + 1024 * 0, true> { int V __attribute__((bitwidth(617 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<617 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<617 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(617 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<617 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<618 + 1024 * 0, true> { int V __attribute__((bitwidth(618 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<618 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<618 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(618 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<618 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<619 + 1024 * 0, true> { int V __attribute__((bitwidth(619 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<619 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<619 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(619 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<619 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<620 + 1024 * 0, true> { int V __attribute__((bitwidth(620 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<620 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<620 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(620 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<620 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<621 + 1024 * 0, true> { int V __attribute__((bitwidth(621 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<621 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<621 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(621 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<621 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<622 + 1024 * 0, true> { int V __attribute__((bitwidth(622 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<622 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<622 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(622 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<622 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<623 + 1024 * 0, true> { int V __attribute__((bitwidth(623 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<623 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<623 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(623 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<623 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<624 + 1024 * 0, true> { int V __attribute__((bitwidth(624 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<624 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<624 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(624 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<624 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<625 + 1024 * 0, true> { int V __attribute__((bitwidth(625 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<625 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<625 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(625 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<625 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<626 + 1024 * 0, true> { int V __attribute__((bitwidth(626 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<626 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<626 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(626 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<626 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<627 + 1024 * 0, true> { int V __attribute__((bitwidth(627 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<627 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<627 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(627 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<627 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<628 + 1024 * 0, true> { int V __attribute__((bitwidth(628 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<628 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<628 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(628 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<628 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<629 + 1024 * 0, true> { int V __attribute__((bitwidth(629 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<629 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<629 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(629 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<629 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<630 + 1024 * 0, true> { int V __attribute__((bitwidth(630 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<630 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<630 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(630 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<630 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<631 + 1024 * 0, true> { int V __attribute__((bitwidth(631 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<631 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<631 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(631 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<631 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<632 + 1024 * 0, true> { int V __attribute__((bitwidth(632 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<632 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<632 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(632 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<632 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<633 + 1024 * 0, true> { int V __attribute__((bitwidth(633 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<633 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<633 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(633 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<633 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<634 + 1024 * 0, true> { int V __attribute__((bitwidth(634 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<634 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<634 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(634 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<634 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<635 + 1024 * 0, true> { int V __attribute__((bitwidth(635 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<635 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<635 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(635 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<635 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<636 + 1024 * 0, true> { int V __attribute__((bitwidth(636 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<636 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<636 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(636 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<636 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<637 + 1024 * 0, true> { int V __attribute__((bitwidth(637 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<637 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<637 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(637 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<637 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<638 + 1024 * 0, true> { int V __attribute__((bitwidth(638 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<638 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<638 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(638 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<638 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<639 + 1024 * 0, true> { int V __attribute__((bitwidth(639 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<639 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<639 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(639 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<639 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<640 + 1024 * 0, true> { int V __attribute__((bitwidth(640 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<640 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<640 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(640 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<640 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<641 + 1024 * 0, true> { int V __attribute__((bitwidth(641 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<641 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<641 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(641 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<641 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<642 + 1024 * 0, true> { int V __attribute__((bitwidth(642 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<642 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<642 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(642 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<642 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<643 + 1024 * 0, true> { int V __attribute__((bitwidth(643 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<643 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<643 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(643 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<643 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<644 + 1024 * 0, true> { int V __attribute__((bitwidth(644 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<644 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<644 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(644 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<644 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<645 + 1024 * 0, true> { int V __attribute__((bitwidth(645 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<645 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<645 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(645 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<645 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<646 + 1024 * 0, true> { int V __attribute__((bitwidth(646 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<646 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<646 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(646 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<646 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<647 + 1024 * 0, true> { int V __attribute__((bitwidth(647 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<647 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<647 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(647 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<647 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<648 + 1024 * 0, true> { int V __attribute__((bitwidth(648 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<648 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<648 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(648 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<648 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<649 + 1024 * 0, true> { int V __attribute__((bitwidth(649 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<649 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<649 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(649 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<649 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<650 + 1024 * 0, true> { int V __attribute__((bitwidth(650 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<650 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<650 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(650 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<650 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<651 + 1024 * 0, true> { int V __attribute__((bitwidth(651 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<651 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<651 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(651 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<651 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<652 + 1024 * 0, true> { int V __attribute__((bitwidth(652 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<652 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<652 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(652 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<652 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<653 + 1024 * 0, true> { int V __attribute__((bitwidth(653 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<653 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<653 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(653 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<653 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<654 + 1024 * 0, true> { int V __attribute__((bitwidth(654 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<654 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<654 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(654 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<654 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<655 + 1024 * 0, true> { int V __attribute__((bitwidth(655 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<655 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<655 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(655 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<655 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<656 + 1024 * 0, true> { int V __attribute__((bitwidth(656 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<656 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<656 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(656 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<656 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<657 + 1024 * 0, true> { int V __attribute__((bitwidth(657 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<657 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<657 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(657 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<657 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<658 + 1024 * 0, true> { int V __attribute__((bitwidth(658 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<658 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<658 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(658 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<658 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<659 + 1024 * 0, true> { int V __attribute__((bitwidth(659 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<659 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<659 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(659 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<659 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<660 + 1024 * 0, true> { int V __attribute__((bitwidth(660 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<660 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<660 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(660 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<660 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<661 + 1024 * 0, true> { int V __attribute__((bitwidth(661 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<661 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<661 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(661 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<661 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<662 + 1024 * 0, true> { int V __attribute__((bitwidth(662 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<662 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<662 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(662 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<662 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<663 + 1024 * 0, true> { int V __attribute__((bitwidth(663 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<663 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<663 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(663 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<663 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<664 + 1024 * 0, true> { int V __attribute__((bitwidth(664 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<664 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<664 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(664 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<664 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<665 + 1024 * 0, true> { int V __attribute__((bitwidth(665 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<665 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<665 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(665 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<665 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<666 + 1024 * 0, true> { int V __attribute__((bitwidth(666 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<666 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<666 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(666 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<666 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<667 + 1024 * 0, true> { int V __attribute__((bitwidth(667 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<667 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<667 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(667 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<667 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<668 + 1024 * 0, true> { int V __attribute__((bitwidth(668 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<668 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<668 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(668 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<668 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<669 + 1024 * 0, true> { int V __attribute__((bitwidth(669 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<669 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<669 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(669 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<669 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<670 + 1024 * 0, true> { int V __attribute__((bitwidth(670 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<670 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<670 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(670 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<670 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<671 + 1024 * 0, true> { int V __attribute__((bitwidth(671 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<671 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<671 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(671 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<671 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<672 + 1024 * 0, true> { int V __attribute__((bitwidth(672 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<672 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<672 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(672 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<672 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<673 + 1024 * 0, true> { int V __attribute__((bitwidth(673 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<673 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<673 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(673 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<673 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<674 + 1024 * 0, true> { int V __attribute__((bitwidth(674 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<674 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<674 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(674 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<674 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<675 + 1024 * 0, true> { int V __attribute__((bitwidth(675 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<675 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<675 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(675 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<675 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<676 + 1024 * 0, true> { int V __attribute__((bitwidth(676 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<676 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<676 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(676 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<676 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<677 + 1024 * 0, true> { int V __attribute__((bitwidth(677 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<677 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<677 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(677 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<677 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<678 + 1024 * 0, true> { int V __attribute__((bitwidth(678 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<678 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<678 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(678 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<678 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<679 + 1024 * 0, true> { int V __attribute__((bitwidth(679 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<679 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<679 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(679 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<679 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<680 + 1024 * 0, true> { int V __attribute__((bitwidth(680 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<680 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<680 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(680 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<680 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<681 + 1024 * 0, true> { int V __attribute__((bitwidth(681 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<681 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<681 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(681 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<681 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<682 + 1024 * 0, true> { int V __attribute__((bitwidth(682 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<682 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<682 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(682 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<682 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<683 + 1024 * 0, true> { int V __attribute__((bitwidth(683 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<683 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<683 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(683 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<683 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<684 + 1024 * 0, true> { int V __attribute__((bitwidth(684 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<684 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<684 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(684 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<684 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<685 + 1024 * 0, true> { int V __attribute__((bitwidth(685 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<685 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<685 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(685 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<685 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<686 + 1024 * 0, true> { int V __attribute__((bitwidth(686 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<686 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<686 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(686 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<686 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<687 + 1024 * 0, true> { int V __attribute__((bitwidth(687 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<687 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<687 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(687 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<687 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<688 + 1024 * 0, true> { int V __attribute__((bitwidth(688 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<688 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<688 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(688 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<688 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<689 + 1024 * 0, true> { int V __attribute__((bitwidth(689 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<689 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<689 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(689 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<689 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<690 + 1024 * 0, true> { int V __attribute__((bitwidth(690 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<690 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<690 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(690 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<690 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<691 + 1024 * 0, true> { int V __attribute__((bitwidth(691 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<691 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<691 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(691 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<691 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<692 + 1024 * 0, true> { int V __attribute__((bitwidth(692 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<692 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<692 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(692 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<692 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<693 + 1024 * 0, true> { int V __attribute__((bitwidth(693 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<693 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<693 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(693 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<693 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<694 + 1024 * 0, true> { int V __attribute__((bitwidth(694 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<694 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<694 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(694 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<694 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<695 + 1024 * 0, true> { int V __attribute__((bitwidth(695 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<695 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<695 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(695 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<695 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<696 + 1024 * 0, true> { int V __attribute__((bitwidth(696 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<696 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<696 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(696 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<696 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<697 + 1024 * 0, true> { int V __attribute__((bitwidth(697 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<697 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<697 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(697 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<697 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<698 + 1024 * 0, true> { int V __attribute__((bitwidth(698 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<698 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<698 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(698 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<698 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<699 + 1024 * 0, true> { int V __attribute__((bitwidth(699 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<699 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<699 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(699 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<699 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<700 + 1024 * 0, true> { int V __attribute__((bitwidth(700 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<700 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<700 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(700 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<700 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<701 + 1024 * 0, true> { int V __attribute__((bitwidth(701 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<701 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<701 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(701 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<701 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<702 + 1024 * 0, true> { int V __attribute__((bitwidth(702 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<702 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<702 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(702 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<702 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<703 + 1024 * 0, true> { int V __attribute__((bitwidth(703 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<703 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<703 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(703 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<703 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<704 + 1024 * 0, true> { int V __attribute__((bitwidth(704 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<704 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<704 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(704 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<704 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<705 + 1024 * 0, true> { int V __attribute__((bitwidth(705 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<705 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<705 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(705 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<705 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<706 + 1024 * 0, true> { int V __attribute__((bitwidth(706 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<706 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<706 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(706 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<706 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<707 + 1024 * 0, true> { int V __attribute__((bitwidth(707 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<707 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<707 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(707 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<707 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<708 + 1024 * 0, true> { int V __attribute__((bitwidth(708 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<708 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<708 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(708 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<708 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<709 + 1024 * 0, true> { int V __attribute__((bitwidth(709 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<709 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<709 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(709 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<709 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<710 + 1024 * 0, true> { int V __attribute__((bitwidth(710 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<710 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<710 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(710 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<710 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<711 + 1024 * 0, true> { int V __attribute__((bitwidth(711 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<711 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<711 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(711 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<711 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<712 + 1024 * 0, true> { int V __attribute__((bitwidth(712 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<712 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<712 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(712 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<712 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<713 + 1024 * 0, true> { int V __attribute__((bitwidth(713 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<713 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<713 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(713 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<713 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<714 + 1024 * 0, true> { int V __attribute__((bitwidth(714 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<714 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<714 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(714 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<714 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<715 + 1024 * 0, true> { int V __attribute__((bitwidth(715 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<715 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<715 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(715 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<715 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<716 + 1024 * 0, true> { int V __attribute__((bitwidth(716 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<716 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<716 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(716 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<716 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<717 + 1024 * 0, true> { int V __attribute__((bitwidth(717 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<717 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<717 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(717 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<717 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<718 + 1024 * 0, true> { int V __attribute__((bitwidth(718 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<718 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<718 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(718 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<718 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<719 + 1024 * 0, true> { int V __attribute__((bitwidth(719 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<719 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<719 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(719 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<719 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<720 + 1024 * 0, true> { int V __attribute__((bitwidth(720 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<720 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<720 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(720 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<720 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<721 + 1024 * 0, true> { int V __attribute__((bitwidth(721 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<721 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<721 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(721 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<721 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<722 + 1024 * 0, true> { int V __attribute__((bitwidth(722 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<722 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<722 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(722 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<722 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<723 + 1024 * 0, true> { int V __attribute__((bitwidth(723 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<723 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<723 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(723 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<723 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<724 + 1024 * 0, true> { int V __attribute__((bitwidth(724 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<724 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<724 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(724 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<724 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<725 + 1024 * 0, true> { int V __attribute__((bitwidth(725 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<725 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<725 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(725 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<725 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<726 + 1024 * 0, true> { int V __attribute__((bitwidth(726 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<726 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<726 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(726 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<726 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<727 + 1024 * 0, true> { int V __attribute__((bitwidth(727 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<727 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<727 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(727 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<727 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<728 + 1024 * 0, true> { int V __attribute__((bitwidth(728 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<728 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<728 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(728 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<728 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<729 + 1024 * 0, true> { int V __attribute__((bitwidth(729 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<729 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<729 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(729 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<729 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<730 + 1024 * 0, true> { int V __attribute__((bitwidth(730 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<730 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<730 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(730 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<730 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<731 + 1024 * 0, true> { int V __attribute__((bitwidth(731 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<731 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<731 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(731 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<731 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<732 + 1024 * 0, true> { int V __attribute__((bitwidth(732 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<732 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<732 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(732 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<732 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<733 + 1024 * 0, true> { int V __attribute__((bitwidth(733 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<733 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<733 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(733 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<733 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<734 + 1024 * 0, true> { int V __attribute__((bitwidth(734 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<734 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<734 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(734 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<734 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<735 + 1024 * 0, true> { int V __attribute__((bitwidth(735 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<735 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<735 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(735 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<735 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<736 + 1024 * 0, true> { int V __attribute__((bitwidth(736 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<736 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<736 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(736 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<736 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<737 + 1024 * 0, true> { int V __attribute__((bitwidth(737 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<737 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<737 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(737 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<737 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<738 + 1024 * 0, true> { int V __attribute__((bitwidth(738 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<738 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<738 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(738 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<738 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<739 + 1024 * 0, true> { int V __attribute__((bitwidth(739 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<739 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<739 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(739 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<739 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<740 + 1024 * 0, true> { int V __attribute__((bitwidth(740 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<740 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<740 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(740 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<740 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<741 + 1024 * 0, true> { int V __attribute__((bitwidth(741 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<741 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<741 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(741 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<741 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<742 + 1024 * 0, true> { int V __attribute__((bitwidth(742 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<742 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<742 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(742 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<742 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<743 + 1024 * 0, true> { int V __attribute__((bitwidth(743 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<743 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<743 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(743 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<743 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<744 + 1024 * 0, true> { int V __attribute__((bitwidth(744 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<744 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<744 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(744 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<744 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<745 + 1024 * 0, true> { int V __attribute__((bitwidth(745 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<745 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<745 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(745 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<745 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<746 + 1024 * 0, true> { int V __attribute__((bitwidth(746 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<746 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<746 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(746 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<746 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<747 + 1024 * 0, true> { int V __attribute__((bitwidth(747 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<747 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<747 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(747 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<747 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<748 + 1024 * 0, true> { int V __attribute__((bitwidth(748 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<748 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<748 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(748 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<748 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<749 + 1024 * 0, true> { int V __attribute__((bitwidth(749 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<749 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<749 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(749 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<749 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<750 + 1024 * 0, true> { int V __attribute__((bitwidth(750 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<750 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<750 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(750 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<750 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<751 + 1024 * 0, true> { int V __attribute__((bitwidth(751 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<751 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<751 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(751 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<751 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<752 + 1024 * 0, true> { int V __attribute__((bitwidth(752 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<752 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<752 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(752 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<752 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<753 + 1024 * 0, true> { int V __attribute__((bitwidth(753 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<753 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<753 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(753 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<753 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<754 + 1024 * 0, true> { int V __attribute__((bitwidth(754 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<754 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<754 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(754 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<754 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<755 + 1024 * 0, true> { int V __attribute__((bitwidth(755 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<755 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<755 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(755 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<755 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<756 + 1024 * 0, true> { int V __attribute__((bitwidth(756 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<756 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<756 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(756 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<756 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<757 + 1024 * 0, true> { int V __attribute__((bitwidth(757 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<757 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<757 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(757 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<757 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<758 + 1024 * 0, true> { int V __attribute__((bitwidth(758 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<758 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<758 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(758 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<758 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<759 + 1024 * 0, true> { int V __attribute__((bitwidth(759 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<759 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<759 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(759 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<759 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<760 + 1024 * 0, true> { int V __attribute__((bitwidth(760 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<760 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<760 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(760 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<760 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<761 + 1024 * 0, true> { int V __attribute__((bitwidth(761 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<761 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<761 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(761 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<761 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<762 + 1024 * 0, true> { int V __attribute__((bitwidth(762 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<762 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<762 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(762 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<762 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<763 + 1024 * 0, true> { int V __attribute__((bitwidth(763 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<763 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<763 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(763 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<763 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<764 + 1024 * 0, true> { int V __attribute__((bitwidth(764 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<764 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<764 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(764 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<764 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<765 + 1024 * 0, true> { int V __attribute__((bitwidth(765 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<765 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<765 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(765 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<765 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<766 + 1024 * 0, true> { int V __attribute__((bitwidth(766 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<766 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<766 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(766 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<766 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<767 + 1024 * 0, true> { int V __attribute__((bitwidth(767 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<767 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<767 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(767 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<767 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<768 + 1024 * 0, true> { int V __attribute__((bitwidth(768 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<768 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<768 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(768 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<768 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<769 + 1024 * 0, true> { int V __attribute__((bitwidth(769 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<769 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<769 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(769 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<769 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<770 + 1024 * 0, true> { int V __attribute__((bitwidth(770 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<770 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<770 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(770 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<770 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<771 + 1024 * 0, true> { int V __attribute__((bitwidth(771 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<771 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<771 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(771 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<771 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<772 + 1024 * 0, true> { int V __attribute__((bitwidth(772 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<772 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<772 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(772 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<772 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<773 + 1024 * 0, true> { int V __attribute__((bitwidth(773 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<773 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<773 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(773 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<773 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<774 + 1024 * 0, true> { int V __attribute__((bitwidth(774 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<774 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<774 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(774 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<774 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<775 + 1024 * 0, true> { int V __attribute__((bitwidth(775 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<775 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<775 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(775 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<775 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<776 + 1024 * 0, true> { int V __attribute__((bitwidth(776 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<776 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<776 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(776 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<776 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<777 + 1024 * 0, true> { int V __attribute__((bitwidth(777 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<777 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<777 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(777 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<777 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<778 + 1024 * 0, true> { int V __attribute__((bitwidth(778 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<778 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<778 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(778 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<778 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<779 + 1024 * 0, true> { int V __attribute__((bitwidth(779 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<779 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<779 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(779 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<779 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<780 + 1024 * 0, true> { int V __attribute__((bitwidth(780 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<780 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<780 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(780 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<780 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<781 + 1024 * 0, true> { int V __attribute__((bitwidth(781 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<781 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<781 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(781 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<781 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<782 + 1024 * 0, true> { int V __attribute__((bitwidth(782 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<782 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<782 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(782 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<782 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<783 + 1024 * 0, true> { int V __attribute__((bitwidth(783 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<783 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<783 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(783 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<783 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<784 + 1024 * 0, true> { int V __attribute__((bitwidth(784 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<784 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<784 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(784 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<784 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<785 + 1024 * 0, true> { int V __attribute__((bitwidth(785 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<785 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<785 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(785 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<785 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<786 + 1024 * 0, true> { int V __attribute__((bitwidth(786 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<786 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<786 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(786 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<786 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<787 + 1024 * 0, true> { int V __attribute__((bitwidth(787 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<787 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<787 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(787 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<787 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<788 + 1024 * 0, true> { int V __attribute__((bitwidth(788 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<788 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<788 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(788 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<788 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<789 + 1024 * 0, true> { int V __attribute__((bitwidth(789 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<789 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<789 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(789 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<789 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<790 + 1024 * 0, true> { int V __attribute__((bitwidth(790 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<790 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<790 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(790 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<790 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<791 + 1024 * 0, true> { int V __attribute__((bitwidth(791 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<791 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<791 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(791 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<791 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<792 + 1024 * 0, true> { int V __attribute__((bitwidth(792 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<792 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<792 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(792 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<792 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<793 + 1024 * 0, true> { int V __attribute__((bitwidth(793 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<793 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<793 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(793 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<793 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<794 + 1024 * 0, true> { int V __attribute__((bitwidth(794 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<794 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<794 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(794 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<794 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<795 + 1024 * 0, true> { int V __attribute__((bitwidth(795 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<795 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<795 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(795 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<795 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<796 + 1024 * 0, true> { int V __attribute__((bitwidth(796 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<796 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<796 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(796 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<796 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<797 + 1024 * 0, true> { int V __attribute__((bitwidth(797 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<797 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<797 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(797 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<797 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<798 + 1024 * 0, true> { int V __attribute__((bitwidth(798 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<798 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<798 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(798 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<798 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<799 + 1024 * 0, true> { int V __attribute__((bitwidth(799 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<799 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<799 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(799 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<799 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<800 + 1024 * 0, true> { int V __attribute__((bitwidth(800 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<800 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<800 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(800 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<800 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<801 + 1024 * 0, true> { int V __attribute__((bitwidth(801 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<801 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<801 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(801 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<801 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<802 + 1024 * 0, true> { int V __attribute__((bitwidth(802 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<802 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<802 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(802 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<802 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<803 + 1024 * 0, true> { int V __attribute__((bitwidth(803 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<803 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<803 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(803 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<803 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<804 + 1024 * 0, true> { int V __attribute__((bitwidth(804 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<804 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<804 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(804 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<804 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<805 + 1024 * 0, true> { int V __attribute__((bitwidth(805 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<805 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<805 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(805 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<805 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<806 + 1024 * 0, true> { int V __attribute__((bitwidth(806 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<806 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<806 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(806 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<806 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<807 + 1024 * 0, true> { int V __attribute__((bitwidth(807 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<807 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<807 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(807 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<807 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<808 + 1024 * 0, true> { int V __attribute__((bitwidth(808 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<808 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<808 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(808 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<808 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<809 + 1024 * 0, true> { int V __attribute__((bitwidth(809 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<809 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<809 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(809 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<809 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<810 + 1024 * 0, true> { int V __attribute__((bitwidth(810 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<810 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<810 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(810 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<810 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<811 + 1024 * 0, true> { int V __attribute__((bitwidth(811 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<811 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<811 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(811 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<811 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<812 + 1024 * 0, true> { int V __attribute__((bitwidth(812 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<812 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<812 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(812 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<812 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<813 + 1024 * 0, true> { int V __attribute__((bitwidth(813 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<813 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<813 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(813 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<813 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<814 + 1024 * 0, true> { int V __attribute__((bitwidth(814 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<814 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<814 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(814 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<814 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<815 + 1024 * 0, true> { int V __attribute__((bitwidth(815 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<815 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<815 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(815 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<815 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<816 + 1024 * 0, true> { int V __attribute__((bitwidth(816 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<816 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<816 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(816 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<816 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<817 + 1024 * 0, true> { int V __attribute__((bitwidth(817 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<817 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<817 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(817 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<817 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<818 + 1024 * 0, true> { int V __attribute__((bitwidth(818 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<818 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<818 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(818 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<818 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<819 + 1024 * 0, true> { int V __attribute__((bitwidth(819 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<819 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<819 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(819 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<819 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<820 + 1024 * 0, true> { int V __attribute__((bitwidth(820 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<820 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<820 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(820 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<820 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<821 + 1024 * 0, true> { int V __attribute__((bitwidth(821 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<821 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<821 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(821 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<821 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<822 + 1024 * 0, true> { int V __attribute__((bitwidth(822 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<822 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<822 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(822 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<822 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<823 + 1024 * 0, true> { int V __attribute__((bitwidth(823 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<823 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<823 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(823 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<823 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<824 + 1024 * 0, true> { int V __attribute__((bitwidth(824 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<824 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<824 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(824 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<824 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<825 + 1024 * 0, true> { int V __attribute__((bitwidth(825 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<825 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<825 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(825 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<825 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<826 + 1024 * 0, true> { int V __attribute__((bitwidth(826 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<826 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<826 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(826 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<826 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<827 + 1024 * 0, true> { int V __attribute__((bitwidth(827 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<827 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<827 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(827 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<827 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<828 + 1024 * 0, true> { int V __attribute__((bitwidth(828 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<828 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<828 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(828 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<828 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<829 + 1024 * 0, true> { int V __attribute__((bitwidth(829 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<829 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<829 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(829 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<829 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<830 + 1024 * 0, true> { int V __attribute__((bitwidth(830 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<830 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<830 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(830 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<830 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<831 + 1024 * 0, true> { int V __attribute__((bitwidth(831 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<831 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<831 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(831 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<831 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<832 + 1024 * 0, true> { int V __attribute__((bitwidth(832 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<832 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<832 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(832 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<832 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<833 + 1024 * 0, true> { int V __attribute__((bitwidth(833 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<833 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<833 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(833 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<833 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<834 + 1024 * 0, true> { int V __attribute__((bitwidth(834 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<834 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<834 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(834 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<834 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<835 + 1024 * 0, true> { int V __attribute__((bitwidth(835 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<835 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<835 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(835 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<835 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<836 + 1024 * 0, true> { int V __attribute__((bitwidth(836 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<836 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<836 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(836 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<836 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<837 + 1024 * 0, true> { int V __attribute__((bitwidth(837 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<837 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<837 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(837 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<837 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<838 + 1024 * 0, true> { int V __attribute__((bitwidth(838 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<838 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<838 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(838 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<838 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<839 + 1024 * 0, true> { int V __attribute__((bitwidth(839 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<839 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<839 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(839 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<839 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<840 + 1024 * 0, true> { int V __attribute__((bitwidth(840 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<840 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<840 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(840 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<840 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<841 + 1024 * 0, true> { int V __attribute__((bitwidth(841 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<841 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<841 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(841 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<841 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<842 + 1024 * 0, true> { int V __attribute__((bitwidth(842 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<842 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<842 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(842 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<842 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<843 + 1024 * 0, true> { int V __attribute__((bitwidth(843 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<843 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<843 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(843 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<843 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<844 + 1024 * 0, true> { int V __attribute__((bitwidth(844 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<844 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<844 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(844 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<844 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<845 + 1024 * 0, true> { int V __attribute__((bitwidth(845 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<845 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<845 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(845 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<845 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<846 + 1024 * 0, true> { int V __attribute__((bitwidth(846 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<846 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<846 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(846 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<846 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<847 + 1024 * 0, true> { int V __attribute__((bitwidth(847 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<847 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<847 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(847 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<847 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<848 + 1024 * 0, true> { int V __attribute__((bitwidth(848 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<848 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<848 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(848 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<848 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<849 + 1024 * 0, true> { int V __attribute__((bitwidth(849 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<849 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<849 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(849 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<849 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<850 + 1024 * 0, true> { int V __attribute__((bitwidth(850 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<850 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<850 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(850 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<850 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<851 + 1024 * 0, true> { int V __attribute__((bitwidth(851 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<851 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<851 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(851 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<851 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<852 + 1024 * 0, true> { int V __attribute__((bitwidth(852 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<852 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<852 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(852 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<852 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<853 + 1024 * 0, true> { int V __attribute__((bitwidth(853 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<853 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<853 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(853 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<853 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<854 + 1024 * 0, true> { int V __attribute__((bitwidth(854 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<854 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<854 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(854 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<854 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<855 + 1024 * 0, true> { int V __attribute__((bitwidth(855 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<855 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<855 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(855 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<855 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<856 + 1024 * 0, true> { int V __attribute__((bitwidth(856 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<856 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<856 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(856 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<856 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<857 + 1024 * 0, true> { int V __attribute__((bitwidth(857 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<857 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<857 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(857 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<857 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<858 + 1024 * 0, true> { int V __attribute__((bitwidth(858 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<858 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<858 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(858 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<858 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<859 + 1024 * 0, true> { int V __attribute__((bitwidth(859 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<859 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<859 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(859 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<859 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<860 + 1024 * 0, true> { int V __attribute__((bitwidth(860 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<860 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<860 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(860 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<860 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<861 + 1024 * 0, true> { int V __attribute__((bitwidth(861 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<861 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<861 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(861 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<861 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<862 + 1024 * 0, true> { int V __attribute__((bitwidth(862 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<862 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<862 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(862 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<862 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<863 + 1024 * 0, true> { int V __attribute__((bitwidth(863 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<863 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<863 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(863 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<863 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<864 + 1024 * 0, true> { int V __attribute__((bitwidth(864 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<864 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<864 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(864 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<864 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<865 + 1024 * 0, true> { int V __attribute__((bitwidth(865 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<865 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<865 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(865 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<865 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<866 + 1024 * 0, true> { int V __attribute__((bitwidth(866 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<866 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<866 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(866 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<866 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<867 + 1024 * 0, true> { int V __attribute__((bitwidth(867 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<867 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<867 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(867 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<867 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<868 + 1024 * 0, true> { int V __attribute__((bitwidth(868 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<868 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<868 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(868 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<868 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<869 + 1024 * 0, true> { int V __attribute__((bitwidth(869 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<869 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<869 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(869 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<869 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<870 + 1024 * 0, true> { int V __attribute__((bitwidth(870 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<870 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<870 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(870 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<870 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<871 + 1024 * 0, true> { int V __attribute__((bitwidth(871 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<871 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<871 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(871 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<871 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<872 + 1024 * 0, true> { int V __attribute__((bitwidth(872 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<872 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<872 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(872 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<872 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<873 + 1024 * 0, true> { int V __attribute__((bitwidth(873 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<873 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<873 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(873 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<873 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<874 + 1024 * 0, true> { int V __attribute__((bitwidth(874 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<874 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<874 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(874 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<874 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<875 + 1024 * 0, true> { int V __attribute__((bitwidth(875 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<875 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<875 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(875 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<875 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<876 + 1024 * 0, true> { int V __attribute__((bitwidth(876 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<876 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<876 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(876 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<876 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<877 + 1024 * 0, true> { int V __attribute__((bitwidth(877 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<877 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<877 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(877 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<877 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<878 + 1024 * 0, true> { int V __attribute__((bitwidth(878 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<878 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<878 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(878 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<878 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<879 + 1024 * 0, true> { int V __attribute__((bitwidth(879 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<879 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<879 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(879 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<879 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<880 + 1024 * 0, true> { int V __attribute__((bitwidth(880 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<880 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<880 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(880 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<880 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<881 + 1024 * 0, true> { int V __attribute__((bitwidth(881 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<881 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<881 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(881 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<881 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<882 + 1024 * 0, true> { int V __attribute__((bitwidth(882 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<882 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<882 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(882 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<882 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<883 + 1024 * 0, true> { int V __attribute__((bitwidth(883 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<883 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<883 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(883 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<883 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<884 + 1024 * 0, true> { int V __attribute__((bitwidth(884 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<884 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<884 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(884 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<884 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<885 + 1024 * 0, true> { int V __attribute__((bitwidth(885 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<885 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<885 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(885 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<885 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<886 + 1024 * 0, true> { int V __attribute__((bitwidth(886 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<886 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<886 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(886 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<886 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<887 + 1024 * 0, true> { int V __attribute__((bitwidth(887 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<887 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<887 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(887 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<887 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<888 + 1024 * 0, true> { int V __attribute__((bitwidth(888 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<888 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<888 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(888 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<888 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<889 + 1024 * 0, true> { int V __attribute__((bitwidth(889 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<889 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<889 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(889 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<889 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<890 + 1024 * 0, true> { int V __attribute__((bitwidth(890 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<890 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<890 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(890 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<890 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<891 + 1024 * 0, true> { int V __attribute__((bitwidth(891 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<891 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<891 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(891 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<891 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<892 + 1024 * 0, true> { int V __attribute__((bitwidth(892 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<892 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<892 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(892 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<892 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<893 + 1024 * 0, true> { int V __attribute__((bitwidth(893 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<893 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<893 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(893 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<893 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<894 + 1024 * 0, true> { int V __attribute__((bitwidth(894 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<894 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<894 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(894 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<894 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<895 + 1024 * 0, true> { int V __attribute__((bitwidth(895 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<895 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<895 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(895 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<895 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<896 + 1024 * 0, true> { int V __attribute__((bitwidth(896 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<896 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<896 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(896 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<896 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<897 + 1024 * 0, true> { int V __attribute__((bitwidth(897 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<897 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<897 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(897 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<897 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<898 + 1024 * 0, true> { int V __attribute__((bitwidth(898 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<898 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<898 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(898 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<898 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<899 + 1024 * 0, true> { int V __attribute__((bitwidth(899 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<899 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<899 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(899 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<899 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<900 + 1024 * 0, true> { int V __attribute__((bitwidth(900 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<900 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<900 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(900 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<900 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<901 + 1024 * 0, true> { int V __attribute__((bitwidth(901 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<901 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<901 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(901 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<901 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<902 + 1024 * 0, true> { int V __attribute__((bitwidth(902 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<902 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<902 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(902 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<902 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<903 + 1024 * 0, true> { int V __attribute__((bitwidth(903 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<903 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<903 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(903 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<903 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<904 + 1024 * 0, true> { int V __attribute__((bitwidth(904 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<904 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<904 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(904 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<904 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<905 + 1024 * 0, true> { int V __attribute__((bitwidth(905 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<905 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<905 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(905 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<905 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<906 + 1024 * 0, true> { int V __attribute__((bitwidth(906 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<906 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<906 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(906 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<906 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<907 + 1024 * 0, true> { int V __attribute__((bitwidth(907 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<907 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<907 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(907 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<907 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<908 + 1024 * 0, true> { int V __attribute__((bitwidth(908 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<908 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<908 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(908 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<908 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<909 + 1024 * 0, true> { int V __attribute__((bitwidth(909 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<909 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<909 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(909 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<909 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<910 + 1024 * 0, true> { int V __attribute__((bitwidth(910 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<910 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<910 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(910 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<910 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<911 + 1024 * 0, true> { int V __attribute__((bitwidth(911 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<911 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<911 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(911 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<911 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<912 + 1024 * 0, true> { int V __attribute__((bitwidth(912 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<912 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<912 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(912 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<912 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<913 + 1024 * 0, true> { int V __attribute__((bitwidth(913 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<913 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<913 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(913 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<913 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<914 + 1024 * 0, true> { int V __attribute__((bitwidth(914 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<914 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<914 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(914 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<914 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<915 + 1024 * 0, true> { int V __attribute__((bitwidth(915 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<915 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<915 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(915 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<915 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<916 + 1024 * 0, true> { int V __attribute__((bitwidth(916 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<916 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<916 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(916 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<916 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<917 + 1024 * 0, true> { int V __attribute__((bitwidth(917 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<917 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<917 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(917 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<917 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<918 + 1024 * 0, true> { int V __attribute__((bitwidth(918 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<918 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<918 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(918 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<918 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<919 + 1024 * 0, true> { int V __attribute__((bitwidth(919 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<919 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<919 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(919 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<919 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<920 + 1024 * 0, true> { int V __attribute__((bitwidth(920 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<920 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<920 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(920 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<920 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<921 + 1024 * 0, true> { int V __attribute__((bitwidth(921 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<921 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<921 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(921 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<921 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<922 + 1024 * 0, true> { int V __attribute__((bitwidth(922 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<922 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<922 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(922 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<922 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<923 + 1024 * 0, true> { int V __attribute__((bitwidth(923 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<923 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<923 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(923 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<923 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<924 + 1024 * 0, true> { int V __attribute__((bitwidth(924 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<924 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<924 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(924 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<924 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<925 + 1024 * 0, true> { int V __attribute__((bitwidth(925 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<925 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<925 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(925 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<925 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<926 + 1024 * 0, true> { int V __attribute__((bitwidth(926 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<926 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<926 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(926 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<926 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<927 + 1024 * 0, true> { int V __attribute__((bitwidth(927 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<927 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<927 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(927 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<927 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<928 + 1024 * 0, true> { int V __attribute__((bitwidth(928 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<928 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<928 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(928 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<928 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<929 + 1024 * 0, true> { int V __attribute__((bitwidth(929 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<929 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<929 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(929 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<929 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<930 + 1024 * 0, true> { int V __attribute__((bitwidth(930 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<930 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<930 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(930 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<930 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<931 + 1024 * 0, true> { int V __attribute__((bitwidth(931 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<931 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<931 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(931 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<931 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<932 + 1024 * 0, true> { int V __attribute__((bitwidth(932 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<932 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<932 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(932 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<932 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<933 + 1024 * 0, true> { int V __attribute__((bitwidth(933 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<933 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<933 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(933 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<933 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<934 + 1024 * 0, true> { int V __attribute__((bitwidth(934 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<934 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<934 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(934 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<934 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<935 + 1024 * 0, true> { int V __attribute__((bitwidth(935 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<935 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<935 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(935 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<935 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<936 + 1024 * 0, true> { int V __attribute__((bitwidth(936 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<936 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<936 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(936 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<936 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<937 + 1024 * 0, true> { int V __attribute__((bitwidth(937 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<937 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<937 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(937 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<937 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<938 + 1024 * 0, true> { int V __attribute__((bitwidth(938 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<938 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<938 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(938 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<938 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<939 + 1024 * 0, true> { int V __attribute__((bitwidth(939 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<939 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<939 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(939 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<939 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<940 + 1024 * 0, true> { int V __attribute__((bitwidth(940 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<940 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<940 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(940 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<940 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<941 + 1024 * 0, true> { int V __attribute__((bitwidth(941 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<941 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<941 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(941 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<941 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<942 + 1024 * 0, true> { int V __attribute__((bitwidth(942 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<942 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<942 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(942 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<942 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<943 + 1024 * 0, true> { int V __attribute__((bitwidth(943 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<943 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<943 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(943 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<943 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<944 + 1024 * 0, true> { int V __attribute__((bitwidth(944 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<944 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<944 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(944 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<944 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<945 + 1024 * 0, true> { int V __attribute__((bitwidth(945 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<945 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<945 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(945 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<945 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<946 + 1024 * 0, true> { int V __attribute__((bitwidth(946 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<946 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<946 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(946 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<946 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<947 + 1024 * 0, true> { int V __attribute__((bitwidth(947 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<947 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<947 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(947 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<947 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<948 + 1024 * 0, true> { int V __attribute__((bitwidth(948 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<948 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<948 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(948 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<948 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<949 + 1024 * 0, true> { int V __attribute__((bitwidth(949 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<949 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<949 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(949 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<949 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<950 + 1024 * 0, true> { int V __attribute__((bitwidth(950 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<950 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<950 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(950 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<950 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<951 + 1024 * 0, true> { int V __attribute__((bitwidth(951 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<951 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<951 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(951 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<951 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<952 + 1024 * 0, true> { int V __attribute__((bitwidth(952 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<952 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<952 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(952 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<952 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<953 + 1024 * 0, true> { int V __attribute__((bitwidth(953 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<953 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<953 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(953 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<953 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<954 + 1024 * 0, true> { int V __attribute__((bitwidth(954 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<954 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<954 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(954 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<954 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<955 + 1024 * 0, true> { int V __attribute__((bitwidth(955 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<955 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<955 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(955 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<955 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<956 + 1024 * 0, true> { int V __attribute__((bitwidth(956 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<956 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<956 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(956 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<956 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<957 + 1024 * 0, true> { int V __attribute__((bitwidth(957 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<957 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<957 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(957 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<957 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<958 + 1024 * 0, true> { int V __attribute__((bitwidth(958 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<958 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<958 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(958 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<958 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<959 + 1024 * 0, true> { int V __attribute__((bitwidth(959 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<959 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<959 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(959 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<959 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<960 + 1024 * 0, true> { int V __attribute__((bitwidth(960 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<960 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<960 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(960 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<960 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<961 + 1024 * 0, true> { int V __attribute__((bitwidth(961 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<961 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<961 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(961 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<961 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<962 + 1024 * 0, true> { int V __attribute__((bitwidth(962 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<962 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<962 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(962 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<962 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<963 + 1024 * 0, true> { int V __attribute__((bitwidth(963 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<963 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<963 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(963 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<963 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<964 + 1024 * 0, true> { int V __attribute__((bitwidth(964 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<964 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<964 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(964 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<964 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<965 + 1024 * 0, true> { int V __attribute__((bitwidth(965 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<965 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<965 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(965 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<965 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<966 + 1024 * 0, true> { int V __attribute__((bitwidth(966 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<966 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<966 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(966 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<966 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<967 + 1024 * 0, true> { int V __attribute__((bitwidth(967 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<967 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<967 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(967 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<967 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<968 + 1024 * 0, true> { int V __attribute__((bitwidth(968 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<968 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<968 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(968 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<968 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<969 + 1024 * 0, true> { int V __attribute__((bitwidth(969 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<969 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<969 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(969 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<969 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<970 + 1024 * 0, true> { int V __attribute__((bitwidth(970 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<970 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<970 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(970 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<970 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<971 + 1024 * 0, true> { int V __attribute__((bitwidth(971 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<971 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<971 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(971 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<971 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<972 + 1024 * 0, true> { int V __attribute__((bitwidth(972 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<972 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<972 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(972 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<972 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<973 + 1024 * 0, true> { int V __attribute__((bitwidth(973 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<973 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<973 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(973 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<973 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<974 + 1024 * 0, true> { int V __attribute__((bitwidth(974 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<974 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<974 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(974 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<974 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<975 + 1024 * 0, true> { int V __attribute__((bitwidth(975 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<975 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<975 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(975 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<975 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<976 + 1024 * 0, true> { int V __attribute__((bitwidth(976 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<976 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<976 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(976 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<976 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<977 + 1024 * 0, true> { int V __attribute__((bitwidth(977 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<977 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<977 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(977 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<977 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<978 + 1024 * 0, true> { int V __attribute__((bitwidth(978 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<978 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<978 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(978 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<978 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<979 + 1024 * 0, true> { int V __attribute__((bitwidth(979 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<979 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<979 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(979 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<979 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<980 + 1024 * 0, true> { int V __attribute__((bitwidth(980 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<980 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<980 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(980 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<980 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<981 + 1024 * 0, true> { int V __attribute__((bitwidth(981 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<981 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<981 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(981 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<981 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<982 + 1024 * 0, true> { int V __attribute__((bitwidth(982 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<982 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<982 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(982 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<982 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<983 + 1024 * 0, true> { int V __attribute__((bitwidth(983 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<983 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<983 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(983 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<983 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<984 + 1024 * 0, true> { int V __attribute__((bitwidth(984 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<984 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<984 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(984 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<984 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<985 + 1024 * 0, true> { int V __attribute__((bitwidth(985 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<985 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<985 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(985 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<985 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<986 + 1024 * 0, true> { int V __attribute__((bitwidth(986 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<986 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<986 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(986 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<986 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<987 + 1024 * 0, true> { int V __attribute__((bitwidth(987 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<987 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<987 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(987 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<987 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<988 + 1024 * 0, true> { int V __attribute__((bitwidth(988 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<988 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<988 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(988 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<988 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<989 + 1024 * 0, true> { int V __attribute__((bitwidth(989 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<989 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<989 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(989 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<989 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<990 + 1024 * 0, true> { int V __attribute__((bitwidth(990 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<990 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<990 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(990 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<990 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<991 + 1024 * 0, true> { int V __attribute__((bitwidth(991 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<991 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<991 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(991 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<991 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<992 + 1024 * 0, true> { int V __attribute__((bitwidth(992 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<992 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<992 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(992 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<992 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<993 + 1024 * 0, true> { int V __attribute__((bitwidth(993 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<993 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<993 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(993 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<993 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<994 + 1024 * 0, true> { int V __attribute__((bitwidth(994 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<994 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<994 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(994 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<994 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<995 + 1024 * 0, true> { int V __attribute__((bitwidth(995 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<995 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<995 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(995 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<995 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<996 + 1024 * 0, true> { int V __attribute__((bitwidth(996 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<996 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<996 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(996 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<996 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<997 + 1024 * 0, true> { int V __attribute__((bitwidth(997 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<997 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<997 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(997 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<997 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<998 + 1024 * 0, true> { int V __attribute__((bitwidth(998 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<998 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<998 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(998 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<998 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<999 + 1024 * 0, true> { int V __attribute__((bitwidth(999 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<999 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<999 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(999 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<999 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1000 + 1024 * 0, true> { int V __attribute__((bitwidth(1000 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1000 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1000 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1000 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1000 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1001 + 1024 * 0, true> { int V __attribute__((bitwidth(1001 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1001 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1001 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1001 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1001 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1002 + 1024 * 0, true> { int V __attribute__((bitwidth(1002 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1002 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1002 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1002 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1002 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1003 + 1024 * 0, true> { int V __attribute__((bitwidth(1003 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1003 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1003 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1003 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1003 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1004 + 1024 * 0, true> { int V __attribute__((bitwidth(1004 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1004 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1004 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1004 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1004 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1005 + 1024 * 0, true> { int V __attribute__((bitwidth(1005 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1005 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1005 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1005 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1005 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1006 + 1024 * 0, true> { int V __attribute__((bitwidth(1006 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1006 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1006 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1006 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1006 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1007 + 1024 * 0, true> { int V __attribute__((bitwidth(1007 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1007 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1007 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1007 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1007 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1008 + 1024 * 0, true> { int V __attribute__((bitwidth(1008 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1008 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1008 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1008 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1008 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1009 + 1024 * 0, true> { int V __attribute__((bitwidth(1009 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1009 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1009 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1009 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1009 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1010 + 1024 * 0, true> { int V __attribute__((bitwidth(1010 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1010 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1010 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1010 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1010 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1011 + 1024 * 0, true> { int V __attribute__((bitwidth(1011 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1011 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1011 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1011 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1011 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1012 + 1024 * 0, true> { int V __attribute__((bitwidth(1012 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1012 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1012 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1012 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1012 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1013 + 1024 * 0, true> { int V __attribute__((bitwidth(1013 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1013 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1013 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1013 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1013 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1014 + 1024 * 0, true> { int V __attribute__((bitwidth(1014 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1014 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1014 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1014 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1014 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1015 + 1024 * 0, true> { int V __attribute__((bitwidth(1015 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1015 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1015 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1015 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1015 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1016 + 1024 * 0, true> { int V __attribute__((bitwidth(1016 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1016 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1016 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1016 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1016 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1017 + 1024 * 0, true> { int V __attribute__((bitwidth(1017 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1017 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1017 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1017 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1017 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1018 + 1024 * 0, true> { int V __attribute__((bitwidth(1018 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1018 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1018 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1018 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1018 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1019 + 1024 * 0, true> { int V __attribute__((bitwidth(1019 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1019 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1019 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1019 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1019 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1020 + 1024 * 0, true> { int V __attribute__((bitwidth(1020 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1020 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1020 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1020 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1020 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1021 + 1024 * 0, true> { int V __attribute__((bitwidth(1021 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1021 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1021 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1021 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1021 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1022 + 1024 * 0, true> { int V __attribute__((bitwidth(1022 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1022 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1022 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1022 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1022 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1023 + 1024 * 0, true> { int V __attribute__((bitwidth(1023 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1023 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1023 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1023 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1023 + 1024 * 0, false>(){}; };
template <> struct ssdm_int<1024 + 1024 * 0, true> { int V __attribute__((bitwidth(1024 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1024 + 1024 * 0, true>(){}; }; template <> struct ssdm_int<1024 + 1024 * 0, false> { unsigned int V __attribute__((bitwidth(1024 + 1024 * 0))); inline __attribute__((always_inline)) ssdm_int<1024 + 1024 * 0, false>(){}; };
# 239 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h" 2
# 562 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h"
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/etc/autopilot_ssdm_bits.h" 1
# 563 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h" 2
extern "C" void _ssdm_string2bits(...);
# 574 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h"
static inline unsigned char guess_radix(const char* s) {
unsigned char rd = 10;
const char* p = s;
if (p[0] == '-' || p[0] == '+') ++p;
if (p[0] == '0') {
if (p[1] == 'b' || p[1] == 'B') {
rd = 2;
} else if (p[1] == 'o' || p[1] == 'O') {
rd = 8;
} else if (p[1] == 'x' || p[1] == 'X') {
rd = 16;
} else if (p[1] == 'd' || p[1] == 'D') {
rd = 10;
}
}
return rd;
}
typedef __fp16 half;
# 691 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_common.h"
inline __attribute__((always_inline)) ap_ulong doubleToRawBits(double pf) {
union {
ap_ulong __L;
double __D;
} LD;
LD.__D = pf;
return LD.__L;
}
inline __attribute__((always_inline)) unsigned int floatToRawBits(float pf) {
union {
unsigned int __L;
float __D;
} LD;
LD.__D = pf;
return LD.__L;
}
inline __attribute__((always_inline)) unsigned short halfToRawBits(half pf) {
union {
unsigned short __L;
half __D;
} LD;
LD.__D = pf;
return LD.__L;
}
inline __attribute__((always_inline)) double rawBitsToDouble(ap_ulong pi) {
union {
ap_ulong __L;
double __D;
} LD;
LD.__L = pi;
return LD.__D;
}
inline __attribute__((always_inline)) float rawBitsToFloat(unsigned long pi) {
union {
unsigned int __L;
float __D;
} LD;
LD.__L = pi;
return LD.__D;
}
inline __attribute__((always_inline)) half rawBitsToHalf(unsigned short pi) {
union {
unsigned short __L;
half __D;
} LD;
LD.__L = pi;
return LD.__D;
}
# 55 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int.h" 2
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h" 1
# 72 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstddef" 1 3
# 41 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstddef" 3
# 41 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstddef" 3
# 1 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/clang/bin/../lib/clang/3.1/include/stddef.h" 1 3
# 44 "/opt/vivado2018/Vivado/2018.3/lnx64/tools/gcc/lib/gcc/x86_64-unknown-linux-gnu/4.6.3/../../../../include/c++/4.6.3/cstddef" 2 3
# 73 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h" 2
# 82 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_N, bool _AP_S>
struct retval;
template <int _AP_N>
struct retval<_AP_N, true> {
typedef ap_slong Type;
};
template <int _AP_N>
struct retval<_AP_N, false> {
typedef ap_ulong Type;
};
template <>
struct retval<1, true> {
typedef signed char Type;
};
template <>
struct retval<1, false> {
typedef unsigned char Type;
};
template <>
struct retval<2, true> {
typedef short Type;
};
template <>
struct retval<2, false> {
typedef unsigned short Type;
};
template <>
struct retval<3, true> {
typedef long Type;
};
template <>
struct retval<3, false> {
typedef unsigned long Type;
};
template <>
struct retval<4, true> {
typedef long Type;
};
template <>
struct retval<4, false> {
typedef unsigned long Type;
};
template <int _AP_W2, bool _AP_S2>
struct _ap_int_factory;
template <int _AP_W2>
struct _ap_int_factory<_AP_W2,true> { typedef ap_int<_AP_W2> type; };
template <int _AP_W2>
struct _ap_int_factory<_AP_W2,false> { typedef ap_uint<_AP_W2> type; };
template <int _AP_W, bool _AP_S>
struct ap_int_base : public ssdm_int<_AP_W, _AP_S> {
public:
typedef ssdm_int<_AP_W, _AP_S> Base;
typedef typename retval<(((_AP_W + 7) / 8) > (8) ? ((_AP_W + 7) / 8) : (8)), _AP_S>::Type RetType;
static const int width = _AP_W;
template <int _AP_W2, bool _AP_S2>
struct RType {
enum {
mult_w = _AP_W + _AP_W2,
mult_s = _AP_S || _AP_S2,
plus_w =
((_AP_W + (_AP_S2 && !_AP_S)) > (_AP_W2 + (_AP_S && !_AP_S2)) ? (_AP_W + (_AP_S2 && !_AP_S)) : (_AP_W2 + (_AP_S && !_AP_S2))) + 1,
plus_s = _AP_S || _AP_S2,
minus_w =
((_AP_W + (_AP_S2 && !_AP_S)) > (_AP_W2 + (_AP_S && !_AP_S2)) ? (_AP_W + (_AP_S2 && !_AP_S)) : (_AP_W2 + (_AP_S && !_AP_S2))) + 1,
minus_s = true,
div_w = _AP_W + _AP_S2,
div_s = _AP_S || _AP_S2,
mod_w = ((_AP_W) < (_AP_W2 + (!_AP_S2 && _AP_S)) ? (_AP_W) : (_AP_W2 + (!_AP_S2 && _AP_S))),
mod_s = _AP_S,
logic_w = ((_AP_W + (_AP_S2 && !_AP_S)) > (_AP_W2 + (_AP_S && !_AP_S2)) ? (_AP_W + (_AP_S2 && !_AP_S)) : (_AP_W2 + (_AP_S && !_AP_S2))),
logic_s = _AP_S || _AP_S2
};
typedef ap_int_base<mult_w, mult_s> mult_base;
typedef ap_int_base<plus_w, plus_s> plus_base;
typedef ap_int_base<minus_w, minus_s> minus_base;
typedef ap_int_base<logic_w, logic_s> logic_base;
typedef ap_int_base<div_w, div_s> div_base;
typedef ap_int_base<mod_w, mod_s> mod_base;
typedef ap_int_base<_AP_W, _AP_S> arg1_base;
typedef typename _ap_int_factory<mult_w, mult_s>::type mult;
typedef typename _ap_int_factory<plus_w, plus_s>::type plus;
typedef typename _ap_int_factory<minus_w, minus_s>::type minus;
typedef typename _ap_int_factory<logic_w, logic_s>::type logic;
typedef typename _ap_int_factory<div_w, div_s>::type div;
typedef typename _ap_int_factory<mod_w, mod_s>::type mod;
typedef typename _ap_int_factory<_AP_W, _AP_S>::type arg1;
typedef bool reduce;
};
inline __attribute__((always_inline)) ap_int_base() {
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_int_base<_AP_W2, _AP_S2>& op) {
Base::V = op.V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const volatile ap_int_base<_AP_W2, _AP_S2>& op) {
Base::V = op.V;
}
# 239 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
inline __attribute__((always_inline)) ap_int_base(const bool op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(const char op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(const signed char op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(const unsigned char op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(const short op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(const unsigned short op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(const int op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(const unsigned int op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(const long op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(const unsigned long op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(const ap_slong op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(const ap_ulong op) { Base::V = op; }
inline __attribute__((always_inline)) ap_int_base(half op) {
ap_int_base<_AP_W, _AP_S> t((float)op);
Base::V = t.V;
}
inline __attribute__((always_inline)) ap_int_base(float op) {
const int BITS = 23 + 8 + 1;
ap_int_base<BITS, false> reg;
reg.V = floatToRawBits(op);
bool is_neg = ({ typeof(reg.V) __Val2__ = reg.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), BITS - 1); __Result__; });
ap_int_base<8 + 1, true> exp = 0;
exp.V = ({ typename _ap_type::remove_const<typeof(reg.V)>::type __Result__ = 0; typeof(reg.V) __Val2__ = reg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 23, BITS - 2); __Result__; });
exp = exp - ((1L << (8 - 1L)) - 1L);
ap_int_base<23 + 2, true> man;
man.V = ({ typename _ap_type::remove_const<typeof(reg.V)>::type __Result__ = 0; typeof(reg.V) __Val2__ = reg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, 23 - 1); __Result__; });
(static_cast<void>(0));
man.V = ({ typename _ap_type::remove_const<typeof(man.V)>::type __Result__ = 0; typeof(man.V) __Val2__ = man.V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 23, 23); __Result__; });
if ((reg.V & 0x7ffffffful) == 0) {
Base::V = 0;
} else {
int sh_amt = 23 - exp.V;
if (sh_amt == 0) {
Base::V = man.V;
} else if (sh_amt > 0) {
if (sh_amt < 23 + 2) {
Base::V = man.V >> sh_amt;
} else {
if (is_neg)
Base::V = -1;
else
Base::V = 0;
}
} else {
sh_amt = -sh_amt;
if (sh_amt < _AP_W) {
Base::V = man.V;
Base::V <<= sh_amt;
} else {
Base::V = 0;
}
}
}
if (is_neg) *this = -(*this);
}
inline __attribute__((always_inline)) ap_int_base(double op) {
const int BITS = 52 + 11 + 1;
ap_int_base<BITS, false> reg;
reg.V = doubleToRawBits(op);
bool is_neg = ({ typeof(reg.V) __Val2__ = reg.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), BITS - 1); __Result__; });
ap_int_base<11 + 1, true> exp = 0;
exp.V = ({ typename _ap_type::remove_const<typeof(reg.V)>::type __Result__ = 0; typeof(reg.V) __Val2__ = reg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 52, BITS - 2); __Result__; });
exp = exp - ((1L << (11 - 1L)) - 1L);
ap_int_base<52 + 2, true> man;
man.V = ({ typename _ap_type::remove_const<typeof(reg.V)>::type __Result__ = 0; typeof(reg.V) __Val2__ = reg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, 52 - 1); __Result__; });
(static_cast<void>(0));
man.V = ({ typename _ap_type::remove_const<typeof(man.V)>::type __Result__ = 0; typeof(man.V) __Val2__ = man.V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 52, 52); __Result__; });
if ((reg.V & 0x7fffffffffffffffull) == 0) {
Base::V = 0;
} else {
int sh_amt = 52 - exp.V;
if (sh_amt == 0) {
Base::V = man.V;
} else if (sh_amt > 0) {
if (sh_amt < 52 + 2) {
Base::V = man.V >> sh_amt;
} else {
if (is_neg)
Base::V = -1;
else
Base::V = 0;
}
} else {
sh_amt = -sh_amt;
if (sh_amt < _AP_W) {
Base::V = man.V;
Base::V <<= sh_amt;
} else {
Base::V = 0;
}
}
}
if (is_neg) *this = -(*this);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_range_ref<_AP_W2, _AP_S2>& ref) {
Base::V = (ref.get()).V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base(const ap_bit_ref<_AP_W2, _AP_S2>& ref) {
Base::V = ref.operator bool();
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& ref) {
const ap_int_base<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>::_AP_WR,
false>
tmp = ref.get();
Base::V = tmp.V;
}
# 393 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
inline __attribute__((always_inline)) ap_int_base(const char* s) {
typeof(Base::V) t;
_ssdm_string2bits((void*)(&t), (const char*)(s), 10, _AP_W, _AP_S,
AP_TRN, AP_WRAP, 0, true);
Base::V = t;
}
inline __attribute__((always_inline)) ap_int_base(const char* s, signed char rd) {
typeof(Base::V) t;
_ssdm_string2bits((void*)(&t), (const char*)(s), rd, _AP_W, _AP_S,
AP_TRN, AP_WRAP, 0, true);
Base::V = t;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
Base::V = (val.get()).V;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
Base::V = val.operator bool();
}
inline __attribute__((always_inline)) ap_int_base read() volatile {
ap_int_base ret;
ret.V = Base::V;
return ret;
}
inline __attribute__((always_inline)) void write(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator=(
const volatile ap_int_base<_AP_W2, _AP_S2>& op2) volatile {
Base::V = op2.V;
}
inline __attribute__((always_inline)) void operator=(
const volatile ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) void operator=(const ap_int_base<_AP_W2, _AP_S2>& op2) volatile {
Base::V = op2.V;
}
inline __attribute__((always_inline)) void operator=(const ap_int_base<_AP_W, _AP_S>& op2) volatile {
Base::V = op2.V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator=(
const volatile ap_int_base<_AP_W2, _AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator=(const ap_int_base<_AP_W2, _AP_S2>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator=(const volatile ap_int_base<_AP_W, _AP_S>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator=(const ap_int_base<_AP_W, _AP_S>& op2) {
Base::V = op2.V;
return *this;
}
# 484 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
inline __attribute__((always_inline)) ap_int_base& operator=(bool op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator=(char op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator=(signed char op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator=(unsigned char op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator=(short op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator=(unsigned short op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator=(int op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator=(unsigned int op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator=(long op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator=(unsigned long op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator=(ap_slong op) { Base::V = op; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator=(ap_ulong op) { Base::V = op; return *this; }
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator=(const ap_bit_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (bool)op2;
return *this;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int_base& operator=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
Base::V = (ap_int_base<_AP_W2, false>(op2)).V;
return *this;
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base& operator=(
const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op2) {
Base::V = op2.get().V;
return *this;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator=(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = op.to_ap_int_base().V;
return *this;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator=(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = (bool)op;
return *this;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int_base& operator=(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
Base::V = ((const ap_int_base<_AP_W2, false>)(op)).V;
return *this;
}
inline __attribute__((always_inline)) operator RetType() const { return (RetType)(Base::V); }
inline __attribute__((always_inline)) bool to_bool() const { return (bool)(Base::V); }
inline __attribute__((always_inline)) char to_char() const { return (char)(Base::V); }
inline __attribute__((always_inline)) signed char to_schar() const { return (signed char)(Base::V); }
inline __attribute__((always_inline)) unsigned char to_uchar() const { return (unsigned char)(Base::V); }
inline __attribute__((always_inline)) short to_short() const { return (short)(Base::V); }
inline __attribute__((always_inline)) unsigned short to_ushort() const { return (unsigned short)(Base::V); }
inline __attribute__((always_inline)) int to_int() const { return (int)(Base::V); }
inline __attribute__((always_inline)) unsigned to_uint() const { return (unsigned)(Base::V); }
inline __attribute__((always_inline)) long to_long() const { return (long)(Base::V); }
inline __attribute__((always_inline)) unsigned long to_ulong() const { return (unsigned long)(Base::V); }
inline __attribute__((always_inline)) ap_slong to_int64() const { return (ap_slong)(Base::V); }
inline __attribute__((always_inline)) ap_ulong to_uint64() const { return (ap_ulong)(Base::V); }
inline __attribute__((always_inline)) float to_float() const { return (float)(Base::V); }
inline __attribute__((always_inline)) double to_double() const { return (double)(Base::V); }
# 588 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
inline __attribute__((always_inline)) int length() const volatile { return _AP_W; }
inline __attribute__((always_inline)) bool iszero() const { return Base::V == 0; }
inline __attribute__((always_inline)) bool is_zero() const { return Base::V == 0; }
inline __attribute__((always_inline)) bool sign() const {
if (_AP_S &&
({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - 1); __Result__; }))
return true;
else
return false;
}
inline __attribute__((always_inline)) void clear(int i) {
;
Base::V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(0) __Repl2__ = !!0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
inline __attribute__((always_inline)) void invert(int i) {
;
bool val = ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), i); __Result__; });
if (val)
Base::V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(0) __Repl2__ = !!0; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
else
Base::V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
inline __attribute__((always_inline)) bool test(int i) const {
;
return ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), i); __Result__; });
}
inline __attribute__((always_inline)) ap_int_base& get() { return *this; }
inline __attribute__((always_inline)) void set(int i) {
;
Base::V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
inline __attribute__((always_inline)) void set(int i, bool v) {
;
Base::V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(v) __Repl2__ = !!v; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
inline __attribute__((always_inline)) ap_int_base& lrotate(int n) {
;
typeof(Base::V) l_p = Base::V << n;
typeof(Base::V) r_p = Base::V >> (_AP_W - n);
Base::V = l_p | r_p;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& rrotate(int n) {
;
typeof(Base::V) l_p = Base::V << (_AP_W - n);
typeof(Base::V) r_p = Base::V >> n;
Base::V = l_p | r_p;
return *this;
}
inline __attribute__((always_inline)) ap_int_base& reverse() {
Base::V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, 0); __Result__; });
return *this;
}
inline __attribute__((always_inline)) void set_bit(int i, bool v) {
Base::V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(v) __Repl2__ = !!v; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), i, i); __Result__; });
}
inline __attribute__((always_inline)) bool get_bit(int i) const {
return (bool)({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), i); __Result__; });
}
inline __attribute__((always_inline)) void b_not() { Base::V = ~Base::V; }
# 701 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator *=(const ap_int_base<_AP_W2, _AP_S2>& op2) { Base::V *= op2.V; return *this; }
template <int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator +=(const ap_int_base<_AP_W2, _AP_S2>& op2) { Base::V += op2.V; return *this; }
template <int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator -=(const ap_int_base<_AP_W2, _AP_S2>& op2) { Base::V -= op2.V; return *this; }
template <int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator /=(const ap_int_base<_AP_W2, _AP_S2>& op2) { Base::V /= op2.V; return *this; }
template <int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator %=(const ap_int_base<_AP_W2, _AP_S2>& op2) { Base::V %= op2.V; return *this; }
# 719 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator &=(const ap_int_base<_AP_W2, _AP_S2>& op2) { (static_cast<void>(0)); Base::V &= op2.V; return *this; }
template <int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator |=(const ap_int_base<_AP_W2, _AP_S2>& op2) { (static_cast<void>(0)); Base::V |= op2.V; return *this; }
template <int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base& operator ^=(const ap_int_base<_AP_W2, _AP_S2>& op2) { (static_cast<void>(0)); Base::V ^= op2.V; return *this; }
inline __attribute__((always_inline)) ap_int_base& operator++() {
operator+=((ap_int_base<1, false>)1);
return *this;
}
inline __attribute__((always_inline)) ap_int_base& operator--() {
operator-=((ap_int_base<1, false>)1);
return *this;
}
inline __attribute__((always_inline)) const typename RType<_AP_W,_AP_S>::arg1 operator++(int) {
ap_int_base t = *this;
operator+=((ap_int_base<1, false>)1);
return t;
}
inline __attribute__((always_inline)) const typename RType<_AP_W,_AP_S>::arg1 operator--(int) {
ap_int_base t = *this;
operator-=((ap_int_base<1, false>)1);
return t;
}
inline __attribute__((always_inline)) typename RType<_AP_W,_AP_S>::arg1 operator+() const { return *this; }
inline __attribute__((always_inline)) typename RType<1, false>::minus operator-() const {
return ap_int_base<1, false>(0) - *this;
}
inline __attribute__((always_inline)) bool operator!() const { return Base::V == 0; }
inline __attribute__((always_inline)) typename RType<_AP_W,_AP_S>::arg1 operator~() const {
ap_int_base<_AP_W, _AP_S> r;
r.V = ~Base::V;
return r;
}
template <int _AP_W2>
inline __attribute__((always_inline)) typename RType<_AP_W,_AP_S>::arg1 operator<<(const ap_int_base<_AP_W2, true>& op2) const {
bool isNeg = ({ typeof(op2.V) __Val2__ = op2.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W2 - 1); __Result__; });
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator>>(sh);
} else
return operator<<(sh);
}
template <int _AP_W2>
inline __attribute__((always_inline)) typename RType<_AP_W,_AP_S>::arg1 operator<<(const ap_int_base<_AP_W2, false>& op2) const {
ap_int_base r;
r.V = Base::V << op2.to_uint();
return r;
}
template <int _AP_W2>
inline __attribute__((always_inline)) typename RType<_AP_W,_AP_S>::arg1 operator>>(const ap_int_base<_AP_W2, true>& op2) const {
bool isNeg = ({ typeof(op2.V) __Val2__ = op2.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W2 - 1); __Result__; });
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator<<(sh);
}
return operator>>(sh);
}
template <int _AP_W2>
inline __attribute__((always_inline)) typename RType<_AP_W,_AP_S>::arg1 operator>>(const ap_int_base<_AP_W2, false>& op2) const {
ap_int_base r;
r.V = Base::V >> op2.to_uint();
return r;
}
# 830 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator<<=(const ap_int_base<_AP_W2, true>& op2) {
bool isNeg = ({ typeof(op2.V) __Val2__ = op2.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W2 - 1); __Result__; });
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator>>=(sh);
} else
return operator<<=(sh);
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator<<=(const ap_int_base<_AP_W2, false>& op2) {
Base::V <<= op2.to_uint();
return *this;
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator>>=(const ap_int_base<_AP_W2, true>& op2) {
bool isNeg = ({ typeof(op2.V) __Val2__ = op2.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W2 - 1); __Result__; });
ap_int_base<_AP_W2, false> sh = op2;
if (isNeg) {
sh = -op2;
return operator<<=(sh);
}
return operator>>=(sh);
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_int_base& operator>>=(const ap_int_base<_AP_W2, false>& op2) {
Base::V >>= op2.to_uint();
return *this;
}
# 879 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator==(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
return Base::V == op2.V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator!=(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
return !(Base::V == op2.V);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator<(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
return Base::V < op2.V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator>=(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
return Base::V >= op2.V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator>(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
return Base::V > op2.V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator<=(const ap_int_base<_AP_W2, _AP_S2>& op2) const {
return Base::V <= op2.V;
}
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) {
(static_cast<void>(0));
(static_cast<void>(0));
return ap_range_ref<_AP_W, _AP_S>(this, Hi, Lo);
}
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S> range(int Hi, int Lo) const {
(static_cast<void>(0));
(static_cast<void>(0));
return ap_range_ref<_AP_W, _AP_S>(const_cast<ap_int_base*>(this), Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S> range(
const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
const ap_int_base<_AP_W3, _AP_S3>& LoIdx) {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S> range(
const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
const ap_int_base<_AP_W3, _AP_S3>& LoIdx) const {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S> range() {
return this->range(_AP_W - 1, 0);
}
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S> range() const {
return this->range(_AP_W - 1, 0);
}
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) {
return this->range(Hi, Lo);
}
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S> operator()(int Hi, int Lo) const {
return this->range(Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S> operator()(
const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
const ap_int_base<_AP_W3, _AP_S3>& LoIdx) {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S> operator()(
const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
const ap_int_base<_AP_W3, _AP_S3>& LoIdx) const {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
# 988 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
inline __attribute__((always_inline)) ap_bit_ref<_AP_W, _AP_S> operator[](int index) {
;
;
ap_bit_ref<_AP_W, _AP_S> bvh(this, index);
return bvh;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W, _AP_S> operator[](
const ap_int_base<_AP_W2, _AP_S2>& index) {
;
;
ap_bit_ref<_AP_W, _AP_S> bvh(this, index.to_int());
return bvh;
}
inline __attribute__((always_inline)) bool operator[](int index) const {
;
;
ap_bit_ref<_AP_W, _AP_S> br(this, index);
return br.to_bool();
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator[](const ap_int_base<_AP_W2, _AP_S2>& index) const {
;
ap_bit_ref<_AP_W, _AP_S> br(this, index.to_int());
return br.to_bool();
}
inline __attribute__((always_inline)) ap_bit_ref<_AP_W, _AP_S> bit(int index) {
;
;
ap_bit_ref<_AP_W, _AP_S> bvh(this, index);
return bvh;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref<_AP_W, _AP_S> bit(
const ap_int_base<_AP_W2, _AP_S2>& index) {
;
;
ap_bit_ref<_AP_W, _AP_S> bvh(this, index.to_int());
return bvh;
}
inline __attribute__((always_inline)) bool bit(int index) const {
;
;
ap_bit_ref<_AP_W, _AP_S> br(this, index);
return br.to_bool();
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool bit(const ap_int_base<_AP_W2, _AP_S2>& index) const {
return bit(index.to_int());
}
# 1055 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
inline __attribute__((always_inline)) int countLeadingZeros() {
if (_AP_W <= 32) {
ap_int_base<32, false> t(-1UL), x;
x.V = ({ typename _ap_type::remove_const<typeof(this->V)>::type __Result__ = 0; typeof(this->V) __Val2__ = this->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, 0); __Result__; });
t.V = ({ typename _ap_type::remove_const<typeof(t.V)>::type __Result__ = 0; typeof(t.V) __Val2__ = t.V; typeof(x.V) __Repl2__ = x.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, _AP_W - 1); __Result__; });
return __builtin_ctz(t.V);
} else if (_AP_W <= 64) {
ap_int_base<64, false> t(-1ULL);
ap_int_base<64, false> x;
x.V = ({ typename _ap_type::remove_const<typeof(this->V)>::type __Result__ = 0; typeof(this->V) __Val2__ = this->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - 1, 0); __Result__; });
t.V = ({ typename _ap_type::remove_const<typeof(t.V)>::type __Result__ = 0; typeof(t.V) __Val2__ = t.V; typeof(x.V) __Repl2__ = x.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, _AP_W - 1); __Result__; });
return __builtin_ctzll(t.V);
} else {
enum { __N = (_AP_W + 63) / 64 };
int NZeros = 0;
int i = 0;
bool hitNonZero = false;
for (i = 0; i < __N - 1; ++i) {
ap_int_base<64, false> t;
t.V = ({ typename _ap_type::remove_const<typeof(this->V)>::type __Result__ = 0; typeof(this->V) __Val2__ = this->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - i * 64 - 64, _AP_W - i * 64 - 1); __Result__; });
NZeros += hitNonZero ? 0 : __builtin_clzll(t.V);
hitNonZero |= (t.V != 0);
}
if (!hitNonZero) {
ap_int_base<64, false> t(-1ULL);
enum { REST = (_AP_W - 1) % 64 };
ap_int_base<64, false> x;
x.V = ({ typename _ap_type::remove_const<typeof(this->V)>::type __Result__ = 0; typeof(this->V) __Val2__ = this->V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, REST); __Result__; });
t.V = ({ typename _ap_type::remove_const<typeof(t.V)>::type __Result__ = 0; typeof(t.V) __Val2__ = t.V; typeof(x.V) __Repl2__ = x.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 63 - REST, 63); __Result__; });
NZeros += __builtin_clzll(t.V);
}
return NZeros;
}
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
concat(const ap_int_base<_AP_W2, _AP_S2>& a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(
const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
concat(ap_int_base<_AP_W2, _AP_S2>& a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator,(const ap_range_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(
const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
const_cast<ap_range_ref<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator,(ap_range_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(const ap_int_base<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(
*this, const_cast<ap_int_base<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(ap_int_base<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(
const_cast<ap_int_base<_AP_W, _AP_S>&>(*this), a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(const ap_int_base<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(
const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
const_cast<ap_int_base<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_int_base, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(ap_int_base<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator,(const ap_bit_ref<_AP_W2, _AP_S2> &a2) const {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >(
const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
const_cast<ap_bit_ref<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator,(ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, 1, ap_bit_ref<_AP_W2, _AP_S2> >(
*this, a2);
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_int_base, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator,(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(
const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>&>(a2));
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_int_base, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator,(ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_int_base, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this,
a2);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<
_AP_W, ap_int_base, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator,(const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>
&a2) const {
return ap_concat_ref<
_AP_W, ap_int_base, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(
const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
const_cast<
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<
_AP_W, ap_int_base, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator,(af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> &a2) {
return ap_concat_ref<
_AP_W, ap_int_base, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
a2);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator,(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>
&a2) const {
return ap_concat_ref<
_AP_W, ap_int_base, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(
const_cast<ap_int_base<_AP_W, _AP_S>&>(*this),
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(
a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_int_base, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator,(
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> &a2) {
return ap_concat_ref<
_AP_W, ap_int_base, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this, a2);
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2 + _AP_W3) > (_AP_W) ? (_AP_W2 + _AP_W3) : (_AP_W)), _AP_S> operator&(
const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this & a2.get();
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2 + _AP_W3) > (_AP_W) ? (_AP_W2 + _AP_W3) : (_AP_W)), _AP_S> operator|(
const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this | a2.get();
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int_base<((_AP_W2 + _AP_W3) > (_AP_W) ? (_AP_W2 + _AP_W3) : (_AP_W)), _AP_S> operator^(
const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& a2) {
return *this ^ a2.get();
}
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
Base::V = val.V;
}
inline __attribute__((always_inline)) bool and_reduce() const { return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_and_reduce((void*)(&__what2__)); }); }
inline __attribute__((always_inline)) bool nand_reduce() const { return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_nand_reduce((void*)(&__what2__)); }); }
inline __attribute__((always_inline)) bool or_reduce() const { return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); }); }
inline __attribute__((always_inline)) bool nor_reduce() const { return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_or_reduce((void*)(&__what2__)); })); }
inline __attribute__((always_inline)) bool xor_reduce() const { return ({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); }); }
inline __attribute__((always_inline)) bool xnor_reduce() const {
return !(({ typeof(Base::V) __what2__ = Base::V; __builtin_bit_xor_reduce((void*)(&__what2__)); }));
}
# 1295 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
inline __attribute__((always_inline)) char* to_string(signed char rd = 2, bool sign = _AP_S) const {
return 0;
}
};
# 1354 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, _AP_S2>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: mult_base lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: mult_base rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: mult_base ret; ret.V = lhs.V * rhs.V; return ret; }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, _AP_S2>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: plus_base lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: plus_base rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: plus_base ret; ret.V = lhs.V + rhs.V; return ret; }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, _AP_S2>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: minus_base lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: minus_base rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: minus_base ret; ret.V = lhs.V - rhs.V; return ret; }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, _AP_S2>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: logic_base lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: logic_base rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: logic_base ret; ret.V = lhs.V & rhs.V; return ret; }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, _AP_S2>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: logic_base lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: logic_base rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: logic_base ret; ret.V = lhs.V | rhs.V; return ret; }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, _AP_S2>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: logic_base lhs(op); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: logic_base rhs(op2); typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: logic_base ret; ret.V = lhs.V ^ rhs.V; return ret; }
# 1373 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, _AP_S2>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: div_base ret; ret.V = op.V / op2.V; return ret; }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W2, _AP_S2>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { typename ap_int_base<_AP_W, _AP_S>::template RType< _AP_W2, _AP_S2>:: mod_base ret; ret.V = op.V % op2.V; return ret; }
# 1401 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator +(PTR_TYPE* i_op, const ap_int_base<_AP_W, _AP_S>& op) { std::ptrdiff_t op2 = op.to_long(); return i_op + op2; } template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator +(const ap_int_base<_AP_W, _AP_S>& op, PTR_TYPE* i_op) { std::ptrdiff_t op2 = op.to_long(); return op2 + i_op; }
template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator -(PTR_TYPE* i_op, const ap_int_base<_AP_W, _AP_S>& op) { std::ptrdiff_t op2 = op.to_long(); return i_op - op2; } template <typename PTR_TYPE, int _AP_W, bool _AP_S> inline __attribute__((always_inline)) PTR_TYPE* operator -(const ap_int_base<_AP_W, _AP_S>& op, PTR_TYPE* i_op) { std::ptrdiff_t op2 = op.to_long(); return op2 - i_op; }
# 1429 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator *(half i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op * op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator *(const ap_int_base<_AP_W, _AP_S>& op, half i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 * i_op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator /(half i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op / op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator /(const ap_int_base<_AP_W, _AP_S>& op, half i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 / i_op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator +(half i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op + op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator +(const ap_int_base<_AP_W, _AP_S>& op, half i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 + i_op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator -(half i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op - op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) half operator -(const ap_int_base<_AP_W, _AP_S>& op, half i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 - i_op; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator *(float i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op * op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator *(const ap_int_base<_AP_W, _AP_S>& op, float i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 * i_op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator /(float i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op / op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator /(const ap_int_base<_AP_W, _AP_S>& op, float i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 / i_op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator +(float i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op + op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator +(const ap_int_base<_AP_W, _AP_S>& op, float i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 + i_op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator -(float i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op - op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) float operator -(const ap_int_base<_AP_W, _AP_S>& op, float i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 - i_op; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator *(double i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op * op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator *(const ap_int_base<_AP_W, _AP_S>& op, double i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 * i_op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator /(double i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op / op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator /(const ap_int_base<_AP_W, _AP_S>& op, double i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 / i_op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator +(double i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op + op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator +(const ap_int_base<_AP_W, _AP_S>& op, double i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 + i_op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator -(double i_op, const ap_int_base<_AP_W, _AP_S>& op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return i_op - op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) double operator -(const ap_int_base<_AP_W, _AP_S>& op, double i_op) { typename ap_int_base<_AP_W, _AP_S>::RetType op2 = op; return op2 - i_op; }
# 1463 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::mult operator *(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, bool i_op) { return op * ap_int_base<1, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::plus operator +(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, bool i_op) { return op + ap_int_base<1, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::minus operator -(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, bool i_op) { return op - ap_int_base<1, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::div operator /(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, bool i_op) { return op / ap_int_base<1, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::mod operator %(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, bool i_op) { return op % ap_int_base<1, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::logic operator &(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, bool i_op) { return op & ap_int_base<1, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::logic operator |(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, bool i_op) { return op | ap_int_base<1, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::logic operator ^(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<1, false>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, bool i_op) { return op ^ ap_int_base<1, false>(i_op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::mult operator *(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, char i_op) { return op * ap_int_base<8, CHAR_IS_SIGNED>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::plus operator +(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, char i_op) { return op + ap_int_base<8, CHAR_IS_SIGNED>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::minus operator -(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, char i_op) { return op - ap_int_base<8, CHAR_IS_SIGNED>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::div operator /(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, char i_op) { return op / ap_int_base<8, CHAR_IS_SIGNED>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::mod operator %(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, char i_op) { return op % ap_int_base<8, CHAR_IS_SIGNED>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::logic operator &(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, char i_op) { return op & ap_int_base<8, CHAR_IS_SIGNED>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::logic operator |(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, char i_op) { return op | ap_int_base<8, CHAR_IS_SIGNED>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::logic operator ^(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, CHAR_IS_SIGNED>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, char i_op) { return op ^ ap_int_base<8, CHAR_IS_SIGNED>(i_op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::mult operator *(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, signed char i_op) { return op * ap_int_base<8, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::plus operator +(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, signed char i_op) { return op + ap_int_base<8, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::minus operator -(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, signed char i_op) { return op - ap_int_base<8, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::div operator /(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, signed char i_op) { return op / ap_int_base<8, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::mod operator %(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, signed char i_op) { return op % ap_int_base<8, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::logic operator &(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, signed char i_op) { return op & ap_int_base<8, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::logic operator |(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, signed char i_op) { return op | ap_int_base<8, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::logic operator ^(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, true>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, signed char i_op) { return op ^ ap_int_base<8, true>(i_op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::mult operator *(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, unsigned char i_op) { return op * ap_int_base<8, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::plus operator +(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, unsigned char i_op) { return op + ap_int_base<8, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::minus operator -(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, unsigned char i_op) { return op - ap_int_base<8, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::div operator /(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, unsigned char i_op) { return op / ap_int_base<8, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::mod operator %(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, unsigned char i_op) { return op % ap_int_base<8, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::logic operator &(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, unsigned char i_op) { return op & ap_int_base<8, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::logic operator |(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, unsigned char i_op) { return op | ap_int_base<8, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::logic operator ^(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<8, false>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, unsigned char i_op) { return op ^ ap_int_base<8, false>(i_op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::mult operator *(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, short i_op) { return op * ap_int_base<_AP_SIZE_short, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::plus operator +(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, short i_op) { return op + ap_int_base<_AP_SIZE_short, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::minus operator -(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, short i_op) { return op - ap_int_base<_AP_SIZE_short, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::div operator /(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, short i_op) { return op / ap_int_base<_AP_SIZE_short, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::mod operator %(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, short i_op) { return op % ap_int_base<_AP_SIZE_short, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::logic operator &(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, short i_op) { return op & ap_int_base<_AP_SIZE_short, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::logic operator |(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, short i_op) { return op | ap_int_base<_AP_SIZE_short, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::logic operator ^(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, true>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, short i_op) { return op ^ ap_int_base<_AP_SIZE_short, true>(i_op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::mult operator *(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, unsigned short i_op) { return op * ap_int_base<_AP_SIZE_short, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::plus operator +(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, unsigned short i_op) { return op + ap_int_base<_AP_SIZE_short, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::minus operator -(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, unsigned short i_op) { return op - ap_int_base<_AP_SIZE_short, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::div operator /(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, unsigned short i_op) { return op / ap_int_base<_AP_SIZE_short, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::mod operator %(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, unsigned short i_op) { return op % ap_int_base<_AP_SIZE_short, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::logic operator &(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, unsigned short i_op) { return op & ap_int_base<_AP_SIZE_short, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::logic operator |(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, unsigned short i_op) { return op | ap_int_base<_AP_SIZE_short, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::logic operator ^(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_short, false>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, unsigned short i_op) { return op ^ ap_int_base<_AP_SIZE_short, false>(i_op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::mult operator *(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, int i_op) { return op * ap_int_base<_AP_SIZE_int, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::plus operator +(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, int i_op) { return op + ap_int_base<_AP_SIZE_int, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::minus operator -(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, int i_op) { return op - ap_int_base<_AP_SIZE_int, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::div operator /(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, int i_op) { return op / ap_int_base<_AP_SIZE_int, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::mod operator %(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, int i_op) { return op % ap_int_base<_AP_SIZE_int, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::logic operator &(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, int i_op) { return op & ap_int_base<_AP_SIZE_int, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::logic operator |(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, int i_op) { return op | ap_int_base<_AP_SIZE_int, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::logic operator ^(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, true>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, int i_op) { return op ^ ap_int_base<_AP_SIZE_int, true>(i_op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::mult operator *(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, unsigned int i_op) { return op * ap_int_base<_AP_SIZE_int, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::plus operator +(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, unsigned int i_op) { return op + ap_int_base<_AP_SIZE_int, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::minus operator -(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, unsigned int i_op) { return op - ap_int_base<_AP_SIZE_int, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::div operator /(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, unsigned int i_op) { return op / ap_int_base<_AP_SIZE_int, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::mod operator %(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, unsigned int i_op) { return op % ap_int_base<_AP_SIZE_int, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::logic operator &(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, unsigned int i_op) { return op & ap_int_base<_AP_SIZE_int, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::logic operator |(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, unsigned int i_op) { return op | ap_int_base<_AP_SIZE_int, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::logic operator ^(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_int, false>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, unsigned int i_op) { return op ^ ap_int_base<_AP_SIZE_int, false>(i_op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::mult operator *(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, long i_op) { return op * ap_int_base<_AP_SIZE_long, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::plus operator +(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, long i_op) { return op + ap_int_base<_AP_SIZE_long, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::minus operator -(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, long i_op) { return op - ap_int_base<_AP_SIZE_long, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::div operator /(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, long i_op) { return op / ap_int_base<_AP_SIZE_long, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::mod operator %(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, long i_op) { return op % ap_int_base<_AP_SIZE_long, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::logic operator &(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, long i_op) { return op & ap_int_base<_AP_SIZE_long, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::logic operator |(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, long i_op) { return op | ap_int_base<_AP_SIZE_long, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::logic operator ^(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, true>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, long i_op) { return op ^ ap_int_base<_AP_SIZE_long, true>(i_op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::mult operator *(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, unsigned long i_op) { return op * ap_int_base<_AP_SIZE_long, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::plus operator +(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, unsigned long i_op) { return op + ap_int_base<_AP_SIZE_long, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::minus operator -(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, unsigned long i_op) { return op - ap_int_base<_AP_SIZE_long, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::div operator /(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, unsigned long i_op) { return op / ap_int_base<_AP_SIZE_long, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::mod operator %(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, unsigned long i_op) { return op % ap_int_base<_AP_SIZE_long, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::logic operator &(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, unsigned long i_op) { return op & ap_int_base<_AP_SIZE_long, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::logic operator |(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, unsigned long i_op) { return op | ap_int_base<_AP_SIZE_long, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::logic operator ^(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_long, false>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, unsigned long i_op) { return op ^ ap_int_base<_AP_SIZE_long, false>(i_op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::mult operator *(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, ap_slong i_op) { return op * ap_int_base<_AP_SIZE_ap_slong, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::plus operator +(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, ap_slong i_op) { return op + ap_int_base<_AP_SIZE_ap_slong, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::minus operator -(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, ap_slong i_op) { return op - ap_int_base<_AP_SIZE_ap_slong, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::div operator /(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, ap_slong i_op) { return op / ap_int_base<_AP_SIZE_ap_slong, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::mod operator %(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, ap_slong i_op) { return op % ap_int_base<_AP_SIZE_ap_slong, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::logic operator &(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, ap_slong i_op) { return op & ap_int_base<_AP_SIZE_ap_slong, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::logic operator |(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, ap_slong i_op) { return op | ap_int_base<_AP_SIZE_ap_slong, true>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::logic operator ^(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, true>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, ap_slong i_op) { return op ^ ap_int_base<_AP_SIZE_ap_slong, true>(i_op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::mult operator *(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) *(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::mult operator *(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong i_op) { return op * ap_int_base<_AP_SIZE_ap_slong, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::plus operator +(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) +(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::plus operator +(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong i_op) { return op + ap_int_base<_AP_SIZE_ap_slong, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::minus operator -(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) -(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::minus operator -(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong i_op) { return op - ap_int_base<_AP_SIZE_ap_slong, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::div operator /(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) /(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::div operator /(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong i_op) { return op / ap_int_base<_AP_SIZE_ap_slong, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::mod operator %(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) %(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::mod operator %(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong i_op) { return op % ap_int_base<_AP_SIZE_ap_slong, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::logic operator &(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) &(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::logic operator &(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong i_op) { return op & ap_int_base<_AP_SIZE_ap_slong, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::logic operator |(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) |(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::logic operator |(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong i_op) { return op | ap_int_base<_AP_SIZE_ap_slong, false>(i_op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::logic operator ^(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) ^(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_SIZE_ap_slong, false>::logic operator ^(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong i_op) { return op ^ ap_int_base<_AP_SIZE_ap_slong, false>(i_op); }
# 1502 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, char op2) { ap_int_base<_AP_W, _AP_S> r; if (CHAR_IS_SIGNED) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, char op2) { ap_int_base<_AP_W, _AP_S> r; if (CHAR_IS_SIGNED) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, short op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, short op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, int op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, int op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, long op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, long op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V << op2) : (op.V >> (-op2)); else r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { ap_int_base<_AP_W, _AP_S> r; if (true) r.V = op2 >= 0 ? (op.V >> op2) : (op.V << (-op2)); else r.V = op.V >> op2; return r; }
# 1526 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, bool op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, bool op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V >> op2; return r; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V >> op2; return r; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V >> op2; return r; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V >> op2; return r; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V >> op2; return r; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator<<( const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V << op2; return r; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, _AP_S>::template RType<_AP_W,_AP_S>::arg1 operator>>( const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { ap_int_base<_AP_W, _AP_S> r; r.V = op.V >> op2; return r; }
# 1557 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op += ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op -= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op *= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op /= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op %= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op &= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op |= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op ^= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op >>= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op <<= ap_int_base<1, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, char op2) { return op += ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, char op2) { return op -= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, char op2) { return op *= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, char op2) { return op /= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, char op2) { return op %= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, char op2) { return op &= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, char op2) { return op |= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, char op2) { return op ^= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, char op2) { return op >>= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, char op2) { return op <<= ap_int_base<8, CHAR_IS_SIGNED>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op += ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op -= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op *= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op /= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op %= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op &= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op |= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op ^= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op >>= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op <<= ap_int_base<8, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op += ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op -= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op *= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op /= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op %= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op &= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op |= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op ^= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op >>= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op <<= ap_int_base<8, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, short op2) { return op += ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, short op2) { return op -= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, short op2) { return op *= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, short op2) { return op /= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, short op2) { return op %= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, short op2) { return op &= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, short op2) { return op |= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, short op2) { return op ^= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, short op2) { return op >>= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, short op2) { return op <<= ap_int_base<_AP_SIZE_short, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op += ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op -= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op *= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op /= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op %= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op &= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op |= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op ^= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op >>= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op <<= ap_int_base<_AP_SIZE_short, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, int op2) { return op += ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, int op2) { return op -= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, int op2) { return op *= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, int op2) { return op /= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, int op2) { return op %= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, int op2) { return op &= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, int op2) { return op |= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, int op2) { return op ^= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, int op2) { return op >>= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, int op2) { return op <<= ap_int_base<_AP_SIZE_int, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op += ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op -= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op *= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op /= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op %= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op &= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op |= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op ^= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op >>= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op <<= ap_int_base<_AP_SIZE_int, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, long op2) { return op += ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, long op2) { return op -= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, long op2) { return op *= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, long op2) { return op /= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, long op2) { return op %= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, long op2) { return op &= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, long op2) { return op |= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, long op2) { return op ^= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, long op2) { return op >>= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, long op2) { return op <<= ap_int_base<_AP_SIZE_long, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op += ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op -= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op *= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op /= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op %= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op &= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op |= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op ^= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op >>= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op <<= ap_int_base<_AP_SIZE_long, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op += ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op -= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op *= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op /= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op %= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op &= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op |= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op ^= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op >>= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op <<= ap_int_base<_AP_SIZE_ap_slong, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator +=( ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op += ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator -=( ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op -= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator *=( ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op *= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator /=( ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op /= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator %=( ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op %= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator &=( ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op &= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator |=( ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op |= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator ^=( ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op ^= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator >>=( ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op >>= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W, _AP_S>& operator <<=( ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op <<= ap_int_base<_AP_SIZE_ap_slong, false>(op2); }
# 1594 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op > ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op < ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op >= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op <= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op == ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(bool i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<1, false>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, bool op2) { return op != ap_int_base<1, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, char op2) { return op > ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, char op2) { return op < ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, char op2) { return op >= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, char op2) { return op <= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, char op2) { return op == ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, CHAR_IS_SIGNED>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, char op2) { return op != ap_int_base<8, CHAR_IS_SIGNED>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op > ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op < ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op >= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op <= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op == ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(signed char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, true>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, signed char op2) { return op != ap_int_base<8, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op > ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op < ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op >= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op <= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op == ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(unsigned char i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<8, false>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, unsigned char op2) { return op != ap_int_base<8, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, short op2) { return op > ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, short op2) { return op < ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, short op2) { return op >= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, short op2) { return op <= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, short op2) { return op == ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, true>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, short op2) { return op != ap_int_base<_AP_SIZE_short, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op > ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op < ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op >= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op <= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op == ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(unsigned short i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_short, false>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, unsigned short op2) { return op != ap_int_base<_AP_SIZE_short, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, int op2) { return op > ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, int op2) { return op < ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, int op2) { return op >= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, int op2) { return op <= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, int op2) { return op == ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, true>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, int op2) { return op != ap_int_base<_AP_SIZE_int, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op > ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op < ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op >= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op <= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op == ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(unsigned int i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_int, false>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, unsigned int op2) { return op != ap_int_base<_AP_SIZE_int, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, long op2) { return op > ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, long op2) { return op < ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, long op2) { return op >= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, long op2) { return op <= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, long op2) { return op == ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, true>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, long op2) { return op != ap_int_base<_AP_SIZE_long, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op > ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op < ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op >= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op <= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op == ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(unsigned long i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_long, false>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, unsigned long op2) { return op != ap_int_base<_AP_SIZE_long, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op > ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op < ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op >= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op <= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op == ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(ap_slong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, true>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, ap_slong op2) { return op != ap_int_base<_AP_SIZE_ap_slong, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) > op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op > ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) < op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op < ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) >= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op >= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) <= op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op <= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) == op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op == ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(ap_ulong i_op, const ap_int_base<_AP_W, _AP_S>& op) { return ap_int_base<_AP_SIZE_ap_slong, false>(i_op) != op; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op, ap_ulong op2) { return op != ap_int_base<_AP_SIZE_ap_slong, false>(op2); }
# 1631 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op1, double op2) { return op1.to_double() > op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(double op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 > op2.to_double() ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W, _AP_S>& op1, float op2) { return op1.to_double() > op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(float op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 > op2.to_double() ; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op1, double op2) { return op1.to_double() < op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(double op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 < op2.to_double() ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W, _AP_S>& op1, float op2) { return op1.to_double() < op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(float op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 < op2.to_double() ; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op1, double op2) { return op1.to_double() >= op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(double op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 >= op2.to_double() ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W, _AP_S>& op1, float op2) { return op1.to_double() >= op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(float op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 >= op2.to_double() ; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op1, double op2) { return op1.to_double() <= op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(double op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 <= op2.to_double() ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W, _AP_S>& op1, float op2) { return op1.to_double() <= op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(float op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 <= op2.to_double() ; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op1, double op2) { return op1.to_double() == op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(double op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 == op2.to_double() ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W, _AP_S>& op1, float op2) { return op1.to_double() == op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(float op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 == op2.to_double() ; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op1, double op2) { return op1.to_double() != op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(double op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 != op2.to_double() ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W, _AP_S>& op1, float op2) { return op1.to_double() != op2 ; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(float op1, const ap_int_base<_AP_W, _AP_S>& op2) { return op1 != op2.to_double() ; }
# 1661 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::plus operator +(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) + op2; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::plus operator +(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 + ap_int_base<_AP_W2, false>(op2); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::minus operator -(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) - op2; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::minus operator -(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 - ap_int_base<_AP_W2, false>(op2); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::mult operator *(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) * op2; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::mult operator *(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 * ap_int_base<_AP_W2, false>(op2); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::div operator /(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) / op2; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::div operator /(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 / ap_int_base<_AP_W2, false>(op2); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::mod operator %(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) % op2; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::mod operator %(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 % ap_int_base<_AP_W2, false>(op2); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator &(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) & op2; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator &(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 & ap_int_base<_AP_W2, false>(op2); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator |(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) | op2; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator |(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 | ap_int_base<_AP_W2, false>(op2); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator ^(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) ^ op2; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::logic operator ^(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 ^ ap_int_base<_AP_W2, false>(op2); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::arg1 operator >>(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) >> op2; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::arg1 operator >>(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 >> ap_int_base<_AP_W2, false>(op2); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::arg1 operator <<(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1) << op2; } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<_AP_W2, _AP_S2>::arg1 operator <<(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 << ap_int_base<_AP_W2, false>(op2); }
# 1690 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator +=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 += ap_int_base<_AP_W2, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1, _AP_S1>& operator +=( ap_range_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp += op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator -=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 -= ap_int_base<_AP_W2, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1, _AP_S1>& operator -=( ap_range_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp -= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator *=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 *= ap_int_base<_AP_W2, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1, _AP_S1>& operator *=( ap_range_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp *= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator /=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 /= ap_int_base<_AP_W2, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1, _AP_S1>& operator /=( ap_range_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp /= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator %=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 %= ap_int_base<_AP_W2, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1, _AP_S1>& operator %=( ap_range_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp %= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator &=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 &= ap_int_base<_AP_W2, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1, _AP_S1>& operator &=( ap_range_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp &= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator |=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 |= ap_int_base<_AP_W2, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1, _AP_S1>& operator |=( ap_range_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp |= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator ^=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 ^= ap_int_base<_AP_W2, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1, _AP_S1>& operator ^=( ap_range_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp ^= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator >>=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 >>= ap_int_base<_AP_W2, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1, _AP_S1>& operator >>=( ap_range_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp >>= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator <<=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1 <<= ap_int_base<_AP_W2, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_range_ref<_AP_W1, _AP_S1>& operator <<=( ap_range_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<_AP_W1, false> tmp(op1); tmp <<= op2; op1 = tmp; return op1; }
# 1716 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1).operator ==(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator ==(op2.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1).operator !=(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator !=(op2.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1).operator >(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator >(op2.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1).operator >=(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator >=(op2.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1).operator <(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator <(op2.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<_AP_W1, false>(op1).operator <=(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_range_ref<_AP_W2, _AP_S2>& op2) { return op1.operator <=(op2.operator ap_int_base<_AP_W2, false>()); }
# 1743 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<1, false>::plus operator +(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 + ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<1, false>::template RType<_AP_W2, _AP_S2>::plus operator +(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) + op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<1, false>::minus operator -(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 - ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<1, false>::template RType<_AP_W2, _AP_S2>::minus operator -(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) - op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<1, false>::mult operator *(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 * ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<1, false>::template RType<_AP_W2, _AP_S2>::mult operator *(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) * op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<1, false>::div operator /(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 / ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<1, false>::template RType<_AP_W2, _AP_S2>::div operator /(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) / op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<1, false>::mod operator %(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 % ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<1, false>::template RType<_AP_W2, _AP_S2>::mod operator %(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) % op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<1, false>::logic operator &(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 & ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<1, false>::template RType<_AP_W2, _AP_S2>::logic operator &(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) & op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<1, false>::logic operator |(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 | ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<1, false>::template RType<_AP_W2, _AP_S2>::logic operator |(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) | op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<1, false>::logic operator ^(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 ^ ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<1, false>::template RType<_AP_W2, _AP_S2>::logic operator ^(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) ^ op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<1, false>::arg1 operator >>(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 >> ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<1, false>::template RType<_AP_W2, _AP_S2>::arg1 operator >>(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) >> op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W1, _AP_S1>::template RType<1, false>::arg1 operator <<(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 << ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<1, false>::template RType<_AP_W2, _AP_S2>::arg1 operator <<(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) << op2; }
# 1772 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator +=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 += ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1, _AP_S1>& operator +=( ap_bit_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp += op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator -=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 -= ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1, _AP_S1>& operator -=( ap_bit_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp -= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator *=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 *= ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1, _AP_S1>& operator *=( ap_bit_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp *= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator /=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 /= ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1, _AP_S1>& operator /=( ap_bit_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp /= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator %=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 %= ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1, _AP_S1>& operator %=( ap_bit_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp %= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator &=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 &= ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1, _AP_S1>& operator &=( ap_bit_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp &= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator |=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 |= ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1, _AP_S1>& operator |=( ap_bit_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp |= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator ^=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 ^= ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1, _AP_S1>& operator ^=( ap_bit_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp ^= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator >>=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 >>= ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1, _AP_S1>& operator >>=( ap_bit_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp >>= op2; op1 = tmp; return op1; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W1, _AP_S1>& operator <<=( ap_int_base<_AP_W1, _AP_S1>& op1, ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 <<= ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_bit_ref<_AP_W1, _AP_S1>& operator <<=( ap_bit_ref<_AP_W1, _AP_S1>& op1, ap_int_base<_AP_W2, _AP_S2>& op2) { ap_int_base<1, false> tmp(op1); tmp <<= op2; op1 = tmp; return op1; }
# 1798 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator ==(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 == ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) == op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator !=(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 != ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) != op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 > ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) > op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >=(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 >= ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) >= op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 < ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) < op2; }
template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <=(const ap_int_base<_AP_W1, _AP_S1>& op1, const ap_bit_ref<_AP_W2, _AP_S2>& op2) { return op1 <= ap_int_base<1, false>(op2); } template <int _AP_W1, bool _AP_S1, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W1, _AP_S1>& op1, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op1) <= op2; }
# 1906 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_base.h"
template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator ==( const ap_int_base<_AP_W3, _AP_S3>& op1, const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op2) { return op1 == op2.get(); } template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op1, const ap_int_base<_AP_W3, _AP_S3>& op2) { return op1.get() == op2; }
template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator !=( const ap_int_base<_AP_W3, _AP_S3>& op1, const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op2) { return op1 != op2.get(); } template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op1, const ap_int_base<_AP_W3, _AP_S3>& op2) { return op1.get() != op2; }
template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator >( const ap_int_base<_AP_W3, _AP_S3>& op1, const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op2) { return op1 > op2.get(); } template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op1, const ap_int_base<_AP_W3, _AP_S3>& op2) { return op1.get() > op2; }
template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator >=( const ap_int_base<_AP_W3, _AP_S3>& op1, const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op2) { return op1 >= op2.get(); } template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op1, const ap_int_base<_AP_W3, _AP_S3>& op2) { return op1.get() >= op2; }
template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator <( const ap_int_base<_AP_W3, _AP_S3>& op1, const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op2) { return op1 < op2.get(); } template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op1, const ap_int_base<_AP_W3, _AP_S3>& op2) { return op1.get() < op2; }
template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator <=( const ap_int_base<_AP_W3, _AP_S3>& op1, const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op2) { return op1 <= op2.get(); } template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2, int _AP_W3, bool _AP_S3> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& op1, const ap_int_base<_AP_W3, _AP_S3>& op2) { return op1.get() <= op2; }
# 56 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int.h" 2
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h" 1
# 72 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
template <int _AP_W1, typename _AP_T1, int _AP_W2, typename _AP_T2>
struct ap_concat_ref {
enum {
_AP_WR = _AP_W1 + _AP_W2,
};
_AP_T1& mbv1;
_AP_T2& mbv2;
inline __attribute__((always_inline)) ap_concat_ref(const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& ref)
: mbv1(ref.mbv1), mbv2(ref.mbv2) {}
inline __attribute__((always_inline)) ap_concat_ref(_AP_T1& bv1, _AP_T2& bv2) : mbv1(bv1), mbv2(bv2) {}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref& operator=(const ap_int_base<_AP_W3, _AP_S3>& val) {
ap_int_base<_AP_W1 + _AP_W2, false> vval(val);
int W_ref1 = mbv1.length();
int W_ref2 = mbv2.length();
ap_int_base<_AP_W1, false> Part1;
Part1.V = ({ typename _ap_type::remove_const<typeof(vval.V)>::type __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), W_ref2, W_ref1 + W_ref2 - 1); __Result__; });
mbv1.set(Part1);
ap_int_base<_AP_W2, false> Part2;
Part2.V = ({ typename _ap_type::remove_const<typeof(vval.V)>::type __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, W_ref2 - 1); __Result__; });
mbv2.set(Part2);
return *this;
}
# 115 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
inline __attribute__((always_inline)) ap_concat_ref& operator=(bool val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(char val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(signed char val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(unsigned char val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(short val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(unsigned short val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(int val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(unsigned int val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(long val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(unsigned long val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(ap_slong val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(ap_ulong val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(half val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(float val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(double val) { ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val); return operator=(tmpVal); }
inline __attribute__((always_inline)) ap_concat_ref& operator=(
const ap_concat_ref<_AP_W1, _AP_T1, _AP_W2, _AP_T2>& val) {
ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val);
return operator=(tmpVal);
}
template <int _AP_W3, typename _AP_T3, int _AP_W4, typename _AP_T4>
inline __attribute__((always_inline)) ap_concat_ref& operator=(
const ap_concat_ref<_AP_W3, _AP_T3, _AP_W4, _AP_T4>& val) {
ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val);
return operator=(tmpVal);
}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref& operator=(const ap_bit_ref<_AP_W3, _AP_S3>& val) {
ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val);
return operator=(tmpVal);
}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref& operator=(const ap_range_ref<_AP_W3, _AP_S3>& val) {
ap_int_base<_AP_W1 + _AP_W2, false> tmpVal(val);
return operator=(tmpVal);
}
template <int _AP_W3, int _AP_I3, bool _AP_S3, ap_q_mode _AP_Q3,
ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline)) ap_concat_ref& operator=(
const af_range_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3>& val) {
return operator=((const ap_int_base<_AP_W3, false>)(val));
}
template <int _AP_W3, int _AP_I3, bool _AP_S3, ap_q_mode _AP_Q3,
ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline)) ap_concat_ref& operator=(
const ap_fixed_base<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3>&
val) {
return operator=(val.to_ap_int_base());
}
template <int _AP_W3, int _AP_I3, bool _AP_S3, ap_q_mode _AP_Q3,
ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline)) ap_concat_ref& operator=(
const af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3>& val) {
return operator=((ap_ulong)(bool)(val));
}
inline __attribute__((always_inline)) operator ap_int_base<_AP_WR, false>() const { return get(); }
inline __attribute__((always_inline)) operator ap_ulong() const { return get().to_uint64(); }
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3,
ap_range_ref<_AP_W3, _AP_S3> >
operator,(const ap_range_ref<_AP_W3, _AP_S3> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3,
ap_range_ref<_AP_W3, _AP_S3> >(
*this, const_cast<ap_range_ref<_AP_W3, _AP_S3>&>(a2));
}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator,(ap_int_base<_AP_W3, _AP_S3> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3,
ap_int_base<_AP_W3, _AP_S3> >(*this, a2);
}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator,(volatile ap_int_base<_AP_W3, _AP_S3> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3,
ap_int_base<_AP_W3, _AP_S3> >(
*this, const_cast<ap_int_base<_AP_W3, _AP_S3>&>(a2));
}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator,(const ap_int_base<_AP_W3, _AP_S3> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3,
ap_int_base<_AP_W3, _AP_S3> >(
*this, const_cast<ap_int_base<_AP_W3, _AP_S3>&>(a2));
}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3, ap_int_base<_AP_W3, _AP_S3> >
operator,(const volatile ap_int_base<_AP_W3, _AP_S3> &a2) {
ap_int_base<_AP_W3, _AP_S3> op(a2);
return ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3,
ap_int_base<_AP_W3, _AP_S3> >(
*this, const_cast<ap_int_base<_AP_W3, _AP_S3>&>(op));
}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, 1, ap_bit_ref<_AP_W3, _AP_S3> >
operator,(const ap_bit_ref<_AP_W3, _AP_S3> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, 1, ap_bit_ref<_AP_W3, _AP_S3> >(
*this, const_cast<ap_bit_ref<_AP_W3, _AP_S3>&>(a2));
}
template <int _AP_W3, typename _AP_T3, int _AP_W4, typename _AP_T4>
inline __attribute__((always_inline)) ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3 + _AP_W4,
ap_concat_ref<_AP_W3, _AP_T3, _AP_W4, _AP_T4> >
operator,(const ap_concat_ref<_AP_W3, _AP_T3, _AP_W4, _AP_T4> &a2) {
return ap_concat_ref<_AP_WR, ap_concat_ref, _AP_W3 + _AP_W4,
ap_concat_ref<_AP_W3, _AP_T3, _AP_W4, _AP_T4> >(
*this, const_cast<ap_concat_ref<_AP_W3, _AP_T3, _AP_W4, _AP_T4>&>(a2));
}
template <int _AP_W3, int _AP_I3, bool _AP_S3, ap_q_mode _AP_Q3,
ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline)) ap_concat_ref<
_AP_WR, ap_concat_ref, _AP_W3,
af_range_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >
operator,(
const af_range_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> &a2) {
return ap_concat_ref<
_AP_WR, ap_concat_ref, _AP_W3,
af_range_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >(
*this,
const_cast<
af_range_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3>&>(a2));
}
template <int _AP_W3, int _AP_I3, bool _AP_S3, ap_q_mode _AP_Q3,
ap_o_mode _AP_O3, int _AP_N3>
inline __attribute__((always_inline))
ap_concat_ref<_AP_WR, ap_concat_ref, 1,
af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >
operator,(const af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3>
&a2) {
return ap_concat_ref<
_AP_WR, ap_concat_ref, 1,
af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3> >(
*this,
const_cast<af_bit_ref<_AP_W3, _AP_I3, _AP_S3, _AP_Q3, _AP_O3, _AP_N3>&>(
a2));
}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3> operator&(
const ap_int_base<_AP_W3, _AP_S3>& a2) {
return get() & a2;
}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3> operator|(
const ap_int_base<_AP_W3, _AP_S3>& a2) {
return get() | a2;
}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) ap_int_base<((_AP_WR) > (_AP_W3) ? (_AP_WR) : (_AP_W3)), _AP_S3> operator^(
const ap_int_base<_AP_W3, _AP_S3>& a2) {
return get() ^ a2;
}
# 303 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
inline __attribute__((always_inline)) ap_int_base<_AP_WR, false> get() const {
ap_int_base<_AP_WR, false> tmpVal(0);
int W_ref1 = mbv1.length();
int W_ref2 = mbv2.length();
ap_int_base<_AP_W2, false> v2(mbv2);
ap_int_base<_AP_W1, false> v1(mbv1);
tmpVal.V = ({ typename _ap_type::remove_const<typeof(tmpVal.V)>::type __Result__ = 0; typeof(tmpVal.V) __Val2__ = tmpVal.V; typeof(v2.V) __Repl2__ = v2.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 0, W_ref2 - 1); __Result__; });
tmpVal.V =
({ typename _ap_type::remove_const<typeof(tmpVal.V)>::type __Result__ = 0; typeof(tmpVal.V) __Val2__ = tmpVal.V; typeof(v1.V) __Repl2__ = v1.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), W_ref2, W_ref1 + W_ref2 - 1); __Result__; });
return tmpVal;
}
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
ap_int_base<_AP_W1 + _AP_W2, false> vval(val);
int W_ref1 = mbv1.length();
int W_ref2 = mbv2.length();
ap_int_base<_AP_W1, false> tmpVal1;
tmpVal1.V = ({ typename _ap_type::remove_const<typeof(vval.V)>::type __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), W_ref2, W_ref1 + W_ref2 - 1); __Result__; });
mbv1.set(tmpVal1);
ap_int_base<_AP_W2, false> tmpVal2;
tmpVal2.V = ({ typename _ap_type::remove_const<typeof(vval.V)>::type __Result__ = 0; typeof(vval.V) __Val2__ = vval.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, W_ref2 - 1); __Result__; });
mbv2.set(tmpVal2);
}
inline __attribute__((always_inline)) int length() const { return mbv1.length() + mbv2.length(); }
};
template <int _AP_W, bool _AP_S>
struct ap_range_ref {
typedef ap_int_base<_AP_W, _AP_S> ref_type;
ref_type& d_bv;
int l_index;
int h_index;
public:
inline __attribute__((always_inline)) ap_range_ref(const ap_range_ref<_AP_W, _AP_S>& ref)
: d_bv(ref.d_bv), l_index(ref.l_index), h_index(ref.h_index) {}
inline __attribute__((always_inline)) ap_range_ref(ref_type* bv, int h, int l)
: d_bv(*bv), l_index(l), h_index(h) {}
inline __attribute__((always_inline)) ap_range_ref(const ref_type* bv, int h, int l)
: d_bv(*const_cast<ref_type*>(bv)), l_index(l), h_index(h) {}
inline __attribute__((always_inline)) operator ap_int_base<_AP_W, false>() const {
ap_int_base<_AP_W, false> ret;
ret.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret;
}
inline __attribute__((always_inline)) operator ap_ulong() const { return to_uint64(); }
# 384 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
inline __attribute__((always_inline)) ap_range_ref& operator=(bool val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(char val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(signed char val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(unsigned char val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(short val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(unsigned short val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(int val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(unsigned int val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(long val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(unsigned long val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(ap_slong val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(ap_ulong val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(half val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(float val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(double val) { ap_int_base<_AP_W, false> tmp(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_range_ref& operator=(const char* val) {
const ap_int_base<_AP_W, false> tmp(val);
d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref& operator=(const ap_int_base<_AP_W2, _AP_S2>& val) {
ap_int_base<_AP_W, false> tmp(val);
d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
inline __attribute__((always_inline)) ap_range_ref& operator=(const ap_range_ref& val) {
return operator=((const ap_int_base<_AP_W, false>)val);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref& operator=(const ap_range_ref<_AP_W2, _AP_S2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)val);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref& operator=(const ap_bit_ref<_AP_W2, _AP_S2>& val) {
return operator=((ap_ulong)(bool)(val));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_range_ref& operator=(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&
val) {
return operator=(val.to_ap_int_base());
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_range_ref& operator=(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)val);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_range_ref& operator=(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((ap_ulong)(bool)(val));
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_range_ref& operator=(
const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)(val));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator,(const ap_range_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(
*this, const_cast<ap_range_ref<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(ap_int_base<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(*this, a2);
}
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W, ap_int_base<_AP_W, _AP_S> >
operator,(ap_int_base<_AP_W, _AP_S>& a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W,
ap_int_base<_AP_W, _AP_S> >(*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(volatile ap_int_base<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(
*this, const_cast<ap_int_base<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(const ap_int_base<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(
*this, const_cast<ap_int_base<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(const volatile ap_int_base<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(
*this, const_cast<ap_int_base<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_range_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator,(const ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >(
*this, const_cast<ap_bit_ref<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, ap_range_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator,(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<_AP_W, ap_range_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(
*this, const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>&>(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<
_AP_W, ap_range_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator,(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> a2) {
return ap_concat_ref<
_AP_W, ap_range_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(
*this,
const_cast<
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, ap_range_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator,(const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>
&a2) {
return ap_concat_ref<
_AP_W, ap_range_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(
*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(
a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator==(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> hop(op2);
return lop == hop;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator!=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator==(op2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator<(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> hop(op2);
return lop < hop;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator<=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> hop(op2);
return lop <= hop;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator>(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator<=(op2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator>=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator<(op2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S>& operator|=(
const ap_range_ref<_AP_W2, _AP_S2>& op2) {
(this->d_bv).V |= (op2.d_bv).V;
return *this;
};
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S>& operator|=(
const ap_int_base<_AP_W2, _AP_S2>& op2) {
(this->d_bv).V |= op2.V;
return *this;
};
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S>& operator&=(
const ap_range_ref<_AP_W2, _AP_S2>& op2) {
(this->d_bv).V &= (op2.d_bv).V;
return *this;
};
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S>& operator&=(
const ap_int_base<_AP_W2, _AP_S2>& op2) {
(this->d_bv).V &= op2.V;
return *this;
};
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S>& operator^=(
const ap_range_ref<_AP_W2, _AP_S2>& op2) {
(this->d_bv).V ^= (op2.d_bv).V;
return *this;
};
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_range_ref<_AP_W, _AP_S>& operator^=(
const ap_int_base<_AP_W2, _AP_S2>& op2) {
(this->d_bv).V ^= op2.V;
return *this;
};
inline __attribute__((always_inline)) ap_int_base<_AP_W, false> get() const {
ap_int_base<_AP_W, false> ret;
ret.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret;
}
template <int _AP_W2>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W2, false>& val) {
d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val.V) __Repl2__ = val.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
}
inline __attribute__((always_inline)) int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
inline __attribute__((always_inline)) int to_int() const {
return (int)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned to_uint() const {
return (unsigned)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) long to_long() const {
return (long)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned long to_ulong() const {
return (unsigned long)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_slong to_int64() const {
return (ap_slong)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_ulong to_uint64() const {
return (ap_ulong)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) bool and_reduce() const {
bool ret = true;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
#pragma HLS unroll
ret &= ({ typeof(d_bv.V) __Val2__ = d_bv.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), i); __Result__; });
}
return ret;
}
inline __attribute__((always_inline)) bool or_reduce() const {
bool ret = false;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
#pragma HLS unroll
ret |= ({ typeof(d_bv.V) __Val2__ = d_bv.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), i); __Result__; });
}
return ret;
}
inline __attribute__((always_inline)) bool xor_reduce() const {
bool ret = false;
bool reverse = l_index > h_index;
unsigned low = reverse ? h_index : l_index;
unsigned high = reverse ? l_index : h_index;
for (unsigned i = low; i != high; ++i) {
#pragma HLS unroll
ret ^= ({ typeof(d_bv.V) __Val2__ = d_bv.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), i); __Result__; });
}
return ret;
}
# 732 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
inline __attribute__((always_inline)) char* to_string(signed char radix = 2) const {
return 0;
}
};
# 771 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
template <int _AP_W, bool _AP_S>
struct ap_bit_ref {
typedef ap_int_base<_AP_W, _AP_S> ref_type;
ref_type& d_bv;
int d_index;
public:
inline __attribute__((always_inline)) ap_bit_ref(const ap_bit_ref<_AP_W, _AP_S>& ref)
: d_bv(ref.d_bv), d_index(ref.d_index) {}
inline __attribute__((always_inline)) ap_bit_ref(ref_type* bv, int index = 0) : d_bv(*bv), d_index(index) {}
inline __attribute__((always_inline)) ap_bit_ref(const ref_type* bv, int index = 0)
: d_bv(*const_cast<ref_type*>(bv)), d_index(index) {}
inline __attribute__((always_inline)) operator bool() const { return ({ typeof(d_bv.V) __Val2__ = d_bv.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), d_index); __Result__; }); }
inline __attribute__((always_inline)) bool to_bool() const { return ({ typeof(d_bv.V) __Val2__ = d_bv.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), d_index); __Result__; }); }
# 809 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
inline __attribute__((always_inline)) ap_bit_ref& operator=(bool val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(char val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(signed char val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(unsigned char val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(short val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(unsigned short val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(int val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(unsigned int val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(long val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(unsigned long val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(ap_slong val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(ap_ulong val) { d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
# 831 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
inline __attribute__((always_inline)) ap_bit_ref& operator=(half val) { bool tmp_val = val; d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp_val) __Repl2__ = !!tmp_val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(float val) { bool tmp_val = val; d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp_val) __Repl2__ = !!tmp_val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) ap_bit_ref& operator=(double val) { bool tmp_val = val; d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp_val) __Repl2__ = !!tmp_val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; }); return *this; }
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref& operator=(const ap_int_base<_AP_W2, _AP_S2>& val) {
return operator=((ap_ulong)(val.V != 0));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref& operator=(const ap_range_ref<_AP_W2, _AP_S2>& val) {
return operator=((ap_int_base<_AP_W2, false>)val);
}
inline __attribute__((always_inline)) ap_bit_ref& operator=(const ap_bit_ref& val) {
return operator=((ap_ulong)(bool)val);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_bit_ref& operator=(const ap_bit_ref<_AP_W2, _AP_S2>& val) {
return operator=((ap_ulong)(bool)val);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_bit_ref& operator=(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((const ap_int_base<_AP_W2, false>)val);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_bit_ref& operator=(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=((ap_ulong)(bool)val);
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_bit_ref& operator=(
const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=((const ap_int_base<_AP_W2 + _AP_W3, false>)val);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(ap_int_base<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >(
*this, a2);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(volatile ap_int_base<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >(
*this, const_cast<ap_int_base<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(const ap_int_base<_AP_W2, _AP_S2> &a2) {
ap_int_base<_AP_W2, _AP_S2> op(a2);
return ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >(
*this, const_cast<ap_int_base<_AP_W2, _AP_S2>&>(op));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(const volatile ap_int_base<_AP_W2, _AP_S2> &a2) {
ap_int_base<_AP_W2, _AP_S2> op(a2);
return ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >(
*this, const_cast<ap_int_base<_AP_W2, _AP_S2>&>(op));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator,(const ap_range_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >(
*this, const_cast<ap_range_ref<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> > operator,(
const ap_bit_ref<_AP_W2, _AP_S2> &a2) {
return ap_concat_ref<1, ap_bit_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >(
*this, const_cast<ap_bit_ref<_AP_W2, _AP_S2>&>(a2));
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator,(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &a2) {
return ap_concat_ref<1, ap_bit_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(
*this, const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>&>(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<
1, ap_bit_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator,(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> &a2) {
return ap_concat_ref<
1, ap_bit_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(
*this,
const_cast<
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(a2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<1, ap_bit_ref, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> >
operator,(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> &a2) {
return ap_concat_ref<1, ap_bit_ref, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> >(
*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(
a2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator==(const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() == op.get();
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator!=(const ap_bit_ref<_AP_W2, _AP_S2>& op) {
return get() != op.get();
}
inline __attribute__((always_inline)) bool get() const { return ({ typeof(d_bv.V) __Val2__ = d_bv.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), d_index); __Result__; }); }
inline __attribute__((always_inline)) bool get() { return ({ typeof(d_bv.V) __Val2__ = d_bv.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), d_index); __Result__; }); }
template <int _AP_W3>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W3, false>& val) {
operator=(val);
}
inline __attribute__((always_inline)) bool operator~() const {
bool bit = ({ typeof(d_bv.V) __Val2__ = d_bv.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), d_index); __Result__; });
return bit ? false : true;
}
inline __attribute__((always_inline)) int length() const { return 1; }
inline __attribute__((always_inline)) char* to_string() const { return 0; }
};
# 1029 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, bool op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(bool op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, bool op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, bool op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(bool op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, bool op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, bool op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(bool op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, bool op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, bool op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(bool op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, bool op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<1, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, char op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, char op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, char op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, char op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<8, CHAR_IS_SIGNED>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(signed char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, signed char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(signed char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, signed char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(signed char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, signed char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(signed char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, signed char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<8, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(unsigned char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(unsigned char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(unsigned char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(unsigned char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<8, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, short op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, short op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, short op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, short op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<_AP_SIZE_short, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(unsigned short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(unsigned short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(unsigned short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(unsigned short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<_AP_SIZE_short, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, int op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, int op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, int op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, int op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<_AP_SIZE_int, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(unsigned int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(unsigned int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(unsigned int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(unsigned int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<_AP_SIZE_int, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, long op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, long op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, long op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, long op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<_AP_SIZE_long, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(unsigned long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(unsigned long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(unsigned long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(unsigned long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<_AP_SIZE_long, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(ap_slong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_slong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(ap_slong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_slong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(ap_slong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_slong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(ap_slong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_slong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<_AP_SIZE_ap_slong, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(const ap_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return bool(op) > op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >(ap_ulong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 > bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_ulong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) > ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(const ap_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return bool(op) < op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <(ap_ulong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 < bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_ulong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) < ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(const ap_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return bool(op) >= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator >=(ap_ulong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 >= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator >=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_ulong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) >= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(const ap_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return bool(op) <= op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator <=(ap_ulong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 <= bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator <=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_ulong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) <= ap_int_base<_AP_SIZE_ap_slong, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, bool op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(bool op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, bool op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<1, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, bool op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(bool op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, bool op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<1, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, char op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<8, CHAR_IS_SIGNED>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, char op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<8, CHAR_IS_SIGNED>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(signed char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, signed char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<8, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, signed char op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(signed char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, signed char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<8, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(unsigned char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<8, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned char op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(unsigned char op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned char op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<8, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, short op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<_AP_SIZE_short, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, short op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<_AP_SIZE_short, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(unsigned short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<_AP_SIZE_short, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned short op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(unsigned short op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned short op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<_AP_SIZE_short, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, int op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<_AP_SIZE_int, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, int op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<_AP_SIZE_int, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(unsigned int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<_AP_SIZE_int, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned int op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(unsigned int op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned int op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<_AP_SIZE_int, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, long op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<_AP_SIZE_long, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, long op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<_AP_SIZE_long, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(unsigned long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<_AP_SIZE_long, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, unsigned long op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(unsigned long op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, unsigned long op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<_AP_SIZE_long, false>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(ap_slong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_slong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<_AP_SIZE_ap_slong, true>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, ap_slong op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(ap_slong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_slong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<_AP_SIZE_ap_slong, true>(op2); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(const ap_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return bool(op) == op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator ==(ap_ulong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 == bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator ==( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_ulong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) == ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<_AP_SIZE_ap_slong, false>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(const ap_bit_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return bool(op) != op2; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) bool operator !=(ap_ulong op2, const ap_bit_ref<_AP_W, _AP_S>& op) { return op2 != bool(op); } template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) bool operator !=( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1>& op, ap_ulong op2) { return ap_int_base<_AP_W + _AP_W1, false>(op) != ap_int_base<_AP_SIZE_ap_slong, false>(op2); }
# 1088 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(1), (false)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(1), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(1), (false)>::template RType<_AP_W, false>::plus operator +(bool op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(1), (false)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(1), (false)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(1), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(1), (false)>::template RType<_AP_W, false>::minus operator -(bool op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(1), (false)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(1), (false)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(1), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(1), (false)>::template RType<_AP_W, false>::mult operator *(bool op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(1), (false)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(1), (false)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(1), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(1), (false)>::template RType<_AP_W, false>::div operator /(bool op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(1), (false)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(1), (false)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(1), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(1), (false)>::template RType<_AP_W, false>::mod operator %(bool op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(1), (false)>(op2) % ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::plus operator +(char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::minus operator -(char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::mult operator *(char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::div operator /(char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::mod operator %(char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) % ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (true)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(8), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (true)>::template RType<_AP_W, false>::plus operator +(signed char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (true)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (true)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(8), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (true)>::template RType<_AP_W, false>::minus operator -(signed char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (true)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (true)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(8), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (true)>::template RType<_AP_W, false>::mult operator *(signed char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (true)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (true)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(8), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (true)>::template RType<_AP_W, false>::div operator /(signed char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (true)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (true)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(8), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (true)>::template RType<_AP_W, false>::mod operator %(signed char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (true)>(op2) % ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (false)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(8), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (false)>::template RType<_AP_W, false>::plus operator +(unsigned char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (false)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (false)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(8), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (false)>::template RType<_AP_W, false>::minus operator -(unsigned char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (false)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (false)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(8), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (false)>::template RType<_AP_W, false>::mult operator *(unsigned char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (false)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (false)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(8), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (false)>::template RType<_AP_W, false>::div operator /(unsigned char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (false)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (false)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(8), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (false)>::template RType<_AP_W, false>::mod operator %(unsigned char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (false)>(op2) % ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (true)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (true)>::template RType<_AP_W, false>::plus operator +(short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (true)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (true)>::template RType<_AP_W, false>::minus operator -(short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (true)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (true)>::template RType<_AP_W, false>::mult operator *(short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (true)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (true)>::template RType<_AP_W, false>::div operator /(short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (true)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (true)>::template RType<_AP_W, false>::mod operator %(short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) % ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (false)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (false)>::template RType<_AP_W, false>::plus operator +(unsigned short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (false)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (false)>::template RType<_AP_W, false>::minus operator -(unsigned short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (false)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (false)>::template RType<_AP_W, false>::mult operator *(unsigned short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (false)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (false)>::template RType<_AP_W, false>::div operator /(unsigned short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (false)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (false)>::template RType<_AP_W, false>::mod operator %(unsigned short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) % ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (true)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (true)>::template RType<_AP_W, false>::plus operator +(int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (true)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (true)>::template RType<_AP_W, false>::minus operator -(int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (true)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (true)>::template RType<_AP_W, false>::mult operator *(int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (true)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (true)>::template RType<_AP_W, false>::div operator /(int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (true)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (true)>::template RType<_AP_W, false>::mod operator %(int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) % ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (false)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (false)>::template RType<_AP_W, false>::plus operator +(unsigned int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (false)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (false)>::template RType<_AP_W, false>::minus operator -(unsigned int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (false)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (false)>::template RType<_AP_W, false>::mult operator *(unsigned int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (false)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (false)>::template RType<_AP_W, false>::div operator /(unsigned int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (false)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (false)>::template RType<_AP_W, false>::mod operator %(unsigned int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) % ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (true)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (true)>::template RType<_AP_W, false>::plus operator +(long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (true)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (true)>::template RType<_AP_W, false>::minus operator -(long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (true)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (true)>::template RType<_AP_W, false>::mult operator *(long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (true)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (true)>::template RType<_AP_W, false>::div operator /(long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (true)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (true)>::template RType<_AP_W, false>::mod operator %(long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) % ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (false)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (false)>::template RType<_AP_W, false>::plus operator +(unsigned long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (false)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (false)>::template RType<_AP_W, false>::minus operator -(unsigned long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (false)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (false)>::template RType<_AP_W, false>::mult operator *(unsigned long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (false)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (false)>::template RType<_AP_W, false>::div operator /(unsigned long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (false)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (false)>::template RType<_AP_W, false>::mod operator %(unsigned long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) % ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (true)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (true)>::template RType<_AP_W, false>::plus operator +(ap_slong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (true)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (true)>::template RType<_AP_W, false>::minus operator -(ap_slong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (true)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (true)>::template RType<_AP_W, false>::mult operator *(ap_slong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (true)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (true)>::template RType<_AP_W, false>::div operator /(ap_slong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (true)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (true)>::template RType<_AP_W, false>::mod operator %(ap_slong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) % ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (false)>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) + ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (false)>::template RType<_AP_W, false>::plus operator +(ap_ulong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) + ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (false)>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) - ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (false)>::template RType<_AP_W, false>::minus operator -(ap_ulong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) - ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (false)>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) * ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (false)>::template RType<_AP_W, false>::mult operator *(ap_ulong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) * ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (false)>::div operator /(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) / ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (false)>::template RType<_AP_W, false>::div operator /(ap_ulong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) / ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (false)>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) % ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (false)>::template RType<_AP_W, false>::mod operator %(ap_ulong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) % ap_int_base<_AP_W, false>(op); }
# 1111 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(1), (false)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(1), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(1), (false)>::template RType<_AP_W, false>::logic operator &(bool op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(1), (false)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(1), (false)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(1), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(1), (false)>::template RType<_AP_W, false>::logic operator |(bool op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(1), (false)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(1), (false)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(1), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(1), (false)>::template RType<_AP_W, false>::logic operator ^(bool op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(1), (false)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(1), (false)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(1), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(1), (false)>::template RType<_AP_W, false>::arg1 operator >>(bool op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(1), (false)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(1), (false)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, bool op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(1), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(1), (false)>::template RType<_AP_W, false>::arg1 operator <<(bool op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(1), (false)>(op2) << ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::logic operator &(char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::logic operator |(char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::logic operator ^(char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::arg1 operator >>(char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (CHAR_IS_SIGNED)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, char op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (CHAR_IS_SIGNED)>::template RType<_AP_W, false>::arg1 operator <<(char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) << ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (true)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(8), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (true)>::template RType<_AP_W, false>::logic operator &(signed char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (true)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (true)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(8), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (true)>::template RType<_AP_W, false>::logic operator |(signed char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (true)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (true)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(8), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (true)>::template RType<_AP_W, false>::logic operator ^(signed char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (true)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (true)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(8), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (true)>::template RType<_AP_W, false>::arg1 operator >>(signed char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (true)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (true)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(8), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (true)>::template RType<_AP_W, false>::arg1 operator <<(signed char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (true)>(op2) << ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (false)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(8), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (false)>::template RType<_AP_W, false>::logic operator &(unsigned char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (false)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (false)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(8), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (false)>::template RType<_AP_W, false>::logic operator |(unsigned char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (false)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (false)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(8), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (false)>::template RType<_AP_W, false>::logic operator ^(unsigned char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (false)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (false)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(8), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (false)>::template RType<_AP_W, false>::arg1 operator >>(unsigned char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (false)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(8), (false)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(8), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(8), (false)>::template RType<_AP_W, false>::arg1 operator <<(unsigned char op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(8), (false)>(op2) << ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (true)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (true)>::template RType<_AP_W, false>::logic operator &(short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (true)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (true)>::template RType<_AP_W, false>::logic operator |(short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (true)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (true)>::template RType<_AP_W, false>::logic operator ^(short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (true)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (true)>::template RType<_AP_W, false>::arg1 operator >>(short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (true)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, short op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (true)>::template RType<_AP_W, false>::arg1 operator <<(short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) << ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (false)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (false)>::template RType<_AP_W, false>::logic operator &(unsigned short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (false)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (false)>::template RType<_AP_W, false>::logic operator |(unsigned short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (false)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (false)>::template RType<_AP_W, false>::logic operator ^(unsigned short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (false)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (false)>::template RType<_AP_W, false>::arg1 operator >>(unsigned short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_short), (false)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_short), (false)>::template RType<_AP_W, false>::arg1 operator <<(unsigned short op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) << ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (true)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (true)>::template RType<_AP_W, false>::logic operator &(int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (true)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (true)>::template RType<_AP_W, false>::logic operator |(int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (true)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (true)>::template RType<_AP_W, false>::logic operator ^(int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (true)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (true)>::template RType<_AP_W, false>::arg1 operator >>(int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (true)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, int op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (true)>::template RType<_AP_W, false>::arg1 operator <<(int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) << ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (false)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (false)>::template RType<_AP_W, false>::logic operator &(unsigned int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (false)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (false)>::template RType<_AP_W, false>::logic operator |(unsigned int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (false)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (false)>::template RType<_AP_W, false>::logic operator ^(unsigned int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (false)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (false)>::template RType<_AP_W, false>::arg1 operator >>(unsigned int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_int), (false)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_int), (false)>::template RType<_AP_W, false>::arg1 operator <<(unsigned int op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) << ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (true)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (true)>::template RType<_AP_W, false>::logic operator &(long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (true)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (true)>::template RType<_AP_W, false>::logic operator |(long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (true)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (true)>::template RType<_AP_W, false>::logic operator ^(long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (true)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (true)>::template RType<_AP_W, false>::arg1 operator >>(long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (true)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, long op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (true)>::template RType<_AP_W, false>::arg1 operator <<(long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) << ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (false)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (false)>::template RType<_AP_W, false>::logic operator &(unsigned long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (false)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (false)>::template RType<_AP_W, false>::logic operator |(unsigned long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (false)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (false)>::template RType<_AP_W, false>::logic operator ^(unsigned long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (false)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (false)>::template RType<_AP_W, false>::arg1 operator >>(unsigned long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_long), (false)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_long), (false)>::template RType<_AP_W, false>::arg1 operator <<(unsigned long op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) << ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (true)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (true)>::template RType<_AP_W, false>::logic operator &(ap_slong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (true)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (true)>::template RType<_AP_W, false>::logic operator |(ap_slong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (true)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (true)>::template RType<_AP_W, false>::logic operator ^(ap_slong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (true)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (true)>::template RType<_AP_W, false>::arg1 operator >>(ap_slong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (true)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (true)>::template RType<_AP_W, false>::arg1 operator <<(ap_slong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) << ap_int_base<_AP_W, false>(op); }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (false)>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) & ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (false)>::template RType<_AP_W, false>::logic operator &(ap_ulong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) & ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (false)>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) | ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (false)>::template RType<_AP_W, false>::logic operator |(ap_ulong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) | ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (false)>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) ^ ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (false)>::template RType<_AP_W, false>::logic operator ^(ap_ulong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) ^ ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (false)>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) >> ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (false)>::template RType<_AP_W, false>::arg1 operator >>(ap_ulong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) >> ap_int_base<_AP_W, false>(op); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<(_AP_SIZE_ap_slong), (false)>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) << ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) typename ap_int_base<(_AP_SIZE_ap_slong), (false)>::template RType<_AP_W, false>::arg1 operator <<(ap_ulong op2, const ap_range_ref<_AP_W, _AP_S>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) << ap_int_base<_AP_W, false>(op); }
# 1139 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::plus operator +(const ap_range_ref<_AP_W, _AP_S>& lhs, const ap_range_ref<_AP_W2, _AP_S2>& rhs) { return (lhs.operator ap_int_base<_AP_W, false>())+( rhs.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::minus operator -(const ap_range_ref<_AP_W, _AP_S>& lhs, const ap_range_ref<_AP_W2, _AP_S2>& rhs) { return (lhs.operator ap_int_base<_AP_W, false>())-( rhs.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::mult operator *(const ap_range_ref<_AP_W, _AP_S>& lhs, const ap_range_ref<_AP_W2, _AP_S2>& rhs) { return (lhs.operator ap_int_base<_AP_W, false>())*( rhs.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::div operator /(const ap_range_ref<_AP_W, _AP_S>& lhs, const ap_range_ref<_AP_W2, _AP_S2>& rhs) { return (lhs.operator ap_int_base<_AP_W, false>())/( rhs.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::mod operator %(const ap_range_ref<_AP_W, _AP_S>& lhs, const ap_range_ref<_AP_W2, _AP_S2>& rhs) { return (lhs.operator ap_int_base<_AP_W, false>())%( rhs.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::logic operator &(const ap_range_ref<_AP_W, _AP_S>& lhs, const ap_range_ref<_AP_W2, _AP_S2>& rhs) { return (lhs.operator ap_int_base<_AP_W, false>())&( rhs.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::logic operator |(const ap_range_ref<_AP_W, _AP_S>& lhs, const ap_range_ref<_AP_W2, _AP_S2>& rhs) { return (lhs.operator ap_int_base<_AP_W, false>())|( rhs.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::logic operator ^(const ap_range_ref<_AP_W, _AP_S>& lhs, const ap_range_ref<_AP_W2, _AP_S2>& rhs) { return (lhs.operator ap_int_base<_AP_W, false>())^( rhs.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::arg1 operator >>(const ap_range_ref<_AP_W, _AP_S>& lhs, const ap_range_ref<_AP_W2, _AP_S2>& rhs) { return (lhs.operator ap_int_base<_AP_W, false>())>>( rhs.operator ap_int_base<_AP_W2, false>()); }
template <int _AP_W, bool _AP_S, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_int_base<_AP_W, false>::template RType<_AP_W2, false>::arg1 operator <<(const ap_range_ref<_AP_W, _AP_S>& lhs, const ap_range_ref<_AP_W2, _AP_S2>& rhs) { return (lhs.operator ap_int_base<_AP_W, false>())<<( rhs.operator ap_int_base<_AP_W2, false>()); }
# 1188 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
template <int _AP_LW1, typename _AP_LT1, int _AP_LW2, typename _AP_LT2, int _AP_RW1, typename _AP_RT1, int _AP_RW2, typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1 + _AP_LW2, false>::template RType< _AP_RW1 + _AP_RW2, false>::plus operator +( const ap_concat_ref<_AP_LW1, _AP_LT1, _AP_LW2, _AP_LT2>& lhs, const ap_concat_ref<_AP_RW1, _AP_RT1, _AP_RW2, _AP_RT2>& rhs) { return lhs.get() + rhs.get(); }
template <int _AP_LW1, typename _AP_LT1, int _AP_LW2, typename _AP_LT2, int _AP_RW1, typename _AP_RT1, int _AP_RW2, typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1 + _AP_LW2, false>::template RType< _AP_RW1 + _AP_RW2, false>::minus operator -( const ap_concat_ref<_AP_LW1, _AP_LT1, _AP_LW2, _AP_LT2>& lhs, const ap_concat_ref<_AP_RW1, _AP_RT1, _AP_RW2, _AP_RT2>& rhs) { return lhs.get() - rhs.get(); }
template <int _AP_LW1, typename _AP_LT1, int _AP_LW2, typename _AP_LT2, int _AP_RW1, typename _AP_RT1, int _AP_RW2, typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1 + _AP_LW2, false>::template RType< _AP_RW1 + _AP_RW2, false>::mult operator *( const ap_concat_ref<_AP_LW1, _AP_LT1, _AP_LW2, _AP_LT2>& lhs, const ap_concat_ref<_AP_RW1, _AP_RT1, _AP_RW2, _AP_RT2>& rhs) { return lhs.get() * rhs.get(); }
template <int _AP_LW1, typename _AP_LT1, int _AP_LW2, typename _AP_LT2, int _AP_RW1, typename _AP_RT1, int _AP_RW2, typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1 + _AP_LW2, false>::template RType< _AP_RW1 + _AP_RW2, false>::div operator /( const ap_concat_ref<_AP_LW1, _AP_LT1, _AP_LW2, _AP_LT2>& lhs, const ap_concat_ref<_AP_RW1, _AP_RT1, _AP_RW2, _AP_RT2>& rhs) { return lhs.get() / rhs.get(); }
template <int _AP_LW1, typename _AP_LT1, int _AP_LW2, typename _AP_LT2, int _AP_RW1, typename _AP_RT1, int _AP_RW2, typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1 + _AP_LW2, false>::template RType< _AP_RW1 + _AP_RW2, false>::mod operator %( const ap_concat_ref<_AP_LW1, _AP_LT1, _AP_LW2, _AP_LT2>& lhs, const ap_concat_ref<_AP_RW1, _AP_RT1, _AP_RW2, _AP_RT2>& rhs) { return lhs.get() % rhs.get(); }
template <int _AP_LW1, typename _AP_LT1, int _AP_LW2, typename _AP_LT2, int _AP_RW1, typename _AP_RT1, int _AP_RW2, typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1 + _AP_LW2, false>::template RType< _AP_RW1 + _AP_RW2, false>::logic operator &( const ap_concat_ref<_AP_LW1, _AP_LT1, _AP_LW2, _AP_LT2>& lhs, const ap_concat_ref<_AP_RW1, _AP_RT1, _AP_RW2, _AP_RT2>& rhs) { return lhs.get() & rhs.get(); }
template <int _AP_LW1, typename _AP_LT1, int _AP_LW2, typename _AP_LT2, int _AP_RW1, typename _AP_RT1, int _AP_RW2, typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1 + _AP_LW2, false>::template RType< _AP_RW1 + _AP_RW2, false>::logic operator |( const ap_concat_ref<_AP_LW1, _AP_LT1, _AP_LW2, _AP_LT2>& lhs, const ap_concat_ref<_AP_RW1, _AP_RT1, _AP_RW2, _AP_RT2>& rhs) { return lhs.get() | rhs.get(); }
template <int _AP_LW1, typename _AP_LT1, int _AP_LW2, typename _AP_LT2, int _AP_RW1, typename _AP_RT1, int _AP_RW2, typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1 + _AP_LW2, false>::template RType< _AP_RW1 + _AP_RW2, false>::logic operator ^( const ap_concat_ref<_AP_LW1, _AP_LT1, _AP_LW2, _AP_LT2>& lhs, const ap_concat_ref<_AP_RW1, _AP_RT1, _AP_RW2, _AP_RT2>& rhs) { return lhs.get() ^ rhs.get(); }
template <int _AP_LW1, typename _AP_LT1, int _AP_LW2, typename _AP_LT2, int _AP_RW1, typename _AP_RT1, int _AP_RW2, typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1 + _AP_LW2, false>::template RType< _AP_RW1 + _AP_RW2, false>::arg1 operator >>( const ap_concat_ref<_AP_LW1, _AP_LT1, _AP_LW2, _AP_LT2>& lhs, const ap_concat_ref<_AP_RW1, _AP_RT1, _AP_RW2, _AP_RT2>& rhs) { return lhs.get() >> rhs.get(); }
template <int _AP_LW1, typename _AP_LT1, int _AP_LW2, typename _AP_LT2, int _AP_RW1, typename _AP_RT1, int _AP_RW2, typename _AP_RT2> inline __attribute__((always_inline)) typename ap_int_base<_AP_LW1 + _AP_LW2, false>::template RType< _AP_RW1 + _AP_RW2, false>::arg1 operator <<( const ap_concat_ref<_AP_LW1, _AP_LT1, _AP_LW2, _AP_LT2>& lhs, const ap_concat_ref<_AP_RW1, _AP_RT1, _AP_RW2, _AP_RT2>& rhs) { return lhs.get() << rhs.get(); }
# 1335 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 1, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, bool op2) { ap_int_base<1 + _AP_W, false> val(op2); ap_int_base<1 + _AP_W, false> ret(op1); ret <<= 1; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 1, false> operator,( bool op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<1 + _AP_W, false> val(op1); ap_int_base<1 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 1; ret >>= 1; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 1, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, bool op2) { ap_int_base<1 + _AP_W, false> val(op2); ap_int_base<1 + _AP_W, false> ret(op1); ret <<= 1; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 1, false> operator,( bool op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<1 + _AP_W, false> val(op1); ap_int_base<1 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<1 + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, bool op2) { ap_int_base<1 + 1, false> val(op2); val[1] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<1 + 1, false> operator,( bool op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<1 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 1, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, bool op2) { ap_int_base<1 + _AP_W + _AP_W2, false> val(op2); ap_int_base<1 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 1; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 1, false> operator,( bool op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<1 + _AP_W + _AP_W2, false> val(op1); ap_int_base<1 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + 1, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, bool op2) { ap_int_base<1 + _AP_W, false> val(op2); ap_int_base<1 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 1; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + 1, false> operator,( bool op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<1 + _AP_W, false> val(op1); ap_int_base<1 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + 1, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, bool op2) { ap_int_base<1 + 1, false> val(op2); val[1] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + 1, false> operator,( bool op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<1 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (CHAR_IS_SIGNED) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( char op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 8; ret >>= 8; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (CHAR_IS_SIGNED) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( char op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false> operator,( char op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, char op2) { ap_int_base<8 + _AP_W + _AP_W2, CHAR_IS_SIGNED> val(op2); ap_int_base<8 + _AP_W + _AP_W2, CHAR_IS_SIGNED> ret(op1); if (CHAR_IS_SIGNED) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 8; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false> operator,( char op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<8 + _AP_W + _AP_W2, CHAR_IS_SIGNED> val(op1); ap_int_base<8 + _AP_W + _AP_W2, CHAR_IS_SIGNED> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); if (CHAR_IS_SIGNED) { val <<= _AP_W; val >>= _AP_W; } ret <<= 8; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( char op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + 8, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, char op2) { ap_int_base<8 + 1, CHAR_IS_SIGNED> val(op2); val[8] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + 8, false> operator,( char op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + 1, CHAR_IS_SIGNED> val(op1); val <<= 1; val[0] = op2; return val; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, signed char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( signed char op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 8; ret >>= 8; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, signed char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( signed char op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, signed char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false> operator,( signed char op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, signed char op2) { ap_int_base<8 + _AP_W + _AP_W2, true> val(op2); ap_int_base<8 + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 8; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false> operator,( signed char op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<8 + _AP_W + _AP_W2, true> val(op1); ap_int_base<8 + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, signed char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= 8; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( signed char op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + 8, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, signed char op2) { ap_int_base<8 + 1, true> val(op2); val[8] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + 8, false> operator,( signed char op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, unsigned char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( unsigned char op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); if (_AP_S) { ret <<= 8; ret >>= 8; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, unsigned char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); ret <<= 8; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( unsigned char op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, unsigned char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<8 + 1, false> operator,( unsigned char op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, unsigned char op2) { ap_int_base<8 + _AP_W + _AP_W2, false> val(op2); ap_int_base<8 + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= 8; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + 8, false> operator,( unsigned char op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<8 + _AP_W + _AP_W2, false> val(op1); ap_int_base<8 + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned char op2) { ap_int_base<8 + _AP_W, false> val(op2); ap_int_base<8 + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= 8; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + 8, false> operator,( unsigned char op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + _AP_W, false> val(op1); ap_int_base<8 + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + 8, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned char op2) { ap_int_base<8 + 1, false> val(op2); val[8] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + 8, false> operator,( unsigned char op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<8 + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, short op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op1); ret <<= _AP_SIZE_short; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( short op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op2); if (_AP_S) { ret <<= _AP_SIZE_short; ret >>= _AP_SIZE_short; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, short op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op1); ret <<= _AP_SIZE_short; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( short op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_short + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, short op2) { ap_int_base<_AP_SIZE_short + 1, false> val(op2); val[_AP_SIZE_short] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_short + 1, false> operator,( short op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_short + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_short, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, short op2) { ap_int_base<_AP_SIZE_short + _AP_W + _AP_W2, true> val(op2); ap_int_base<_AP_SIZE_short + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= _AP_SIZE_short; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_short, false> operator,( short op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<_AP_SIZE_short + _AP_W + _AP_W2, true> val(op1); ap_int_base<_AP_SIZE_short + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, short op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= _AP_SIZE_short; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( short op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_short, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, short op2) { ap_int_base<_AP_SIZE_short + 1, true> val(op2); val[_AP_SIZE_short] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_short, false> operator,( short op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_short + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, unsigned short op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op1); ret <<= _AP_SIZE_short; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( unsigned short op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op2); if (_AP_S) { ret <<= _AP_SIZE_short; ret >>= _AP_SIZE_short; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, unsigned short op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op1); ret <<= _AP_SIZE_short; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( unsigned short op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_short + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, unsigned short op2) { ap_int_base<_AP_SIZE_short + 1, false> val(op2); val[_AP_SIZE_short] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_short + 1, false> operator,( unsigned short op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_short + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_short, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, unsigned short op2) { ap_int_base<_AP_SIZE_short + _AP_W + _AP_W2, false> val(op2); ap_int_base<_AP_SIZE_short + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= _AP_SIZE_short; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_short, false> operator,( unsigned short op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<_AP_SIZE_short + _AP_W + _AP_W2, false> val(op1); ap_int_base<_AP_SIZE_short + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned short op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= _AP_SIZE_short; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_short, false> operator,( unsigned short op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_short + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_short + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_short, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned short op2) { ap_int_base<_AP_SIZE_short + 1, false> val(op2); val[_AP_SIZE_short] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_short, false> operator,( unsigned short op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_short + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, int op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op1); ret <<= _AP_SIZE_int; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( int op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op2); if (_AP_S) { ret <<= _AP_SIZE_int; ret >>= _AP_SIZE_int; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, int op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op1); ret <<= _AP_SIZE_int; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( int op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_int + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, int op2) { ap_int_base<_AP_SIZE_int + 1, false> val(op2); val[_AP_SIZE_int] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_int + 1, false> operator,( int op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_int + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_int, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, int op2) { ap_int_base<_AP_SIZE_int + _AP_W + _AP_W2, true> val(op2); ap_int_base<_AP_SIZE_int + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= _AP_SIZE_int; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_int, false> operator,( int op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<_AP_SIZE_int + _AP_W + _AP_W2, true> val(op1); ap_int_base<_AP_SIZE_int + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, int op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= _AP_SIZE_int; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( int op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_int, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, int op2) { ap_int_base<_AP_SIZE_int + 1, true> val(op2); val[_AP_SIZE_int] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_int, false> operator,( int op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_int + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, unsigned int op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op1); ret <<= _AP_SIZE_int; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( unsigned int op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op2); if (_AP_S) { ret <<= _AP_SIZE_int; ret >>= _AP_SIZE_int; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, unsigned int op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op1); ret <<= _AP_SIZE_int; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( unsigned int op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_int + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, unsigned int op2) { ap_int_base<_AP_SIZE_int + 1, false> val(op2); val[_AP_SIZE_int] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_int + 1, false> operator,( unsigned int op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_int + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_int, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, unsigned int op2) { ap_int_base<_AP_SIZE_int + _AP_W + _AP_W2, false> val(op2); ap_int_base<_AP_SIZE_int + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= _AP_SIZE_int; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_int, false> operator,( unsigned int op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<_AP_SIZE_int + _AP_W + _AP_W2, false> val(op1); ap_int_base<_AP_SIZE_int + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned int op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= _AP_SIZE_int; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_int, false> operator,( unsigned int op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_int + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_int + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_int, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned int op2) { ap_int_base<_AP_SIZE_int + 1, false> val(op2); val[_AP_SIZE_int] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_int, false> operator,( unsigned int op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_int + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, long op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op1); ret <<= _AP_SIZE_long; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( long op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op2); if (_AP_S) { ret <<= _AP_SIZE_long; ret >>= _AP_SIZE_long; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, long op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op1); ret <<= _AP_SIZE_long; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( long op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_long + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, long op2) { ap_int_base<_AP_SIZE_long + 1, false> val(op2); val[_AP_SIZE_long] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_long + 1, false> operator,( long op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_long + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_long, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, long op2) { ap_int_base<_AP_SIZE_long + _AP_W + _AP_W2, true> val(op2); ap_int_base<_AP_SIZE_long + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= _AP_SIZE_long; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_long, false> operator,( long op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<_AP_SIZE_long + _AP_W + _AP_W2, true> val(op1); ap_int_base<_AP_SIZE_long + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, long op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= _AP_SIZE_long; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( long op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_long, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, long op2) { ap_int_base<_AP_SIZE_long + 1, true> val(op2); val[_AP_SIZE_long] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_long, false> operator,( long op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_long + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, unsigned long op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op1); ret <<= _AP_SIZE_long; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( unsigned long op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op2); if (_AP_S) { ret <<= _AP_SIZE_long; ret >>= _AP_SIZE_long; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, unsigned long op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op1); ret <<= _AP_SIZE_long; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( unsigned long op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_long + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, unsigned long op2) { ap_int_base<_AP_SIZE_long + 1, false> val(op2); val[_AP_SIZE_long] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_long + 1, false> operator,( unsigned long op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_long + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_long, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, unsigned long op2) { ap_int_base<_AP_SIZE_long + _AP_W + _AP_W2, false> val(op2); ap_int_base<_AP_SIZE_long + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= _AP_SIZE_long; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_long, false> operator,( unsigned long op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<_AP_SIZE_long + _AP_W + _AP_W2, false> val(op1); ap_int_base<_AP_SIZE_long + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned long op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= _AP_SIZE_long; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_long, false> operator,( unsigned long op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_long + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_long + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_long, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, unsigned long op2) { ap_int_base<_AP_SIZE_long + 1, false> val(op2); val[_AP_SIZE_long] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_long, false> operator,( unsigned long op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_long + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, ap_slong op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op1); ret <<= _AP_SIZE_ap_slong; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( ap_slong op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op2); if (_AP_S) { ret <<= _AP_SIZE_ap_slong; ret >>= _AP_SIZE_ap_slong; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, ap_slong op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op1); ret <<= _AP_SIZE_ap_slong; if (true) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( ap_slong op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_ap_slong + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, ap_slong op2) { ap_int_base<_AP_SIZE_ap_slong + 1, false> val(op2); val[_AP_SIZE_ap_slong] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_ap_slong + 1, false> operator,( ap_slong op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_ap_slong + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_ap_slong, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, ap_slong op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W + _AP_W2, true> val(op2); ap_int_base<_AP_SIZE_ap_slong + _AP_W + _AP_W2, true> ret(op1); if (true) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= _AP_SIZE_ap_slong; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_ap_slong, false> operator,( ap_slong op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W + _AP_W2, true> val(op1); ap_int_base<_AP_SIZE_ap_slong + _AP_W + _AP_W2, true> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, ap_slong op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op1); if (true) { val <<= _AP_W; val >>= _AP_W; } ret <<= _AP_SIZE_ap_slong; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( ap_slong op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_ap_slong, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, ap_slong op2) { ap_int_base<_AP_SIZE_ap_slong + 1, true> val(op2); val[_AP_SIZE_ap_slong] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_ap_slong, false> operator,( ap_slong op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_ap_slong + 1, true> val(op1); val <<= 1; val[0] = op2; return val; }
template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( const ap_int_base<_AP_W, _AP_S> &op1, ap_ulong op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op1); ret <<= _AP_SIZE_ap_slong; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( ap_ulong op1, const ap_int_base<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op2); if (_AP_S) { ret <<= _AP_SIZE_ap_slong; ret >>= _AP_SIZE_ap_slong; } ret |= val << _AP_W; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( const ap_range_ref<_AP_W, _AP_S> &op1, ap_ulong op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op1); ret <<= _AP_SIZE_ap_slong; if (false) { val <<= _AP_W; val >>= _AP_W; } ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( ap_ulong op1, const ap_range_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_ap_slong + 1, false> operator,( const ap_bit_ref<_AP_W, _AP_S> &op1, ap_ulong op2) { ap_int_base<_AP_SIZE_ap_slong + 1, false> val(op2); val[_AP_SIZE_ap_slong] = op1; return val; } template <int _AP_W, bool _AP_S> inline __attribute__((always_inline)) ap_int_base<_AP_SIZE_ap_slong + 1, false> operator,( ap_ulong op1, const ap_bit_ref<_AP_W, _AP_S> &op2) { ap_int_base<_AP_SIZE_ap_slong + 1, false> val(op1); val <<= 1; val[0] = op2; return val; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_ap_slong, false> operator,( const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op1, ap_ulong op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W + _AP_W2, false> val(op2); ap_int_base<_AP_SIZE_ap_slong + _AP_W + _AP_W2, false> ret(op1); if (false) { val <<= _AP_W + _AP_W2; val >>= _AP_W + _AP_W2; } ret <<= _AP_SIZE_ap_slong; ret |= val; return ret; } template <int _AP_W, typename _AP_T, int _AP_W2, typename _AP_T2> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_W2 + _AP_SIZE_ap_slong, false> operator,( ap_ulong op1, const ap_concat_ref<_AP_W, _AP_T, _AP_W2, _AP_T2> &op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W + _AP_W2, false> val(op1); ap_int_base<_AP_SIZE_ap_slong + _AP_W + _AP_W2, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, ap_ulong op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op2); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op1); if (false) { val <<= _AP_W; val >>= _AP_W; } ret <<= _AP_SIZE_ap_slong; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<_AP_W + _AP_SIZE_ap_slong, false> operator,( ap_ulong op1, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> val(op1); ap_int_base<_AP_SIZE_ap_slong + _AP_W, false> ret(op2); int len = op2.length(); val <<= len; ret |= val; return ret; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_ap_slong, false> operator,( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op1, ap_ulong op2) { ap_int_base<_AP_SIZE_ap_slong + 1, false> val(op2); val[_AP_SIZE_ap_slong] = op1; return val; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_int_base<1 + _AP_SIZE_ap_slong, false> operator,( ap_ulong op1, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> &op2) { ap_int_base<_AP_SIZE_ap_slong + 1, false> val(op1); val <<= 1; val[0] = op2; return val; }
# 1359 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_ref.h"
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator <<( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, int rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() << int(rhs); }
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator <<( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned int rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() << int(rhs); }
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator <<( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, long rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() << int(rhs); }
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator <<( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned long rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() << int(rhs); }
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator <<( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_slong rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() << int(rhs); }
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator <<( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_ulong rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() << int(rhs); }
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator >>( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, int rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() >> int(rhs); }
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator >>( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned int rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() >> int(rhs); }
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator >>( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, long rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() >> int(rhs); }
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator >>( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, unsigned long rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() >> int(rhs); }
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator >>( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_slong rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() >> int(rhs); }
template <int _AP_W, typename _AP_T, int _AP_W1, typename _AP_T1> inline __attribute__((always_inline)) ap_uint<_AP_W + _AP_W1> operator >>( const ap_concat_ref<_AP_W, _AP_T, _AP_W1, _AP_T1> lhs, ap_ulong rhs) { return ap_uint<_AP_W + _AP_W1>(lhs).get() >> int(rhs); }
# 57 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int.h" 2
template <int _AP_W>
struct ap_int : ap_int_base<_AP_W, true> {
typedef ap_int_base<_AP_W, true> Base;
inline __attribute__((always_inline)) ap_int() : Base() {}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_int(const ap_int<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_int(const volatile ap_int<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_int(const ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_int(const volatile ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int(const ap_range_ref<_AP_W2, _AP_S2>& ref) : Base(ref) {}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int(const ap_bit_ref<_AP_W2, _AP_S2>& ref) : Base(ref) {}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_int(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& ref)
: Base(ref) {}
template <int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2,
int _AP_N2>
inline __attribute__((always_inline)) ap_int(const ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
template <int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2,
int _AP_N2>
inline __attribute__((always_inline)) ap_int(const ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {
}
template <int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2,
int _AP_N2>
inline __attribute__((always_inline)) ap_int(
const volatile ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
template <int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2,
int _AP_N2>
inline __attribute__((always_inline)) ap_int(
const volatile ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_int(const ap_int_base<_AP_W2, _AP_S2>& op) {
Base::V = op.V;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_int(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
inline __attribute__((always_inline)) ap_int(bool val) { Base::V = val; }
inline __attribute__((always_inline)) ap_int(char val) { Base::V = val; }
inline __attribute__((always_inline)) ap_int(signed char val) { Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned char val) { Base::V = val; }
inline __attribute__((always_inline)) ap_int(short val) { Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned short val) { Base::V = val; }
inline __attribute__((always_inline)) ap_int(int val) { Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned int val) { Base::V = val; }
inline __attribute__((always_inline)) ap_int(long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_int(unsigned long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_int(ap_slong val) { Base::V = val; }
inline __attribute__((always_inline)) ap_int(ap_ulong val) { Base::V = val; }
ap_int(double val) : Base(val) {}
ap_int(float val) : Base(val) {}
ap_int(half val) : Base(val) {}
inline __attribute__((always_inline)) ap_int(const char* s) : Base(s) {}
inline __attribute__((always_inline)) ap_int(const char* s, signed char rd) : Base(s, rd) {}
inline __attribute__((always_inline)) ap_int& operator=(const ap_int<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_int& operator=(const volatile ap_int<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) void operator=(const ap_int<_AP_W>& op2) volatile { Base::V = op2.V; }
inline __attribute__((always_inline)) void operator=(const volatile ap_int<_AP_W>& op2) volatile {
Base::V = op2.V;
}
};
template <int _AP_W>
struct ap_uint : ap_int_base<_AP_W, false> {
typedef ap_int_base<_AP_W, false> Base;
inline __attribute__((always_inline)) ap_uint() : Base() {}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_uint(const ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_uint(const ap_int<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_uint(const volatile ap_uint<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_uint(const volatile ap_int<_AP_W2>& op) {
Base::V = op.V;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_uint(const ap_range_ref<_AP_W2, _AP_S2>& ref) : Base(ref) {}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_uint(const ap_bit_ref<_AP_W2, _AP_S2>& ref) : Base(ref) {}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_uint(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& ref)
: Base(ref) {}
template <int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2,
int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
template <int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2,
int _AP_N2>
inline __attribute__((always_inline)) ap_uint(const ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {
}
template <int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2,
int _AP_N2>
inline __attribute__((always_inline)) ap_uint(
const volatile ap_fixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base((ap_fixed_base<_AP_W2, _AP_I2, true, _AP_Q2, _AP_O2, _AP_N2>)op) {}
template <int _AP_W2, int _AP_I2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2,
int _AP_N2>
inline __attribute__((always_inline)) ap_uint(
const volatile ap_ufixed<_AP_W2, _AP_I2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base((ap_fixed_base<_AP_W2, _AP_I2, false, _AP_Q2, _AP_O2, _AP_N2>)op) {
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_uint(const ap_int_base<_AP_W2, _AP_S2>& op) {
Base::V = op.V;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_uint(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
inline __attribute__((always_inline)) ap_uint(bool val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(char val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(signed char val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned char val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(short val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned short val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(int val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned int val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(unsigned long val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(ap_slong val) { Base::V = val; }
inline __attribute__((always_inline)) ap_uint(ap_ulong val) { Base::V = val; }
ap_uint(double val) : Base(val) {}
ap_uint(float val) : Base(val) {}
ap_uint(half val) : Base(val) {}
inline __attribute__((always_inline)) ap_uint(const char* s) : Base(s) {}
inline __attribute__((always_inline)) ap_uint(const char* s, signed char rd) : Base(s, rd) {}
inline __attribute__((always_inline)) ap_uint& operator=(const ap_uint<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) ap_uint& operator=(const volatile ap_uint<_AP_W>& op2) {
Base::V = op2.V;
return *this;
}
inline __attribute__((always_inline)) void operator=(const ap_uint<_AP_W>& op2) volatile { Base::V = op2.V; }
inline __attribute__((always_inline)) void operator=(const volatile ap_uint<_AP_W>& op2) volatile {
Base::V = op2.V;
}
};
# 341 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int.h"
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_special.h" 1
# 60 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_special.h"
namespace std {
template<typename _Tp> class complex;
}
namespace std {
# 88 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_special.h"
template <int _AP_W>
struct complex<ap_int<_AP_W> > {
typedef ap_int<_AP_W> _Tp;
typedef _Tp value_type;
complex() : _M_real(_Tp()), _M_imag(_Tp()) {}
complex(const _Tp &__r, const _Tp &__i = _Tp(0))
: _M_real(__r), _M_imag(__i) {}
template <typename _Up>
complex(const complex<_Up> &__z) : _M_real(__z.real()), _M_imag(__z.imag()) {}
_Tp& real() { return _M_real; }
const _Tp& real() const { return _M_real; }
_Tp& imag() { return _M_imag; }
const _Tp& imag() const { return _M_imag; }
void real(_Tp __val) { _M_real = __val; }
void imag(_Tp __val) { _M_imag = __val; }
complex<_Tp> &operator=(const _Tp __t) {
_M_real = __t;
_M_imag = _Tp(0);
return *this;
}
complex<_Tp> &operator+=(const _Tp &__t) {
_M_real += __t;
return *this;
}
complex<_Tp> &operator-=(const _Tp &__t) {
_M_real -= __t;
return *this;
}
complex<_Tp> &operator*=(const _Tp &__t) {
_M_real *= __t;
_M_imag *= __t;
return *this;
}
complex<_Tp> &operator/=(const _Tp &__t) {
_M_real /= __t;
_M_imag /= __t;
return *this;
}
template <typename _Up>
complex<_Tp> &operator=(const complex<_Up> &__z) {
_M_real = __z.real();
_M_imag = __z.imag();
return *this;
}
template <typename _Up>
complex<_Tp> &operator+=(const complex<_Up> &__z) {
_M_real += __z.real();
_M_imag += __z.imag();
return *this;
}
template <typename _Up>
complex<_Tp> &operator-=(const complex<_Up> &__z) {
_M_real -= __z.real();
_M_imag -= __z.imag();
return *this;
}
template <typename _Up>
complex<_Tp> &operator*=(const complex<_Up> &__z) {
const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
_M_imag = _M_real * __z.imag() + _M_imag * __z.real();
_M_real = __r;
return *this;
}
template <typename _Up>
complex<_Tp> &operator/=(const complex<_Up> &__z) {
complex<_Tp> cj (__z.real(), -__z.imag());
complex<_Tp> a = (*this) * cj;
complex<_Tp> b = cj * __z;
_M_real = a.real() / b.real();
_M_imag = a.imag() / b.real();
return *this;
}
private:
_Tp _M_real;
_Tp _M_imag;
};
# 220 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int_special.h"
template <int _AP_W>
inline bool operator==(const complex<ap_int<_AP_W> > &__x, const ap_int<_AP_W> &__y) {
return __x.real() == __y &&
__x.imag() == 0;
}
template <int _AP_W>
inline bool operator==(const ap_int<_AP_W> &__x, const complex<ap_int<_AP_W> > &__y) {
return __x == __y.real() &&
0 == __y.imag();
}
template <int _AP_W>
inline bool operator!=(const complex<ap_int<_AP_W> > &__x, const ap_int<_AP_W> &__y) {
return __x.real() != __y ||
__x.imag() != 0;
}
template <int _AP_W>
inline bool operator!=(const ap_int<_AP_W> &__x, const complex<ap_int<_AP_W> > &__y) {
return __x != __y.real() ||
0 != __y.imag();
}
}
# 342 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int.h" 2
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed.h" 1
# 55 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed.h"
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h" 1
# 61 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int.h" 1
# 62 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h" 2
# 132 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
template <int _AP_W2, int _AP_I2, bool _AP_S2>
struct _ap_fixed_factory;
template <int _AP_W2, int _AP_I2>
struct _ap_fixed_factory<_AP_W2, _AP_I2, true> {
typedef ap_fixed<_AP_W2, _AP_I2> type;
};
template <int _AP_W2, int _AP_I2>
struct _ap_fixed_factory<_AP_W2, _AP_I2, false> {
typedef ap_ufixed<_AP_W2, _AP_I2> type;
};
# 153 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
struct ap_fixed_base : ssdm_int<_AP_W, _AP_S> {
public:
typedef ssdm_int<_AP_W, _AP_S> Base;
static const int width = _AP_W;
static const int iwidth = _AP_I;
static const ap_q_mode qmode = _AP_Q;
static const ap_o_mode omode = _AP_O;
template <int _AP_W2, int _AP_I2, bool _AP_S2>
struct RType {
enum {
_AP_F = _AP_W - _AP_I,
F2 = _AP_W2 - _AP_I2,
mult_w = _AP_W + _AP_W2,
mult_i = _AP_I + _AP_I2,
mult_s = _AP_S || _AP_S2,
plus_w = ((_AP_I + (_AP_S2 && !_AP_S)) > (_AP_I2 + (_AP_S && !_AP_S2)) ? (_AP_I + (_AP_S2 && !_AP_S)) : (_AP_I2 + (_AP_S && !_AP_S2))) +
1 + ((_AP_F) > (F2) ? (_AP_F) : (F2)),
plus_i =
((_AP_I + (_AP_S2 && !_AP_S)) > (_AP_I2 + (_AP_S && !_AP_S2)) ? (_AP_I + (_AP_S2 && !_AP_S)) : (_AP_I2 + (_AP_S && !_AP_S2))) + 1,
plus_s = _AP_S || _AP_S2,
minus_w =
((_AP_I + (_AP_S2 && !_AP_S)) > (_AP_I2 + (_AP_S && !_AP_S2)) ? (_AP_I + (_AP_S2 && !_AP_S)) : (_AP_I2 + (_AP_S && !_AP_S2))) + 1 +
((_AP_F) > (F2) ? (_AP_F) : (F2)),
minus_i =
((_AP_I + (_AP_S2 && !_AP_S)) > (_AP_I2 + (_AP_S && !_AP_S2)) ? (_AP_I + (_AP_S2 && !_AP_S)) : (_AP_I2 + (_AP_S && !_AP_S2))) + 1,
minus_s = true,
div_w = _AP_S2 + _AP_W + ((F2) > (0) ? (F2) : (0)),
div_i = _AP_S2 + _AP_I + F2,
div_s = _AP_S || _AP_S2,
logic_w =
((_AP_I + (_AP_S2 && !_AP_S)) > (_AP_I2 + (_AP_S && !_AP_S2)) ? (_AP_I + (_AP_S2 && !_AP_S)) : (_AP_I2 + (_AP_S && !_AP_S2))) +
((_AP_F) > (F2) ? (_AP_F) : (F2)),
logic_i = ((_AP_I + (_AP_S2 && !_AP_S)) > (_AP_I2 + (_AP_S && !_AP_S2)) ? (_AP_I + (_AP_S2 && !_AP_S)) : (_AP_I2 + (_AP_S && !_AP_S2))),
logic_s = _AP_S || _AP_S2
};
typedef ap_fixed_base<_AP_W, _AP_I, _AP_S> lhs;
typedef ap_fixed_base<_AP_W2, _AP_I2, _AP_S2> rhs;
typedef ap_fixed_base<mult_w, mult_i, mult_s> mult_base;
typedef ap_fixed_base<plus_w, plus_i, plus_s> plus_base;
typedef ap_fixed_base<minus_w, minus_i, minus_s> minus_base;
typedef ap_fixed_base<logic_w, logic_i, logic_s> logic_base;
typedef ap_fixed_base<div_w, div_i, div_s> div_base;
typedef ap_fixed_base<_AP_W, _AP_I, _AP_S> arg1_base;
typedef typename _ap_fixed_factory<mult_w, mult_i, mult_s>::type mult;
typedef typename _ap_fixed_factory<plus_w, plus_i, plus_s>::type plus;
typedef typename _ap_fixed_factory<minus_w, minus_i, minus_s>::type minus;
typedef typename _ap_fixed_factory<logic_w, logic_i, logic_s>::type logic;
typedef typename _ap_fixed_factory<div_w, div_i, div_s>::type div;
typedef typename _ap_fixed_factory<_AP_W, _AP_I, _AP_S>::type arg1;
};
private:
# 332 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
inline __attribute__((always_inline)) void report() {}
inline __attribute__((always_inline)) void overflow_adjust(bool underflow, bool overflow, bool lD,
bool sign) {
if (!underflow && !overflow) return;
if (_AP_O == AP_WRAP) {
if (_AP_N == 0) return;
if (_AP_S) {
Base::V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(sign) __Repl2__ = !!sign; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - 1, _AP_W - 1); __Result__; });
if (_AP_N > 1) {
ap_int_base<_AP_W, false> mask(-1);
if (sign) mask.V = 0;
Base::V =
({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(mask.V) __Repl2__ = mask.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - _AP_N, _AP_W - 2); __Result__; });
}
} else {
ap_int_base<_AP_W, false> mask(-1);
Base::V =
({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(mask.V) __Repl2__ = mask.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - _AP_N, _AP_W - 1); __Result__; });
}
} else if (_AP_O == AP_SAT_ZERO) {
Base::V = 0;
} else if (_AP_O == AP_WRAP_SM && _AP_S) {
bool Ro = ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - 1); __Result__; });
if (_AP_N == 0) {
if (lD != Ro) {
Base::V = ~Base::V;
Base::V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(lD) __Repl2__ = !!lD; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - 1, _AP_W - 1); __Result__; });
}
} else {
if (_AP_N == 1 && sign != Ro) {
Base::V = ~Base::V;
} else if (_AP_N > 1) {
bool lNo = ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - _AP_N); __Result__; });
if (lNo == sign) Base::V = ~Base::V;
ap_int_base<_AP_W, false> mask(-1);
if (sign) mask.V = 0;
Base::V =
({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(mask.V) __Repl2__ = mask.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - _AP_N, _AP_W - 2); __Result__; });
}
Base::V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; typeof(sign) __Repl2__ = !!sign; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), _AP_W - 1, _AP_W - 1); __Result__; });
}
} else {
if (_AP_S) {
if (overflow) {
Base::V = 1;
Base::V <<= _AP_W - 1;
Base::V = ~Base::V;
} else if (underflow) {
Base::V = 1;
Base::V <<= _AP_W - 1;
if (_AP_O == AP_SAT_SYM) Base::V |= 1;
}
} else {
if (overflow)
Base::V = ~(ap_int_base<_AP_W, false>(0).V);
else if (underflow)
Base::V = 0;
}
}
}
inline __attribute__((always_inline)) bool quantization_adjust(bool qb, bool r, bool s) {
bool carry = (bool)({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - 1); __Result__; });
if (_AP_Q == AP_TRN) return false;
if (_AP_Q == AP_RND_ZERO)
qb &= s || r;
else if (_AP_Q == AP_RND_MIN_INF)
qb &= r;
else if (_AP_Q == AP_RND_INF)
qb &= !s || r;
else if (_AP_Q == AP_RND_CONV)
qb &= ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), 0); __Result__; }) || r;
else if (_AP_Q == AP_TRN_ZERO)
qb = s && (qb || r);
Base::V += qb;
return carry && (!(bool)({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - 1); __Result__; }));
}
public:
inline __attribute__((always_inline)) ap_fixed_base() {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
operator=(op);
report();
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base(
const volatile ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
operator=(op);
report();
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base(const ap_int_base<_AP_W2, _AP_S2>& op) {
ap_fixed_base<_AP_W2, _AP_W2, _AP_S2> tmp;
tmp.V = op.V;
operator=(tmp);
report();
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base(const volatile ap_int_base<_AP_W2, _AP_S2>& op) {
ap_fixed_base<_AP_W2, _AP_W2, _AP_S2> tmp;
tmp.V = op.V;
operator=(tmp);
report();
}
# 476 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
inline __attribute__((always_inline)) ap_fixed_base(const char* s) {
typeof(Base::V) t;
_ssdm_string2bits((void*)(&t), (const char*)(s), 10, _AP_I, _AP_S, _AP_Q,
_AP_O, _AP_N, true);
Base::V = t;
}
inline __attribute__((always_inline)) ap_fixed_base(const char* s, signed char rd) {
typeof(Base::V) t;
_ssdm_string2bits((void*)(&t), (const char*)(s), rd, _AP_I, _AP_S, _AP_Q,
_AP_O, _AP_N, true);
Base::V = t;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base(const ap_bit_ref<_AP_W2, _AP_S2>& op) {
*this = ((bool)op);
report();
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base(const ap_range_ref<_AP_W2, _AP_S2>& op) {
*this = (ap_int_base<_AP_W2, false>(op));
report();
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_fixed_base(
const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op) {
*this = (ap_int_base<_AP_W2 + _AP_W3, false>(op));
report();
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
*this = (bool(op));
report();
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
*this = (ap_int_base<_AP_W2, false>(op));
report();
}
# 534 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
inline __attribute__((always_inline)) ap_fixed_base(const bool x) { ap_fixed_base<(1), (1), (false)> tmp; tmp.V = x; *this = tmp; }
inline __attribute__((always_inline)) ap_fixed_base(const char x) { ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)> tmp; tmp.V = x; *this = tmp; }
inline __attribute__((always_inline)) ap_fixed_base(const signed char x) { ap_fixed_base<(8), (8), (true)> tmp; tmp.V = x; *this = tmp; }
inline __attribute__((always_inline)) ap_fixed_base(const unsigned char x) { ap_fixed_base<(8), (8), (false)> tmp; tmp.V = x; *this = tmp; }
inline __attribute__((always_inline)) ap_fixed_base(const short x) { ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)> tmp; tmp.V = x; *this = tmp; }
inline __attribute__((always_inline)) ap_fixed_base(const unsigned short x) { ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)> tmp; tmp.V = x; *this = tmp; }
inline __attribute__((always_inline)) ap_fixed_base(const int x) { ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)> tmp; tmp.V = x; *this = tmp; }
inline __attribute__((always_inline)) ap_fixed_base(const unsigned int x) { ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)> tmp; tmp.V = x; *this = tmp; }
inline __attribute__((always_inline)) ap_fixed_base(const long x) { ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)> tmp; tmp.V = x; *this = tmp; }
inline __attribute__((always_inline)) ap_fixed_base(const unsigned long x) { ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)> tmp; tmp.V = x; *this = tmp; }
inline __attribute__((always_inline)) ap_fixed_base(const ap_slong x) { ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)> tmp; tmp.V = x; *this = tmp; }
inline __attribute__((always_inline)) ap_fixed_base(const ap_ulong x) { ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)> tmp; tmp.V = x; *this = tmp; }
ap_fixed_base(double d) {
ap_int_base<64, false> ireg;
ireg.V = doubleToRawBits(d);
bool isneg = ({ typeof(ireg.V) __Val2__ = ireg.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), 63); __Result__; });
ap_int_base<11 + 1, true> exp;
ap_int_base<11, false> exp_tmp;
exp_tmp.V =
({ typename _ap_type::remove_const<typeof(ireg.V)>::type __Result__ = 0; typeof(ireg.V) __Val2__ = ireg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 52, 52 + 11 - 1); __Result__; });
exp = exp_tmp - ((1L << (11 - 1L)) - 1L);
ap_int_base<52 + 2, true> man;
man.V = ({ typename _ap_type::remove_const<typeof(ireg.V)>::type __Result__ = 0; typeof(ireg.V) __Val2__ = ireg.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, 52 - 1); __Result__; });
(static_cast<void>(0));
man.V = ({ typename _ap_type::remove_const<typeof(man.V)>::type __Result__ = 0; typeof(man.V) __Val2__ = man.V; typeof(1) __Repl2__ = !!1; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 52, 52); __Result__; });
if (isneg) man = -man;
if ((ireg.V & 0x7fffffffffffffffLL) == 0) {
Base::V = 0;
} else {
int _AP_W2 = 52 + 2, _AP_I2 = exp.V + 2, _AP_F = _AP_W - _AP_I,
F2 = _AP_W2 - _AP_I2;
bool _AP_S2 = true,
QUAN_INC = F2 > _AP_F &&
!(_AP_Q == AP_TRN || (_AP_Q == AP_TRN_ZERO && !_AP_S2));
bool carry = false;
unsigned sh_amt = (F2 > _AP_F) ? F2 - _AP_F : _AP_F - F2;
if (F2 == _AP_F)
Base::V = man.V;
else if (F2 > _AP_F) {
if (sh_amt < 52 + 2)
Base::V = man.V >> sh_amt;
else {
Base::V = isneg ? -1 : 0;
}
if ((_AP_Q != AP_TRN) && !((_AP_Q == AP_TRN_ZERO) && !_AP_S2)) {
bool qb = (F2 - _AP_F > _AP_W2) ? isneg : (bool)({ typeof(man.V) __Val2__ = man.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), F2 - _AP_F - 1); __Result__; });
bool r =
(F2 > _AP_F + 1)
? ({ typename _ap_type::remove_const<typeof(man.V)>::type __Result__ = 0; typeof(man.V) __Val2__ = man.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, (F2 - _AP_F - 2 < _AP_W2) ? (F2 - _AP_F - 2) : (_AP_W2 - 1)); __Result__; }) != 0
: false;
carry = quantization_adjust(qb, r, isneg);
}
} else {
Base::V = man.V;
if (sh_amt < _AP_W)
Base::V = Base::V << sh_amt;
else
Base::V = 0;
}
if ((_AP_O != AP_WRAP || _AP_N != 0) &&
((!_AP_S && _AP_S2) ||
_AP_I - _AP_S <
_AP_I2 - _AP_S2 +
(QUAN_INC ||
(_AP_S2 && (_AP_O == AP_SAT_SYM))))) {
bool deleted_zeros = _AP_S2 ? true : !carry, deleted_ones = true;
bool neg_src = isneg;
bool lD = false;
int pos1 = F2 - _AP_F + _AP_W;
int pos2 = F2 - _AP_F + _AP_W + 1;
bool newsignbit = ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - 1); __Result__; });
if (pos1 < _AP_W2 && pos1 >= 0)
lD = (man.V >> pos1) & 1;
if (pos1 < _AP_W2) {
bool Range1_all_ones = true;
bool Range1_all_zeros = true;
bool Range2_all_ones = true;
ap_int_base<52 + 2, false> Range2;
ap_int_base<52 + 2, false> all_ones(-1);
if (pos2 >= 0 && pos2 < _AP_W2) {
Range2.V = man.V;
Range2.V >>= pos2;
Range2_all_ones = Range2 == (all_ones >> pos2);
} else if (pos2 < 0)
Range2_all_ones = false;
if (pos1 >= 0 && pos2 < _AP_W2) {
Range1_all_ones = Range2_all_ones && lD;
Range1_all_zeros = !Range2.V && !lD;
} else if (pos2 == _AP_W2) {
Range1_all_ones = lD;
Range1_all_zeros = !lD;
} else if (pos1 < 0) {
Range1_all_zeros = !man.V;
Range1_all_ones = false;
}
deleted_zeros =
deleted_zeros && (carry ? Range1_all_ones : Range1_all_zeros);
deleted_ones =
carry ? Range2_all_ones && (pos1 < 0 || !lD) : Range1_all_ones;
neg_src = isneg && !(carry && Range1_all_ones);
} else
neg_src = isneg && newsignbit;
bool neg_trg = _AP_S && newsignbit;
bool overflow = (neg_trg || !deleted_zeros) && !isneg;
bool underflow = (!neg_trg || !deleted_ones) && neg_src;
if ((_AP_O == AP_SAT_SYM) && _AP_S2 && _AP_S)
underflow |=
neg_src &&
(_AP_W > 1 ? ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 2); __Result__; }) == 0
: true);
overflow_adjust(underflow, overflow, lD, neg_src);
}
}
report();
}
inline __attribute__((always_inline)) ap_fixed_base(float d) { *this = ap_fixed_base(double(d)); }
inline __attribute__((always_inline)) ap_fixed_base(half d) { *this = ap_fixed_base(double(d)); }
# 687 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base& operator=(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
const int _AP_F = _AP_W - _AP_I;
const int F2 = _AP_W2 - _AP_I2;
const int QUAN_INC =
F2 > _AP_F && !(_AP_Q == AP_TRN || (_AP_Q == AP_TRN_ZERO && !_AP_S2));
if (!op) Base::V = 0;
bool carry = false;
bool signbit = ({ typeof(op.V) __Val2__ = op.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W2 - 1); __Result__; });
bool isneg = signbit && _AP_S2;
if (F2 == _AP_F)
Base::V = op.V;
else if (F2 > _AP_F) {
unsigned int sh_amt = F2 - _AP_F;
if (sh_amt < _AP_W2) {
Base::V = op.V >> sh_amt;
} else {
Base::V = isneg ? -1 : 0;
}
if (_AP_Q != AP_TRN && !(_AP_Q == AP_TRN_ZERO && !_AP_S2)) {
bool qbit = ({ typeof(op.V) __Val2__ = op.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), F2 - _AP_F - 1); __Result__; });
bool qb = (F2 - _AP_F > _AP_W2) ? _AP_S2 && signbit : qbit;
enum { hi = ((F2 - _AP_F - 2) < _AP_W2) ? (F2 - _AP_F - 2) : (_AP_W2 - 1) };
bool r = (F2 > _AP_F + 1) ? (({ typename _ap_type::remove_const<typeof(op.V)>::type __Result__ = 0; typeof(op.V) __Val2__ = op.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, hi); __Result__; }) != 0) : false;
carry = quantization_adjust(qb, r, isneg);
}
} else {
unsigned sh_amt = _AP_F - F2;
if (sh_amt < _AP_W) {
if (_AP_W > _AP_W2) {
Base::V = op.V;
Base::V <<= sh_amt;
} else {
Base::V = op.V << sh_amt;
}
} else {
Base::V = 0;
}
}
if ((_AP_O != AP_WRAP || _AP_N != 0) &&
((!_AP_S && _AP_S2) ||
_AP_I - _AP_S <
_AP_I2 - _AP_S2 +
(QUAN_INC || (_AP_S2 && _AP_O == AP_SAT_SYM)))) {
bool deleted_zeros = _AP_S2 ? true : !carry;
bool deleted_ones = true;
bool neg_src = isneg;
bool newsignbit = ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - 1); __Result__; });
enum { pos1 = F2 - _AP_F + _AP_W, pos2 = F2 - _AP_F + _AP_W + 1 };
bool lD = (pos1 < _AP_W2 && pos1 >= 0) ? ({ typeof(op.V) __Val2__ = op.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), pos1); __Result__; })
: false;
if (pos1 < _AP_W2) {
bool Range1_all_ones = true;
bool Range1_all_zeros = true;
bool Range2_all_ones = true;
ap_int_base<_AP_W2, false> all_ones(-1);
if (pos2 < _AP_W2 && pos2 >= 0) {
ap_int_base<_AP_W2, false> Range2;
Range2.V = ({ typename _ap_type::remove_const<typeof(op.V)>::type __Result__ = 0; typeof(op.V) __Val2__ = op.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), pos2, _AP_W2 - 1); __Result__; });
Range2_all_ones = Range2 == (all_ones >> pos2);
} else if (pos2 < 0) {
Range2_all_ones = false;
}
if (pos1 >= 0 && pos2 < _AP_W2) {
ap_int_base<_AP_W2, false> Range1;
Range1.V = ({ typename _ap_type::remove_const<typeof(op.V)>::type __Result__ = 0; typeof(op.V) __Val2__ = op.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), pos1, _AP_W2 - 1); __Result__; });
Range1_all_ones = Range1 == (all_ones >> pos1);
Range1_all_zeros = !Range1.V;
} else if (pos2 == _AP_W2) {
Range1_all_ones = lD;
Range1_all_zeros = !lD;
} else if (pos1 < 0) {
Range1_all_zeros = !op.V;
Range1_all_ones = false;
}
deleted_zeros =
deleted_zeros && (carry ? Range1_all_ones : Range1_all_zeros);
deleted_ones =
carry ? Range2_all_ones && (pos1 < 0 || !lD) : Range1_all_ones;
neg_src = isneg && !(carry && Range1_all_ones);
} else
neg_src = isneg && newsignbit;
bool neg_trg = _AP_S && newsignbit;
bool overflow = (neg_trg || !deleted_zeros) && !isneg;
bool underflow = (!neg_trg || !deleted_ones) && neg_src;
if ((_AP_O == AP_SAT_SYM) && _AP_S2 && _AP_S)
underflow |=
neg_src &&
(_AP_W > 1 ? ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 2); __Result__; }) == 0
: true);
overflow_adjust(underflow, overflow, lD, neg_src);
}
return *this;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base& operator=(
const volatile ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
operator=(const_cast<const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(op));
return *this;
}
inline __attribute__((always_inline)) ap_fixed_base& setBits(ap_ulong bv) {
Base::V = bv;
return *this;
}
static inline __attribute__((always_inline)) ap_fixed_base bitsToFixed(ap_ulong bv) {
ap_fixed_base t;
t.V = bv;
return t;
}
inline __attribute__((always_inline)) ap_int_base<((_AP_I) > (1) ? (_AP_I) : (1)), _AP_S> to_ap_int_base(
bool Cnative = true) const {
ap_int_base<((_AP_I) > (1) ? (_AP_I) : (1)), _AP_S> ret;
if (_AP_I == 0) {
ret.V = 0;
} else if (_AP_I > 0 && _AP_I <= _AP_W) {
ret.V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), _AP_W - _AP_I, _AP_W - 1); __Result__; });
} else if (_AP_I > _AP_W) {
ret.V = ({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_W - 1); __Result__; });
ret.V <<= (_AP_I - _AP_W);
}
# 847 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
if (Cnative && _AP_I < _AP_W) {
if (_AP_S && ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - 1); __Result__; }) && (_AP_I < _AP_W) &&
(({ typename _ap_type::remove_const<typeof(Base::V)>::type __Result__ = 0; typeof(Base::V) __Val2__ = Base::V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, _AP_I < 0 ? _AP_W - 1 : _AP_W - _AP_I - 1); __Result__; }) != 0))
++ret;
} else {
}
return ret;
};
public:
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) operator ap_int_base<_AP_W2, _AP_S2>() const {
return ap_int_base<_AP_W2, _AP_S2>(to_ap_int_base());
}
inline __attribute__((always_inline)) char to_char() const { return to_ap_int_base().to_char(); }
inline __attribute__((always_inline)) int to_int() const { return to_ap_int_base().to_int(); }
inline __attribute__((always_inline)) unsigned to_uint() const { return to_ap_int_base().to_uint(); }
inline __attribute__((always_inline)) ap_slong to_int64() const { return to_ap_int_base().to_int64(); }
inline __attribute__((always_inline)) ap_ulong to_uint64() const { return to_ap_int_base().to_uint64(); }
inline __attribute__((always_inline)) double to_double() const {
enum { BITS = 52 + 11 + 1 };
if (!Base::V) return 0.0f;
bool s = _AP_S && ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - 1); __Result__; });
ap_int_base<_AP_W, false> tmp;
if (s)
tmp.V = -Base::V;
else
tmp.V = Base::V;
int l = tmp.countLeadingZeros();
int e = _AP_I - l - 1 + ((1L << (11 - 1L)) - 1L);
int lsb_index = _AP_W - l - 1 - 52;
bool a = (lsb_index >=2) ?
(({ typename _ap_type::remove_const<typeof(tmp.V)>::type __Result__ = 0; typeof(tmp.V) __Val2__ = tmp.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, lsb_index - 2); __Result__; }) != 0) : 0;
a |= (lsb_index >=0) ? ({ typeof(tmp.V) __Val2__ = tmp.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), lsb_index); __Result__; }) : 0;
ap_ulong m;
if (_AP_W > BITS) {
m = (lsb_index >= 1) ? (ap_ulong)(tmp.V >> (lsb_index - 1))
: (ap_ulong)(tmp.V << (1 - lsb_index));
} else {
m = (ap_ulong)tmp.V;
m = (lsb_index >= 1) ? (m >> (lsb_index - 1))
: (m << (1 - lsb_index));
}
m += a;
m >>= 1;
if (({ typeof(m) __Val2__ = m; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), 52 + 1); __Result__; })) {
e += 1;
}
m = ({ typename _ap_type::remove_const<typeof(m)>::type __Result__ = 0; typeof(m) __Val2__ = m; typeof(s) __Repl2__ = !!s; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), BITS - 1, BITS - 1); __Result__; });
m = ({ typename _ap_type::remove_const<typeof(m)>::type __Result__ = 0; typeof(m) __Val2__ = m; typeof(e) __Repl2__ = e; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 52, 52 + 11 - 1); __Result__; });
return rawBitsToDouble(m);
}
inline __attribute__((always_inline)) float to_float() const {
enum { BITS = 23 + 8 + 1 };
if (!Base::V) return 0.0f;
bool s = _AP_S && ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - 1); __Result__; });
ap_int_base<_AP_W, false> tmp;
if (s)
tmp.V = -Base::V;
else
tmp.V = Base::V;
int l = tmp.countLeadingZeros();
int e = _AP_I - l - 1 + ((1L << (8 - 1L)) - 1L);
int lsb_index = _AP_W - l - 1 - 23;
bool a = (lsb_index >=2) ?
(({ typename _ap_type::remove_const<typeof(tmp.V)>::type __Result__ = 0; typeof(tmp.V) __Val2__ = tmp.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, lsb_index - 2); __Result__; }) != 0) : 0;
a |= (lsb_index >=0) ? ({ typeof(tmp.V) __Val2__ = tmp.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), lsb_index); __Result__; }) : 0;
unsigned long m;
if (_AP_W > BITS) {
m = (lsb_index >= 1) ? (unsigned long)(tmp.V >> (lsb_index - 1))
: (unsigned long)(tmp.V << (1 - lsb_index));
} else {
m = (unsigned long)tmp.V;
m = (lsb_index >= 1) ? (m >> (lsb_index - 1))
: (m << (1 - lsb_index));
}
m += a;
m >>= 1;
if (({ typeof(m) __Val2__ = m; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), 23 + 1); __Result__; })) {
e += 1;
}
m = ({ typename _ap_type::remove_const<typeof(m)>::type __Result__ = 0; typeof(m) __Val2__ = m; typeof(s) __Repl2__ = !!s; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), BITS - 1, BITS - 1); __Result__; });
m = ({ typename _ap_type::remove_const<typeof(m)>::type __Result__ = 0; typeof(m) __Val2__ = m; typeof(e) __Repl2__ = e; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 23, 23 + 8 - 1); __Result__; });
return rawBitsToFloat(m);
}
inline __attribute__((always_inline)) half to_half() const {
enum { BITS = 10 + 5 + 1 };
if (!Base::V) return 0.0f;
bool s = _AP_S && ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - 1); __Result__; });
ap_int_base<_AP_W, false> tmp;
if (s)
tmp.V = -Base::V;
else
tmp.V = Base::V;
int l = tmp.countLeadingZeros();
int e = _AP_I - l - 1 + ((1L << (5 - 1L)) - 1L);
int lsb_index = _AP_W - l - 1 - 10;
bool a = (lsb_index >=2) ?
(({ typename _ap_type::remove_const<typeof(tmp.V)>::type __Result__ = 0; typeof(tmp.V) __Val2__ = tmp.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), 0, lsb_index - 2); __Result__; }) != 0) : 0;
a |= (lsb_index >=0) ? ({ typeof(tmp.V) __Val2__ = tmp.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), lsb_index); __Result__; }) : 0;
unsigned short m;
if (_AP_W > BITS) {
m = (lsb_index >= 1) ? (unsigned short)(tmp.V >> (lsb_index - 1))
: (unsigned short)(tmp.V << (1 - lsb_index));
} else {
m = (unsigned short)tmp.V;
m = (lsb_index >= 1) ? (m >> (lsb_index - 1))
: (m << (1 - lsb_index));
}
m += a;
m >>= 1;
if (({ typeof(m) __Val2__ = m; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), 10 + 1); __Result__; })) {
e += 1;
}
m = ({ typename _ap_type::remove_const<typeof(m)>::type __Result__ = 0; typeof(m) __Val2__ = m; typeof(s) __Repl2__ = !!s; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), BITS - 1, BITS - 1); __Result__; });
m = ({ typename _ap_type::remove_const<typeof(m)>::type __Result__ = 0; typeof(m) __Val2__ = m; typeof(e) __Repl2__ = e; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), 10, 10 + 5 - 1); __Result__; });
return rawBitsToHalf(m);
}
inline __attribute__((always_inline)) operator long double() const { return (long double)to_double(); }
inline __attribute__((always_inline)) operator double() const { return to_double(); }
inline __attribute__((always_inline)) operator float() const { return to_float(); }
inline __attribute__((always_inline)) operator half() const { return to_half(); }
inline __attribute__((always_inline)) operator bool() const { return (bool)Base::V != 0; }
inline __attribute__((always_inline)) operator char() const { return (char)to_int(); }
inline __attribute__((always_inline)) operator signed char() const { return (signed char)to_int(); }
inline __attribute__((always_inline)) operator unsigned char() const { return (unsigned char)to_uint(); }
inline __attribute__((always_inline)) operator short() const { return (short)to_int(); }
inline __attribute__((always_inline)) operator unsigned short() const { return (unsigned short)to_uint(); }
inline __attribute__((always_inline)) operator int() const { return to_int(); }
inline __attribute__((always_inline)) operator unsigned int() const { return to_uint(); }
inline __attribute__((always_inline)) operator long() const { return (long)to_int64(); }
inline __attribute__((always_inline)) operator unsigned long() const { return (unsigned long)to_uint64(); }
inline __attribute__((always_inline)) operator ap_ulong() const { return to_uint64(); }
inline __attribute__((always_inline)) operator ap_slong() const { return to_int64(); }
inline __attribute__((always_inline)) int length() const { return _AP_W; };
# 1073 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
inline __attribute__((always_inline)) int countLeadingZeros() {
if (_AP_W <= 32) {
ap_int_base<32, false> t(-1ULL);
t.range(_AP_W - 1, 0) = this->range(0, _AP_W - 1);
return __builtin_ctz(t.V);
} else if (_AP_W <= 64) {
ap_int_base<64, false> t(-1ULL);
t.range(_AP_W - 1, 0) = this->range(0, _AP_W - 1);
return __builtin_ctzll(t.V);
} else {
enum {__N = (_AP_W + 63) / 64};
int NZeros = 0;
int i = 0;
bool hitNonZero = false;
for (i = 0; i < __N - 1; ++i) {
ap_int_base<64, false> t;
t.range(0, 63) = this->range(_AP_W - i * 64 - 64, _AP_W - i * 64 - 1);
NZeros += hitNonZero ? 0 : __builtin_clzll(t.V);
hitNonZero |= (t != 0);
}
if (!hitNonZero) {
ap_int_base<64, false> t(-1ULL);
t.range(63 - (_AP_W - 1) % 64, 63) = this->range(0, (_AP_W - 1) % 64);
NZeros += __builtin_clzll(t.V);
}
return NZeros;
}
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) typename RType<_AP_W2, _AP_I2, _AP_S2>::mult operator*(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2)
const {
typename RType<_AP_W2, _AP_I2, _AP_S2>::mult_base r, t;
r.V = Base::V;
t.V = op2.V;
r.V *= op2.V;
return r;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) typename RType<_AP_W2, _AP_I2, _AP_S2>::div operator/(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2)
const {
typename RType<_AP_W2, _AP_I2, _AP_S2>::div_base r;
# 1143 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
ap_fixed_base<_AP_W + ((_AP_W2 - _AP_I2) > (0) ? (_AP_W2 - _AP_I2) : (0)),_AP_I, _AP_S> t(*this);
r.V = t.V / op2.V;
# 1176 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
return r;
}
# 1191 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2, _AP_I2, _AP_S2>::plus operator +( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) const { typename RType<_AP_W2, _AP_I2, _AP_S2>:: plus_base ret, lhs(*this), rhs(op2); ret.V = lhs.V + rhs.V; return ret; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2, _AP_I2, _AP_S2>::minus operator -( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) const { typename RType<_AP_W2, _AP_I2, _AP_S2>:: minus_base ret, lhs(*this), rhs(op2); ret.V = lhs.V - rhs.V; return ret; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2, _AP_I2, _AP_S2>::logic operator &( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) const { typename RType<_AP_W2, _AP_I2, _AP_S2>:: logic_base ret, lhs(*this), rhs(op2); ret.V = lhs.V & rhs.V; return ret; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2, _AP_I2, _AP_S2>::logic operator |( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) const { typename RType<_AP_W2, _AP_I2, _AP_S2>:: logic_base ret, lhs(*this), rhs(op2); ret.V = lhs.V | rhs.V; return ret; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) typename RType<_AP_W2, _AP_I2, _AP_S2>::logic operator ^( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) const { typename RType<_AP_W2, _AP_I2, _AP_S2>:: logic_base ret, lhs(*this), rhs(op2); ret.V = lhs.V ^ rhs.V; return ret; }
# 1209 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator *=( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) { *this = operator *(op2); return *this; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator /=( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) { *this = operator /(op2); return *this; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator +=( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) { *this = operator +(op2); return *this; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator -=( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) { *this = operator -(op2); return *this; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator &=( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) { *this = operator &(op2); return *this; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator |=( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) { *this = operator |(op2); return *this; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) ap_fixed_base& operator ^=( const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) { *this = operator ^(op2); return *this; }
inline __attribute__((always_inline)) ap_fixed_base& operator++() {
operator+=(ap_fixed_base<_AP_W - _AP_I + 1, 1, false>(1));
return *this;
}
inline __attribute__((always_inline)) ap_fixed_base& operator--() {
operator-=(ap_fixed_base<_AP_W - _AP_I + 1, 1, false>(1));
return *this;
}
inline __attribute__((always_inline)) const ap_fixed_base operator++(int) {
ap_fixed_base r(*this);
operator++();
return r;
}
inline __attribute__((always_inline)) const ap_fixed_base operator--(int) {
ap_fixed_base r(*this);
operator--();
return r;
}
inline __attribute__((always_inline)) ap_fixed_base operator+() { return *this; }
inline __attribute__((always_inline)) ap_fixed_base<_AP_W + 1, _AP_I + 1, true> operator-() const {
ap_fixed_base<_AP_W + 1, _AP_I + 1, true> r(*this);
r.V = -r.V;
return r;
}
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, true, _AP_Q, _AP_O, _AP_N> getNeg() {
ap_fixed_base<_AP_W, _AP_I, true, _AP_Q, _AP_O, _AP_N> r(*this);
r.V = -r.V;
return r;
}
inline __attribute__((always_inline)) bool operator!() const { return Base::V == 0; }
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S> operator~() const {
ap_fixed_base<_AP_W, _AP_I, _AP_S> r;
r.V = ~Base::V;
return r;
}
template <int _AP_SHIFT>
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I + _AP_SHIFT, _AP_S> lshift() const {
ap_fixed_base<_AP_W, _AP_I + _AP_SHIFT, _AP_S> r;
r.V = Base::V;
return r;
}
template <int _AP_SHIFT>
inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I - _AP_SHIFT, _AP_S> rshift() const {
ap_fixed_base<_AP_W, _AP_I - _AP_SHIFT, _AP_S> r;
r.V = Base::V;
return r;
}
inline __attribute__((always_inline)) ap_fixed_base operator<<(unsigned int sh) const {
ap_fixed_base r;
r.V = Base::V << sh;
# 1327 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
return r;
}
inline __attribute__((always_inline)) ap_fixed_base operator>>(unsigned int sh) const {
ap_fixed_base r;
r.V = Base::V >> sh;
# 1349 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
return r;
}
inline __attribute__((always_inline)) ap_fixed_base operator<<(int sh) const {
ap_fixed_base r;
bool isNeg = sh < 0;
unsigned int ush = isNeg ? -sh : sh;
if (isNeg) {
return operator>>(ush);
} else {
return operator<<(ush);
}
}
inline __attribute__((always_inline)) ap_fixed_base operator>>(int sh) const {
bool isNeg = sh < 0;
unsigned int ush = isNeg ? -sh : sh;
if (isNeg) {
return operator<<(ush);
} else {
return operator>>(ush);
}
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base operator<<(const ap_int_base<_AP_W2, true>& op2) const {
int sh = op2.to_int();
return operator<<(sh);
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base operator>>(const ap_int_base<_AP_W2, true>& op2) const {
int sh = op2.to_int();
return operator>>(sh);
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base operator<<(const ap_int_base<_AP_W2, false>& op2) const {
unsigned int sh = op2.to_uint();
return operator<<(sh);
}
template <int _AP_W2>
inline __attribute__((always_inline)) ap_fixed_base operator>>(const ap_int_base<_AP_W2, false>& op2) const {
unsigned int sh = op2.to_uint();
return operator>>(sh);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base operator<<(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&
op2) {
return operator<<(op2.to_ap_int_base());
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base operator>>(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&
op2) {
return operator>>(op2.to_ap_int_base());
}
inline __attribute__((always_inline)) ap_fixed_base& operator<<=(const int sh) {
*this = operator<<(sh);
return *this;
}
inline __attribute__((always_inline)) ap_fixed_base& operator<<=(const unsigned int sh) {
*this = operator<<(sh);
return *this;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base& operator<<=(const ap_int_base<_AP_W2, _AP_S2>& sh) {
*this = operator<<(sh.to_int());
return *this;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base& operator<<=(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&
sh) {
*this = operator<<(sh.to_int());
return *this;
}
inline __attribute__((always_inline)) ap_fixed_base& operator>>=(const int sh) {
*this = operator>>(sh);
return *this;
}
inline __attribute__((always_inline)) ap_fixed_base& operator>>=(const unsigned int sh) {
*this = operator>>(sh);
return *this;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed_base& operator>>=(const ap_int_base<_AP_W2, _AP_S2>& sh) {
*this = operator>>(sh.to_int());
return *this;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed_base& operator>>=(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&
sh) {
*this = operator>>(sh.to_int());
return *this;
}
# 1493 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator >(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) const { enum { _AP_F = _AP_W - _AP_I, F2 = _AP_W2 - _AP_I2 }; if (_AP_F == F2) return Base::V > op2.V; else if (_AP_F > F2) return Base::V > ap_fixed_base<((_AP_W2 + _AP_F - F2) > (1) ? (_AP_W2 + _AP_F - F2) : (1)), _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W + F2 - _AP_F + 1) > (1) ? (_AP_W + F2 - _AP_F + 1) : (1)), _AP_I + 1, _AP_S, _AP_Q, _AP_O, _AP_N>(*this).V > op2.V; return false; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator <(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) const { enum { _AP_F = _AP_W - _AP_I, F2 = _AP_W2 - _AP_I2 }; if (_AP_F == F2) return Base::V < op2.V; else if (_AP_F > F2) return Base::V < ap_fixed_base<((_AP_W2 + _AP_F - F2) > (1) ? (_AP_W2 + _AP_F - F2) : (1)), _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W + F2 - _AP_F + 1) > (1) ? (_AP_W + F2 - _AP_F + 1) : (1)), _AP_I + 1, _AP_S, _AP_Q, _AP_O, _AP_N>(*this).V < op2.V; return false; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator >=(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) const { enum { _AP_F = _AP_W - _AP_I, F2 = _AP_W2 - _AP_I2 }; if (_AP_F == F2) return Base::V >= op2.V; else if (_AP_F > F2) return Base::V >= ap_fixed_base<((_AP_W2 + _AP_F - F2) > (1) ? (_AP_W2 + _AP_F - F2) : (1)), _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W + F2 - _AP_F + 1) > (1) ? (_AP_W + F2 - _AP_F + 1) : (1)), _AP_I + 1, _AP_S, _AP_Q, _AP_O, _AP_N>(*this).V >= op2.V; return false; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator <=(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) const { enum { _AP_F = _AP_W - _AP_I, F2 = _AP_W2 - _AP_I2 }; if (_AP_F == F2) return Base::V <= op2.V; else if (_AP_F > F2) return Base::V <= ap_fixed_base<((_AP_W2 + _AP_F - F2) > (1) ? (_AP_W2 + _AP_F - F2) : (1)), _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W + F2 - _AP_F + 1) > (1) ? (_AP_W + F2 - _AP_F + 1) : (1)), _AP_I + 1, _AP_S, _AP_Q, _AP_O, _AP_N>(*this).V <= op2.V; return false; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator ==(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) const { enum { _AP_F = _AP_W - _AP_I, F2 = _AP_W2 - _AP_I2 }; if (_AP_F == F2) return Base::V == op2.V; else if (_AP_F > F2) return Base::V == ap_fixed_base<((_AP_W2 + _AP_F - F2) > (1) ? (_AP_W2 + _AP_F - F2) : (1)), _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W + F2 - _AP_F + 1) > (1) ? (_AP_W + F2 - _AP_F + 1) : (1)), _AP_I + 1, _AP_S, _AP_Q, _AP_O, _AP_N>(*this).V == op2.V; return false; }
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2, ap_o_mode _AP_O2, int _AP_N2> inline __attribute__((always_inline)) bool operator !=(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) const { enum { _AP_F = _AP_W - _AP_I, F2 = _AP_W2 - _AP_I2 }; if (_AP_F == F2) return Base::V != op2.V; else if (_AP_F > F2) return Base::V != ap_fixed_base<((_AP_W2 + _AP_F - F2) > (1) ? (_AP_W2 + _AP_F - F2) : (1)), _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>(op2).V; else return ap_fixed_base<((_AP_W + F2 - _AP_F + 1) > (1) ? (_AP_W + F2 - _AP_F + 1) : (1)), _AP_I + 1, _AP_S, _AP_Q, _AP_O, _AP_N>(*this).V != op2.V; return false; }
inline __attribute__((always_inline)) bool operator >(double d) const { return to_double() > d; }
inline __attribute__((always_inline)) bool operator <(double d) const { return to_double() < d; }
inline __attribute__((always_inline)) bool operator >=(double d) const { return to_double() >= d; }
inline __attribute__((always_inline)) bool operator <=(double d) const { return to_double() <= d; }
inline __attribute__((always_inline)) bool operator ==(double d) const { return to_double() == d; }
inline __attribute__((always_inline)) bool operator !=(double d) const { return to_double() != d; }
inline __attribute__((always_inline)) af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> operator[](
unsigned index) {
(static_cast<void>(0));
return af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, index);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> operator[](
const ap_int_base<_AP_W2, _AP_S2>& index) {
(static_cast<void>(0));
(static_cast<void>(0));
return af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this,
index.to_int());
}
inline __attribute__((always_inline)) bool operator[](unsigned index) const {
(static_cast<void>(0));
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), index); __Result__; });
}
inline __attribute__((always_inline)) af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> bit(
unsigned index) {
(static_cast<void>(0));
return af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, index);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> bit(
const ap_int_base<_AP_W2, _AP_S2>& index) {
(static_cast<void>(0));
(static_cast<void>(0));
return af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this,
index.to_int());
}
inline __attribute__((always_inline)) bool bit(unsigned index) const {
(static_cast<void>(0));
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), index); __Result__; });
}
template <int _AP_W2>
inline __attribute__((always_inline)) af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> get_bit(
const ap_int_base<_AP_W2, true>& index) {
(static_cast<void>(0));
(static_cast<void>(0));
return af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(
this, index.to_int() + _AP_W - _AP_I);
}
inline __attribute__((always_inline)) bool get_bit(int index) const {
(static_cast<void>(0));
(static_cast<void>(0));
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), index + _AP_W - _AP_I); __Result__; });
}
# 1579 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
template <int _AP_W2>
inline __attribute__((always_inline)) bool get_bit(const ap_int_base<_AP_W2, true>& index) const {
(static_cast<void>(0));
(static_cast<void>(0));
return ({ typeof(const_cast<ap_fixed_base*>(this)->V) __Val2__ = const_cast<ap_fixed_base*>(this)->V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), index.to_int() + _AP_W - _AP_I); __Result__; });
}
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> range(int Hi,
int Lo) {
(static_cast<void>(0));
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(this, Hi, Lo);
}
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> range(
int Hi, int Lo) const {
(static_cast<void>(0));
return af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>(
const_cast<ap_fixed_base*>(this), Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> range(
const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
const ap_int_base<_AP_W3, _AP_S3>& LoIdx) {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> range(
const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
const ap_int_base<_AP_W3, _AP_S3>& LoIdx) const {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> range() {
return this->range(_AP_W - 1, 0);
}
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> range() const {
return this->range(_AP_W - 1, 0);
}
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> operator()(
int Hi, int Lo) {
return this->range(Hi, Lo);
}
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> operator()(
int Hi, int Lo) const {
return this->range(Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> operator()(
const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
const ap_int_base<_AP_W3, _AP_S3>& LoIdx) {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
template <int _AP_W2, bool _AP_S2, int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> operator()(
const ap_int_base<_AP_W2, _AP_S2>& HiIdx,
const ap_int_base<_AP_W3, _AP_S3>& LoIdx) const {
int Hi = HiIdx.to_int();
int Lo = LoIdx.to_int();
return this->range(Hi, Lo);
}
inline __attribute__((always_inline)) bool is_zero() const { return Base::V == 0; }
inline __attribute__((always_inline)) bool is_neg() const {
if (_AP_S && ({ typeof(Base::V) __Val2__ = Base::V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), _AP_W - 1); __Result__; })) return true;
return false;
}
inline __attribute__((always_inline)) int wl() const { return _AP_W; }
inline __attribute__((always_inline)) int iwl() const { return _AP_I; }
inline __attribute__((always_inline)) ap_q_mode q_mode() const { return _AP_Q; }
inline __attribute__((always_inline)) ap_o_mode o_mode() const { return _AP_O; }
inline __attribute__((always_inline)) int n_bits() const { return _AP_N; }
# 1762 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
inline __attribute__((always_inline)) char* to_string(unsigned char radix = 2, bool sign = _AP_S) const {
return 0;
}
};
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline __attribute__((always_inline)) void b_not(
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) {
ret.V = ~op.V;
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline __attribute__((always_inline)) void b_and(
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V & op2.V;
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline __attribute__((always_inline)) void b_or(
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V | op2.V;
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline __attribute__((always_inline)) void b_xor(
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
ret.V = op1.V ^ op2.V;
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N, int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) void neg(
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
ap_fixed_base<_AP_W2 + !_AP_S2, _AP_I2 + !_AP_S2, true, _AP_Q2, _AP_O2,
_AP_N2>
t;
t.V = -op.V;
ret = t;
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N, int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) void lshift(
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op,
int i) {
enum {
F2 = _AP_W2 - _AP_I2,
_AP_I3 = ((_AP_I) > (_AP_I2) ? (_AP_I) : (_AP_I2)),
_AP_W3 = _AP_I3 + F2,
};
ap_fixed_base<_AP_W3, _AP_I3, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> t;
t.V = op.V;
t.V <<= i;
ret = t;
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N, int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) void rshift(
ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ret,
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op,
int i) {
enum {
F = _AP_W - _AP_I,
F2 = _AP_W2 - _AP_I2,
F3 = ((F) > (F2) ? (F) : (F2)),
_AP_W3 = _AP_I2 + F3,
sh = F - F2,
};
ap_fixed_base<_AP_W3, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> t;
t.V = op.V;
if (sh >= 0)
t.V <<= (int) sh;
t.V >>= i;
ret = t;
}
# 2212 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator +(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::plus operator +( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator -(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::minus operator -( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator *(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::mult operator *( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator /(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::div operator /( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator &(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::logic operator &( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator |(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::logic operator |( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator ^(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::logic operator ^( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator >>(ap_int_base<(1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (1), (1), (false)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator <<(ap_int_base<(1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator +=(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator -=(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator *=(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator /=(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator &=(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator |=(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator ^=(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator >>=(ap_int_base<(1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator <<=(ap_int_base<(1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator >(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator <(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator >=(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator <=(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator ==(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool i_op) { return op.operator !=(ap_fixed_base<(1), (1), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( bool i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(1), (1), (false)>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator +(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::plus operator +( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator -(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::minus operator -( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator *(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::mult operator *( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator /(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::div operator /( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator &(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::logic operator &( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator |(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::logic operator |( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator ^(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::logic operator ^( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator >>(ap_int_base<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (CHAR_IS_SIGNED)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator <<(ap_int_base<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator +=(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator -=(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator *=(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator /=(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator &=(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator |=(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator ^=(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator >>=(ap_int_base<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator <<=(ap_int_base<(8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator >(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator <(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator >=(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator <=(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator ==(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char i_op) { return op.operator !=(ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (CHAR_IS_SIGNED)>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator +(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::plus operator +( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator -(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::minus operator -( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator *(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::mult operator *( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator /(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::div operator /( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator &(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::logic operator &( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator |(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::logic operator |( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator ^(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::logic operator ^( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator >>(ap_int_base<(8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (true)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator <<(ap_int_base<(8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator +=(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator -=(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator *=(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator /=(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator &=(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator |=(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator ^=(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator >>=(ap_int_base<(8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator <<=(ap_int_base<(8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator >(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator <(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator >=(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator <=(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator ==(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char i_op) { return op.operator !=(ap_fixed_base<(8), (8), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( signed char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (true)>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator +(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::plus operator +( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator -(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::minus operator -( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator *(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::mult operator *( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator /(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::div operator /( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator &(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::logic operator &( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator |(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::logic operator |( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator ^(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::logic operator ^( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator >>(ap_int_base<(8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (8), (8), (false)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator <<(ap_int_base<(8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator +=(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator -=(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator *=(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator /=(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator &=(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator |=(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator ^=(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator >>=(ap_int_base<(8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator <<=(ap_int_base<(8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator >(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator <(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator >=(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator <=(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator ==(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char i_op) { return op.operator !=(ap_fixed_base<(8), (8), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned char i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(8), (8), (false)>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator +(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::plus operator +( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator -(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::minus operator -( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator *(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::mult operator *( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator /(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::div operator /( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator &(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::logic operator &( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator |(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::logic operator |( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator ^(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::logic operator ^( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator >>(ap_int_base<(_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (true)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator <<(ap_int_base<(_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator +=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator -=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator *=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator /=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator &=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator |=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator ^=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator >>=(ap_int_base<(_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator <<=(ap_int_base<(_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator >(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator <(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator >=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator <=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator ==(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short i_op) { return op.operator !=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (true)>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator +(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::plus operator +( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator -(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::minus operator -( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator *(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::mult operator *( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator /(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::div operator /( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator &(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::logic operator &( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator |(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::logic operator |( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator ^(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::logic operator ^( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator >>(ap_int_base<(_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_short), (_AP_SIZE_short), (false)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator <<(ap_int_base<(_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator +=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator -=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator *=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator /=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator &=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator |=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator ^=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator >>=(ap_int_base<(_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator <<=(ap_int_base<(_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator >(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator <(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator >=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator <=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator ==(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short i_op) { return op.operator !=(ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned short i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_short), (_AP_SIZE_short), (false)>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator +(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::plus operator +( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator -(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::minus operator -( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator *(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::mult operator *( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator /(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::div operator /( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator &(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::logic operator &( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator |(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::logic operator |( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator ^(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::logic operator ^( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator >>(ap_int_base<(_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (true)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator <<(ap_int_base<(_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator +=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator -=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator *=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator /=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator &=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator |=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator ^=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator >>=(ap_int_base<(_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator <<=(ap_int_base<(_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator >(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator <(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator >=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator <=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator ==(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int i_op) { return op.operator !=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (true)>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator +(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::plus operator +( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator -(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::minus operator -( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator *(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::mult operator *( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator /(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::div operator /( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator &(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::logic operator &( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator |(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::logic operator |( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator ^(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::logic operator ^( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator >>(ap_int_base<(_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_int), (_AP_SIZE_int), (false)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator <<(ap_int_base<(_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator +=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator -=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator *=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator /=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator &=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator |=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator ^=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator >>=(ap_int_base<(_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator <<=(ap_int_base<(_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator >(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator <(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator >=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator <=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator ==(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int i_op) { return op.operator !=(ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned int i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_int), (_AP_SIZE_int), (false)>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator +(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::plus operator +( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator -(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::minus operator -( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator *(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::mult operator *( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator /(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::div operator /( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator &(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::logic operator &( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator |(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::logic operator |( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator ^(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::logic operator ^( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator >>(ap_int_base<(_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (true)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator <<(ap_int_base<(_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator +=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator -=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator *=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator /=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator &=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator |=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator ^=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator >>=(ap_int_base<(_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator <<=(ap_int_base<(_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator >(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator <(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator >=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator <=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator ==(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long i_op) { return op.operator !=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (true)>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator +(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::plus operator +( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator -(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::minus operator -( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator *(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::mult operator *( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator /(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::div operator /( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator &(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::logic operator &( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator |(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::logic operator |( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator ^(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::logic operator ^( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator >>(ap_int_base<(_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_long), (_AP_SIZE_long), (false)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator <<(ap_int_base<(_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator +=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator -=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator *=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator /=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator &=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator |=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator ^=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator >>=(ap_int_base<(_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator <<=(ap_int_base<(_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator >(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator <(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator >=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator <=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator ==(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long i_op) { return op.operator !=(ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned long i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_long), (_AP_SIZE_long), (false)>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator +(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::plus operator +( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator -(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::minus operator -( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator *(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::mult operator *( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator /(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::div operator /( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator &(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::logic operator &( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator |(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::logic operator |( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator ^(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::logic operator ^( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator >>(ap_int_base<(_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator <<(ap_int_base<(_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator +=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator -=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator *=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator /=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator &=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator |=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator ^=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator >>=(ap_int_base<(_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator <<=(ap_int_base<(_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator >(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator <(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator >=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator <=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator ==(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong i_op) { return op.operator !=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( ap_slong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (true)>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator +(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::plus operator +( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator -(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::minus operator -( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator *(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::mult operator *( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator /(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::div operator /( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator &(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::logic operator &( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator |(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::logic operator |( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator ^(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::logic operator ^( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::lhs operator >>( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator >>(ap_int_base<(_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< (_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>::lhs operator <<( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator <<(ap_int_base<(_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator +=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator -=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator *=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator /=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator &=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator |=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator ^=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator >>=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator >>=(ap_int_base<(_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator <<=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator <<=(ap_int_base<(_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator >(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator >(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator <(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator <(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator >=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator >=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator <=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator <=(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator ==(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator ==(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong i_op) { return op.operator !=(ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( ap_ulong i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<(_AP_SIZE_ap_slong), (_AP_SIZE_ap_slong), (false)>(i_op).operator !=(op); }
# 2300 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_base.h"
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>::template RType< _AP_W, _AP_I, _AP_S>::plus operator +( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator +(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< _AP_W2, _AP_W2, _AP_S2>::plus operator +( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator +(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>::template RType< _AP_W, _AP_I, _AP_S>::minus operator -( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator -(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< _AP_W2, _AP_W2, _AP_S2>::minus operator -( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator -(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>::template RType< _AP_W, _AP_I, _AP_S>::mult operator *( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator *(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< _AP_W2, _AP_W2, _AP_S2>::mult operator *( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator *(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>::template RType< _AP_W, _AP_I, _AP_S>::div operator /( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator /(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< _AP_W2, _AP_W2, _AP_S2>::div operator /( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator /(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>::template RType< _AP_W, _AP_I, _AP_S>::logic operator &( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator &(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< _AP_W2, _AP_W2, _AP_S2>::logic operator &( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator &(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>::template RType< _AP_W, _AP_I, _AP_S>::logic operator |( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator |(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< _AP_W2, _AP_W2, _AP_S2>::logic operator |( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator |(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>::template RType< _AP_W, _AP_I, _AP_S>::logic operator ^( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator ^(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) typename ap_fixed_base<_AP_W, _AP_I, _AP_S>::template RType< _AP_W2, _AP_W2, _AP_S2>::logic operator ^( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator ^(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator +=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator +=(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2, _AP_S2>& operator +=( ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return i_op.operator +=(op.to_ap_int_base()); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator -=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator -=(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2, _AP_S2>& operator -=( ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return i_op.operator -=(op.to_ap_int_base()); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator *=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator *=(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2, _AP_S2>& operator *=( ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return i_op.operator *=(op.to_ap_int_base()); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator /=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator /=(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2, _AP_S2>& operator /=( ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return i_op.operator /=(op.to_ap_int_base()); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator &=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator &=(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2, _AP_S2>& operator &=( ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return i_op.operator &=(op.to_ap_int_base()); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator |=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator |=(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2, _AP_S2>& operator |=( ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return i_op.operator |=(op.to_ap_int_base()); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& operator ^=( ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator ^=(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) ap_int_base<_AP_W2, _AP_S2>& operator ^=( ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return i_op.operator ^=(op.to_ap_int_base()); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator ==( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator ==(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator ==( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator ==(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator !=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator !=(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator !=( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator !=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator >(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator >(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator >=(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >=( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator >=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator <(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator <(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <=( const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& i_op) { return op.operator <=(ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op)); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <=( const ap_int_base<_AP_W2, _AP_S2>& i_op, const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_fixed_base<_AP_W2, _AP_W2, _AP_S2>(i_op).operator <=(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline __attribute__((always_inline)) bool operator==(
double op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
return op2.operator==(op1);
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline __attribute__((always_inline)) bool operator!=(
double op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
return op2.operator!=(op1);
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline __attribute__((always_inline)) bool operator>(
double op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
return op2.operator<(op1);
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline __attribute__((always_inline)) bool operator>=(
double op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
return op2.operator<=(op1);
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline __attribute__((always_inline)) bool operator<(
double op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
return op2.operator>(op1);
}
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
inline __attribute__((always_inline)) bool operator<=(
double op1,
const ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op2) {
return op2.operator>=(op1);
}
# 56 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed.h" 2
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_ref.h" 1
# 69 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_ref.h"
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
struct af_bit_ref {
typedef ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> ref_type;
ref_type& d_bv;
int d_index;
public:
inline __attribute__((always_inline)) af_bit_ref(
const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ref)
: d_bv(ref.d_bv), d_index(ref.d_index) {
}
inline __attribute__((always_inline)) af_bit_ref(ref_type* bv, int index = 0) : d_bv(*bv), d_index(index) {}
inline __attribute__((always_inline)) af_bit_ref(const ref_type* bv, int index = 0)
: d_bv(*const_cast<ref_type*>(bv)), d_index(index) {}
inline __attribute__((always_inline)) operator bool() const { return ({ typeof(d_bv.V) __Val2__ = d_bv.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), d_index); __Result__; }); }
inline __attribute__((always_inline)) af_bit_ref& operator=(bool val) {
d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val) __Repl2__ = !!val; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), d_index, d_index); __Result__; });
return *this;
}
inline __attribute__((always_inline)) af_bit_ref& operator=(const af_bit_ref& val) {
return operator=(bool(val));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_bit_ref& operator=(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=(bool(val));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref& operator=(const ap_bit_ref<_AP_W2, _AP_S2>& val) {
return operator=(bool(val));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref& operator=(const ap_int_base<_AP_W2, _AP_S2>& val) {
return operator=(val != 0);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_bit_ref& operator=(const ap_range_ref<_AP_W2, _AP_S2>& val) {
return operator=(ap_int_base<_AP_W2, false>(val));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_bit_ref& operator=(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
return operator=(ap_int_base<_AP_W2, false>(val));
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) af_bit_ref& operator=(
const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
return operator=(ap_int_base<_AP_W2 + _AP_W3, false>(val));
}
template <int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(ap_int_base<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >(
*this, op);
}
template <int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> > operator,(
const ap_bit_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<1, af_bit_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >(*this,
op);
}
template <int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator,(const ap_range_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >(
*this, op);
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator,(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &op) {
return ap_concat_ref<1, af_bit_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(*this,
op);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<
1, af_bit_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator,(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> &op) {
return ap_concat_ref<
1, af_bit_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(*this,
op);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_concat_ref<1, af_bit_ref, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> >
operator,(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> &op) {
return ap_concat_ref<1, af_bit_ref, 1, af_bit_ref<_AP_W2, _AP_I2, _AP_S2,
_AP_Q2, _AP_O2, _AP_N2> >(
*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(
op));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator==(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
return get() == op.get();
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator!=(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op) {
return get() != op.get();
}
inline __attribute__((always_inline)) bool operator~() const {
bool bit = ({ typeof(d_bv.V) __Val2__ = d_bv.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), d_index); __Result__; });
return bit ? false : true;
}
inline __attribute__((always_inline)) bool get() const { return ({ typeof(d_bv.V) __Val2__ = d_bv.V; bool __Result__ = __builtin_bit_select((void*)(&__Val2__), d_index); __Result__; }); }
inline __attribute__((always_inline)) int length() const { return 1; }
inline __attribute__((always_inline)) char* to_string() const { return 0; }
};
# 256 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_ref.h"
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O,
int _AP_N>
struct af_range_ref {
typedef ap_fixed_base<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N> ref_type;
ref_type& d_bv;
int l_index;
int h_index;
public:
inline __attribute__((always_inline)) af_range_ref(
const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& ref)
: d_bv(ref.d_bv), l_index(ref.l_index), h_index(ref.h_index) {}
inline __attribute__((always_inline)) af_range_ref(ref_type* bv, int h, int l)
: d_bv(*bv), l_index(l), h_index(h) {
# 286 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_ref.h"
}
inline __attribute__((always_inline)) af_range_ref(const ref_type* bv, int h, int l)
: d_bv(*const_cast<ref_type*>(bv)), l_index(l), h_index(h) {
# 298 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_ref.h"
}
# 310 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_ref.h"
inline __attribute__((always_inline)) af_range_ref& operator=(const bool val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const char val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const signed char val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const unsigned char val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const short val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const unsigned short val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const int val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const unsigned int val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const unsigned long val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const ap_slong val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const ap_ulong val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const half val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const float val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const double val) { ap_int_base<_AP_W, false> loc(val); d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(loc.V) __Repl2__ = loc.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; }); return *this; }
inline __attribute__((always_inline)) af_range_ref& operator=(const char* val) {
const ap_int_base<_AP_W, false> tmp(val);
d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(tmp.V) __Repl2__ = tmp.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
template <int _AP_W3, bool _AP_S3>
inline __attribute__((always_inline)) af_range_ref& operator=(const ap_int_base<_AP_W3, _AP_S3>& val) {
d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val.V) __Repl2__ = val.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_range_ref& operator=(const ap_range_ref<_AP_W2, _AP_S2>& val) {
const ap_int_base<_AP_W2, false> tmp(val);
return operator=(tmp);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) af_range_ref& operator=(const ap_bit_ref<_AP_W2, _AP_S2>& val) {
const ap_int_base<1, false> tmp((bool)val);
return operator=(tmp);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_range_ref& operator=(
const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&
val) {
d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val.V) __Repl2__ = val.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
return *this;
}
inline __attribute__((always_inline)) af_range_ref& operator=(const af_range_ref& val) {
ap_int_base<_AP_W, false> tmp(val);
return operator=(tmp);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_range_ref& operator=(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
ap_int_base<_AP_W2, false> tmp(val);
return operator=(tmp);
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) af_range_ref& operator=(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& val) {
ap_int_base<1, false> tmp((bool)val);
return operator=(tmp);
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) af_range_ref& operator=(
const ap_concat_ref<_AP_W2, _AP_T3, _AP_W3, _AP_T3>& val) {
const ap_int_base<_AP_W2 + _AP_W3, false> tmp(val);
return operator=(tmp);
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator==(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop == rop;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator!=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator==(op2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator<(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop < rop;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator>(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop > rop;
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator<=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator>(op2));
}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) bool operator>=(const ap_range_ref<_AP_W2, _AP_S2>& op2) {
return !(operator<(op2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator==(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop == rop;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator!=(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator==(op2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator<(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop < rop;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator>(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) {
ap_int_base<_AP_W, false> lop(*this);
ap_int_base<_AP_W2, false> rop(op2);
return lop > rop;
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator<=(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator>(op2));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) bool operator>=(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op2) {
return !(operator<(op2));
}
template <int _AP_W2, int _AP_S2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, af_range_ref, _AP_W2, ap_int_base<_AP_W2, _AP_S2> >
operator,(ap_int_base<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
ap_int_base<_AP_W2, _AP_S2> >(*this, op);
}
template <int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >
operator,(const ap_bit_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, 1, ap_bit_ref<_AP_W2, _AP_S2> >(
*this, const_cast<ap_bit_ref<_AP_W2, _AP_S2>&>(op));
}
template <int _AP_W2, int _AP_S2>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2, ap_range_ref<_AP_W2, _AP_S2> >
operator,(const ap_range_ref<_AP_W2, _AP_S2> &op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
ap_range_ref<_AP_W2, _AP_S2> >(
*this, const_cast<ap_range_ref<_AP_W2, _AP_S2>&>(op));
}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_concat_ref<_AP_W, af_range_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >
operator,(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> &op) {
return ap_concat_ref<_AP_W, af_range_ref, _AP_W2 + _AP_W3,
ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3> >(
*this, const_cast<ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>&>(op));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, af_range_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator,(const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>
&op) {
return ap_concat_ref<
_AP_W, af_range_ref, _AP_W2,
af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(
*this,
const_cast<af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(
op));
}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline))
ap_concat_ref<_AP_W, af_range_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >
operator,(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> &op) {
return ap_concat_ref<
_AP_W, af_range_ref, 1,
af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2> >(
*this,
const_cast<af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>&>(
op));
}
inline __attribute__((always_inline)) operator ap_ulong() const {
ap_int_base<_AP_W, false> ret;
ret.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret.to_uint64();
}
inline __attribute__((always_inline)) operator ap_int_base<_AP_W, false>() const {
ap_int_base<_AP_W, false> ret;
ret.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret;
}
inline __attribute__((always_inline)) ap_int_base<_AP_W, false> to_ap_int_base() const {
ap_int_base<_AP_W, false> ret;
ret.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret;
}
inline __attribute__((always_inline)) char to_char() const {
return (char)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) int to_int() const {
return (int)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned to_uint() const {
return (unsigned)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) long to_long() const {
return (long)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) unsigned long to_ulong() const {
return (unsigned long)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_slong to_int64() const {
return (ap_slong)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_ulong to_uint64() const {
return (ap_ulong)(({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; }));
}
inline __attribute__((always_inline)) ap_int_base<_AP_W, false> get() const {
ap_int_base<_AP_W, false> ret;
ret.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; __builtin_bit_part_select((void*)(&__Result__), (void*)(&__Val2__), l_index, h_index); __Result__; });
return ret;
}
template <int _AP_W2>
inline __attribute__((always_inline)) void set(const ap_int_base<_AP_W2, false>& val) {
d_bv.V = ({ typename _ap_type::remove_const<typeof(d_bv.V)>::type __Result__ = 0; typeof(d_bv.V) __Val2__ = d_bv.V; typeof(val.V) __Repl2__ = val.V; __builtin_bit_part_set((void*)(&__Result__), (void*)(&__Val2__), (void*)(&__Repl2__), l_index, h_index); __Result__; });
}
inline __attribute__((always_inline)) int length() const {
return h_index >= l_index ? h_index - l_index + 1 : l_index - h_index + 1;
}
# 632 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_ref.h"
inline __attribute__((always_inline)) char* to_string(signed char rd = 2) const {
return 0;
}
};
# 695 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_ref.h"
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(1), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(1), (false)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(1), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(1), (false)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(1), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(1), (false)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(1), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(1), (false)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(1), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(1), (false)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(1), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( bool op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(1), (false)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, bool op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( bool op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(8), (CHAR_IS_SIGNED)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (CHAR_IS_SIGNED)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, char op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(8), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (true)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(8), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (true)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(8), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (true)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(8), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (true)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(8), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (true)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(8), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( signed char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (true)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, signed char op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( signed char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(8), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (false)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(8), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (false)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(8), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (false)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(8), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (false)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(8), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (false)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(8), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned char op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(8), (false)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned char op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned char op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(_AP_SIZE_short), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (true)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, short op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(_AP_SIZE_short), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned short op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_short), (false)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned short op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned short op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(_AP_SIZE_int), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (true)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, int op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(_AP_SIZE_int), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned int op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_int), (false)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned int op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned int op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(_AP_SIZE_long), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (true)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, long op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(_AP_SIZE_long), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned long op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_long), (false)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, unsigned long op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( unsigned long op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( ap_slong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (true)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_slong op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( ap_slong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) > ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return bool(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) < ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return bool(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) >= ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return bool(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator >=( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) <= ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return bool(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator <=( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) == ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return bool(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator ==( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == bool(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return ap_int_base<_AP_W, false>(op) != ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( ap_ulong op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return ap_int_base<(_AP_SIZE_ap_slong), (false)>(op2) != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, ap_ulong op2) { return bool(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N> inline __attribute__((always_inline)) bool operator !=( ap_ulong op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != bool(op); }
# 741 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_ref.h"
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S>& op2) { return ap_int_base<_AP_W, false>(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op) > op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 > ap_int_base<1, false>(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S>& op2) { return ap_int_base<_AP_W, false>(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op) < op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 < ap_int_base<1, false>(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S>& op2) { return ap_int_base<_AP_W, false>(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >=( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op) >= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator >=( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 >= ap_int_base<1, false>(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S>& op2) { return ap_int_base<_AP_W, false>(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <=( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op) <= op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator <=( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 <= ap_int_base<1, false>(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator ==( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S>& op2) { return ap_int_base<_AP_W, false>(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator ==( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator ==( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op) == op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator ==( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 == ap_int_base<1, false>(op); }
template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator !=( const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S>& op2) { return ap_int_base<_AP_W, false>(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator !=( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_range_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != ap_int_base<_AP_W, false>(op); } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator !=( const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op, const ap_int_base<_AP_W2, _AP_S2>& op2) { return ap_int_base<1, false>(op) != op2; } template <int _AP_W, int _AP_I, bool _AP_S, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N, int _AP_W2, bool _AP_S2> inline __attribute__((always_inline)) bool operator !=( const ap_int_base<_AP_W2, _AP_S2>& op2, const af_bit_ref<_AP_W, _AP_I, _AP_S, _AP_Q, _AP_O, _AP_N>& op) { return op2 != ap_int_base<1, false>(op); }
# 57 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed.h" 2
template <int _AP_W, int _AP_I, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
struct ap_fixed : ap_fixed_base<_AP_W, _AP_I, true, _AP_Q, _AP_O, _AP_N> {
typedef ap_fixed_base<_AP_W, _AP_I, true, _AP_Q, _AP_O, _AP_N> Base;
inline __attribute__((always_inline)) ap_fixed() : Base() {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& op)
: Base(op) {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(const volatile ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& op)
: Base(op) {}
# 111 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed.h"
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed(const ap_int_base<_AP_W2, _AP_S2>& op) : Base(op) {}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed(const volatile ap_int_base<_AP_W2, _AP_S2>& op) : Base(op) {}
# 136 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed.h"
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed(const ap_bit_ref<_AP_W2, _AP_S2>& op) : Base(op) {}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_fixed(const ap_range_ref<_AP_W2, _AP_S2>& op) : Base(op) {}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_fixed(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op)
: Base(op) {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_fixed(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
inline __attribute__((always_inline)) ap_fixed(bool v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(char v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(signed char v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned char v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(short v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned short v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(int v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned int v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(long v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(unsigned long v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(ap_slong v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(ap_ulong v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(half v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(float v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(double v) : Base(v) {}
inline __attribute__((always_inline)) ap_fixed(const char* s) : Base(s) {}
inline __attribute__((always_inline)) ap_fixed(const char* s, signed char rd) : Base(s, rd) {}
inline __attribute__((always_inline)) ap_fixed& operator=(
const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
inline __attribute__((always_inline)) void operator=(
const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
inline __attribute__((always_inline)) ap_fixed& operator=(
const volatile ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
inline __attribute__((always_inline)) void operator=(
const volatile ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
};
template <int _AP_W, int _AP_I, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
struct ap_ufixed : ap_fixed_base<_AP_W, _AP_I, false, _AP_Q, _AP_O, _AP_N> {
typedef ap_fixed_base<_AP_W, _AP_I, false, _AP_Q, _AP_O, _AP_N> Base;
inline __attribute__((always_inline)) ap_ufixed() : Base() {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(const ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& op)
: Base(op) {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(const volatile ap_fixed_base<_AP_W2, _AP_I2, _AP_S2, _AP_Q2,
_AP_O2, _AP_N2>& op)
: Base(op) {}
# 267 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed.h"
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_ufixed(const ap_int_base<_AP_W2, _AP_S2>& op) : Base(op) {}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_ufixed(const volatile ap_int_base<_AP_W2, _AP_S2>& op) : Base(op) {}
# 289 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed.h"
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_ufixed(const ap_bit_ref<_AP_W2, _AP_S2>& op) : Base(op) {}
template <int _AP_W2, bool _AP_S2>
inline __attribute__((always_inline)) ap_ufixed(const ap_range_ref<_AP_W2, _AP_S2>& op) : Base(op) {}
template <int _AP_W2, typename _AP_T2, int _AP_W3, typename _AP_T3>
inline __attribute__((always_inline)) ap_ufixed(const ap_concat_ref<_AP_W2, _AP_T2, _AP_W3, _AP_T3>& op)
: Base(op) {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(
const af_bit_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
template <int _AP_W2, int _AP_I2, bool _AP_S2, ap_q_mode _AP_Q2,
ap_o_mode _AP_O2, int _AP_N2>
inline __attribute__((always_inline)) ap_ufixed(
const af_range_ref<_AP_W2, _AP_I2, _AP_S2, _AP_Q2, _AP_O2, _AP_N2>& op)
: Base(op) {}
inline __attribute__((always_inline)) ap_ufixed(bool v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(char v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(signed char v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned char v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(short v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned short v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(int v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned int v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(long v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(unsigned long v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(ap_slong v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(ap_ulong v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(half v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(float v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(double v) : Base(v) {}
inline __attribute__((always_inline)) ap_ufixed(const char* s) : Base(s) {}
inline __attribute__((always_inline)) ap_ufixed(const char* s, signed char rd) : Base(s, rd) {}
inline __attribute__((always_inline)) ap_ufixed& operator=(
const ap_ufixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
inline __attribute__((always_inline)) void operator=(
const ap_ufixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) volatile {
Base::V = op.V;
}
inline __attribute__((always_inline)) ap_ufixed& operator=(
const volatile ap_ufixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N>& op) {
Base::V = op.V;
return *this;
}
inline __attribute__((always_inline)) void operator=(const volatile ap_ufixed<_AP_W, _AP_I, _AP_Q, _AP_O,
_AP_N>& op) volatile {
Base::V = op.V;
}
};
# 380 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed.h"
# 1 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_special.h" 1
# 60 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_special.h"
namespace std {
template<typename _Tp> class complex;
}
namespace std {
# 88 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_special.h"
template <int _AP_W, int _AP_I, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
struct complex<ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> > {
typedef ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> _Tp;
typedef _Tp value_type;
complex() : _M_real(_Tp()), _M_imag(_Tp()) {}
complex(const _Tp &__r, const _Tp &__i = _Tp(0))
: _M_real(__r), _M_imag(__i) {}
template <typename _Up>
complex(const complex<_Up> &__z) : _M_real(__z.real()), _M_imag(__z.imag()) {}
_Tp& real() { return _M_real; }
const _Tp& real() const { return _M_real; }
_Tp& imag() { return _M_imag; }
const _Tp& imag() const { return _M_imag; }
void real(_Tp __val) { _M_real = __val; }
void imag(_Tp __val) { _M_imag = __val; }
complex<_Tp> &operator=(const _Tp __t) {
_M_real = __t;
_M_imag = _Tp(0);
return *this;
}
complex<_Tp> &operator+=(const _Tp &__t) {
_M_real += __t;
return *this;
}
complex<_Tp> &operator-=(const _Tp &__t) {
_M_real -= __t;
return *this;
}
complex<_Tp> &operator*=(const _Tp &__t) {
_M_real *= __t;
_M_imag *= __t;
return *this;
}
complex<_Tp> &operator/=(const _Tp &__t) {
_M_real /= __t;
_M_imag /= __t;
return *this;
}
template <typename _Up>
complex<_Tp> &operator=(const complex<_Up> &__z) {
_M_real = __z.real();
_M_imag = __z.imag();
return *this;
}
template <typename _Up>
complex<_Tp> &operator+=(const complex<_Up> &__z) {
_M_real += __z.real();
_M_imag += __z.imag();
return *this;
}
template <typename _Up>
complex<_Tp> &operator-=(const complex<_Up> &__z) {
_M_real -= __z.real();
_M_imag -= __z.imag();
return *this;
}
template <typename _Up>
complex<_Tp> &operator*=(const complex<_Up> &__z) {
const _Tp __r = _M_real * __z.real() - _M_imag * __z.imag();
_M_imag = _M_real * __z.imag() + _M_imag * __z.real();
_M_real = __r;
return *this;
}
template <typename _Up>
complex<_Tp> &operator/=(const complex<_Up> &__z) {
complex<_Tp> cj (__z.real(), -__z.imag());
complex<_Tp> a = (*this) * cj;
complex<_Tp> b = cj * __z;
_M_real = a.real() / b.real();
_M_imag = a.imag() / b.real();
return *this;
}
private:
_Tp _M_real;
_Tp _M_imag;
};
# 219 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed_special.h"
template <int _AP_W, int _AP_I, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline bool operator==(
const complex<ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> > &__x,
const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> &__y) {
return __x.real() == __y &&
__x.imag() == 0;
}
template <int _AP_W, int _AP_I, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline bool operator==(
const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> &__x,
const complex<ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> > &__y) {
return __x == __y.real() &&
0 == __y.imag();
}
template <int _AP_W, int _AP_I, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline bool operator!=(
const complex<ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> > &__x,
const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> &__y) {
return __x.real() != __y ||
__x.imag() != 0;
}
template <int _AP_W, int _AP_I, ap_q_mode _AP_Q, ap_o_mode _AP_O, int _AP_N>
inline bool operator!=(
const ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> &__x,
const complex<ap_fixed<_AP_W, _AP_I, _AP_Q, _AP_O, _AP_N> > &__y) {
return __x != __y.real() ||
0 != __y.imag();
}
}
# 381 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_fixed.h" 2
# 350 "/opt/vivado2018/Vivado/2018.3/common/technology/autopilot/ap_int.h" 2
# 14 "modules/V_read/../../Stream.h" 2
# 1 "modules/V_read/../../templates/stream_templates.hpp" 1
template< typename T>
struct dataPackage32 {
T data;
ap_int<1> tlast;
};
template< typename T,int dataQuantity>
struct dataPackage {
T data[dataQuantity];
};
# 15 "modules/V_read/../../Stream.h" 2
const int inputBusSize=64;
const int PORT_SIZE=inputBusSize/32;
const int BLOCK_SIZE=4;
const int MAX_V_SIZE=10000;
float const hundred = -1.0 / 100.0;
template< int maxBits>
struct config {
ap_int<maxBits> rowBegin;
ap_int<maxBits> rowEnd;
ap_int<maxBits> rowsToSimulate;
ap_int<maxBits> BLOCK_NUMBERS;
};
typedef config<27> Config;
typedef dataPackage32<float> dataStream;
typedef hls::stream<dataStream> Stream ;
typedef dataPackage<float,PORT_SIZE> Package64Bits;
typedef hls::stream<Package64Bits> in64Bits ;
typedef dataPackage<float,BLOCK_SIZE> VC_Package;
typedef hls::stream<VC_Package> VC_Stream ;
void GapJunctionIP(in64Bits &input,Stream &output,
int size,int FirstRow,int LastRow);
# 2 "modules/V_read/V_read.hpp" 2
template< typename T,int voltagesBackupLenght>
struct voltagesControl {
T voltagesBackup[voltagesBackupLenght];
};
typedef voltagesControl<float,MAX_V_SIZE> V_Control;
template< int maxBits>
struct control {
ap_int<maxBits> fixedVoltageControl;
ap_int<1> voltagesPending;
ap_int<1> voltagesRead;
ap_int<maxBits> blockInitialIdx;
ap_int<1> completing;
ap_int<maxBits> idxForBackup;
ap_int<maxBits> columnBlock;
};
typedef control<14> Control;
const unsigned int idxMaxBits = 27;
template <unsigned int size>
struct idxArray{
ap_uint<idxMaxBits> data[size];
};
const unsigned int wordDataPack = 4;
typedef hls::stream<idxArray<4> > idxStream ;
void V_read(VC_Stream &input,
VC_Stream &processedData,
Stream &fixedData,
Config &simConfig,
int &V_SIZE
);
# 2 "modules/V_read/V_read.cpp" 2
template<typename dataType,typename streamType,int maxBits>
void indexGeneration(streamType &Vi_idx,streamType &Vj_idx,Config &simConfig){
for (ap_uint<maxBits> rowOffset = simConfig.rowBegin; rowOffset < simConfig.rowEnd;
rowOffset+=BLOCK_SIZE){
#pragma HLS loop_tripcount min=1 max=2500
dataType idx;
idx.data[0]=rowOffset;
idx.data[1]=rowOffset+1;
idx.data[2]=rowOffset+2;
idx.data[3]=rowOffset+3;
Vi_idx.write(idx);
((simConfig.BLOCK_NUMBERS<2500) ? static_cast<void> (0) : __assert_fail ("simConfig.BLOCK_NUMBERS<2500", "modules/V_read/V_read.cpp", 16, __PRETTY_FUNCTION__));
for (ap_uint<maxBits> block = 0; block < simConfig.BLOCK_NUMBERS; block++) {
#pragma HLS loop_tripcount min=1 max=2500
ap_uint<maxBits> column = block*BLOCK_SIZE;
dataType jdx;
jdx.data[0]=column;
jdx.data[1]=column+1;
jdx.data[2]=column+2;
jdx.data[3]=column+3;
Vj_idx.write(jdx);
}
}
}
template<typename dataType,typename streamType,unsigned int PackageDataQuantity,int maxBits>
void readVoltages(streamType &input,float voltagesBackup[], int &V_SIZE){
((V_SIZE<MAX_V_SIZE) ? static_cast<void> (0) : __assert_fail ("V_SIZE<MAX_V_SIZE", "modules/V_read/V_read.cpp", 32, __PRETTY_FUNCTION__));
#pragma HLS pipeline
for (ap_int<maxBits> i = 0; i < V_SIZE; i+=BLOCK_SIZE) {
#pragma HLS loop_tripcount min=1 max=MAX_V_SIZE/4
dataType readData = input.read();
for (ap_int<4> j = 0; j < PackageDataQuantity; j++) {
voltagesBackup[i+j]=readData.data[j];
}
}
}
template<typename dataType,typename streamType,typename idxType,typename idxStreamType>
void dataToProcess(idxStreamType &Vj_idx,streamType &processedData,float voltagesBackup[]) {
#pragma HLS inline
dataType newData;
idxType idx;
idx=Vj_idx.read();
for (ap_int<4> i = 0; i < BLOCK_SIZE; i++) {
#pragma HLS unroll
newData.data[i]=voltagesBackup[idx.data[i]];
}
processedData.write(newData);
processedData.write(newData);
processedData.write(newData);
processedData.write(newData);
}
void writeV2calc(
float voltagesBackup[MAX_V_SIZE],
Config& simConfig,
Stream& fixedData,
VC_Stream& processedData,
idxStream &Vi_idx,
idxStream &Vj_idx
){_ssdm_SpecArrayDimSize(voltagesBackup, 10000);
((simConfig.rowsToSimulate < 2500) ? static_cast<void> (0) : __assert_fail ("simConfig.rowsToSimulate < 2500", "modules/V_read/V_read.cpp", 69, __PRETTY_FUNCTION__));
for (ap_uint<idxMaxBits> i = 0; i < simConfig.rowsToSimulate; i++) {
idxArray<wordDataPack> idx = Vi_idx.read();
dataStream rowData[wordDataPack];
rowData[0].data = voltagesBackup[idx.data[0]];
rowData[1].data = voltagesBackup[idx.data[1]];
rowData[2].data = voltagesBackup[idx.data[2]];
rowData[3].data = voltagesBackup[idx.data[3]];
((simConfig.BLOCK_NUMBERS < 2500) ? static_cast<void> (0) : __assert_fail ("simConfig.BLOCK_NUMBERS < 2500", "modules/V_read/V_read.cpp", 77, __PRETTY_FUNCTION__));
for (ap_uint<idxMaxBits> j = 0; j < simConfig.BLOCK_NUMBERS; j++) {
#pragma HLS pipeline
fixedData.write(rowData[0]);
fixedData.write(rowData[1]);
fixedData.write(rowData[2]);
fixedData.write(rowData[3]);
dataToProcess<VC_Package, VC_Stream, idxArray<wordDataPack>,
idxStream>(Vj_idx, processedData, voltagesBackup);
}
}
}
void V_read(VC_Stream &input, VC_Stream &processedData, Stream &fixedData,Config &simConfig, int &V_SIZE){
float voltagesBackup[MAX_V_SIZE];
#pragma HLS RESOURCE variable=&voltagesBackup core=RAM_T2P_BRAM
static idxStream Vi_idx("Vi_idx");
static idxStream Vj_idx("Vj_idx");
#pragma HLS STREAM variable=&Vi_idx depth=1024 dim=1
#pragma HLS STREAM variable=&Vj_idx depth=1024 dim=1
readVoltages<VC_Package,VC_Stream,wordDataPack,idxMaxBits>(input, voltagesBackup,V_SIZE);
#pragma HLS DATAFLOW
indexGeneration<idxArray<wordDataPack>, idxStream, idxMaxBits>(Vi_idx,Vj_idx, simConfig);
writeV2calc(voltagesBackup, simConfig, fixedData,processedData,Vi_idx,Vj_idx);
}
| [
"mespinoza1986@gmail.com"
] | mespinoza1986@gmail.com |
12661c4bea59e55a1ff25aef003e8d59a7f08ee1 | d7b84a31cafb72a3cb71b3a3cc724a68119ba18e | /Tyr/2.36/p | 507763b5232865e6269ef54b03cf184d8b5850df | [] | no_license | benroque/Ragnorak | 6cc7c68db801f9281a4ac241da754bce88ef6caf | a1bfc2430cccb207192792acebdd1530f1388a4c | refs/heads/master | 2021-01-14T08:13:18.774988 | 2017-02-20T08:32:53 | 2017-02-20T08:32:53 | 82,008,402 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 403,393 | /*--------------------------------*- C++ -*----------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 4.1 |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
FoamFile
{
version 2.0;
format ascii;
class volScalarField;
location "2.36";
object p;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
dimensions [1 -1 -2 0 0 0 0];
internalField nonuniform List<scalar>
52500
(
1.00001
1.00003
1.0001
1.00022
1.00063
1.00129
1.00371
1.0073
1.02264
1.04035
1.1476
1.25883
2.00589
3.34415
8.05621
11.616
11.2161
10.9667
11.0483
11.2749
11.4999
11.6315
11.7304
11.8079
11.8639
1.00001
1.00003
1.0001
1.00021
1.00062
1.00127
1.00366
1.00721
1.02231
1.0398
1.14539
1.25492
1.98865
3.30424
7.94838
11.6252
11.2132
10.9559
11.0386
11.2663
11.4914
11.6237
11.7247
11.8042
11.8625
1.00001
1.00003
1.0001
1.00021
1.00061
1.00124
1.00356
1.00701
1.02163
1.0387
1.1408
1.24687
1.95198
3.21823
7.70599
11.643
11.2035
10.9235
11.005
11.2308
11.4544
11.5862
11.6881
11.7689
11.8292
1.00001
1.00003
1.00009
1.0002
1.00058
1.00119
1.0034
1.00672
1.02062
1.03702
1.13389
1.23481
1.89691
3.08859
7.3299
11.6706
11.1914
10.8708
10.9478
11.1672
11.3889
11.519
11.6204
11.7022
11.7661
1.00001
1.00002
1.00009
1.00019
1.00055
1.00114
1.00324
1.0065
1.01926
1.03621
1.12267
1.22255
1.82137
2.92114
6.82652
11.6965
11.1788
10.8019
10.8712
11.0795
11.2985
11.4247
11.5231
11.605
11.6735
1
1.00002
1.00008
1.00018
1.00052
1.00106
1.00302
1.00609
1.01771
1.03449
1.11047
1.20694
1.73643
2.72678
6.21807
11.6832
11.1548
10.7172
10.7749
10.964
11.1777
11.2969
11.3879
11.4654
11.5387
1
1.00002
1.00007
1.00016
1.00047
1.00097
1.00277
1.00559
1.01617
1.03185
1.09908
1.19097
1.65122
2.53007
5.58727
11.5494
11.0837
10.6155
10.6596
10.8203
11.0199
11.1248
11.2003
11.2645
11.3352
1
1.00002
1.00007
1.00015
1.00043
1.00088
1.0025
1.00507
1.01464
1.02887
1.08967
1.17211
1.58641
2.37238
5.15178
11.1268
10.8974
10.5019
10.5262
10.6436
10.8177
10.8991
10.9443
10.9748
11.0229
1
1.00002
1.00006
1.00013
1.00038
1.00078
1.00221
1.00447
1.01302
1.02499
1.0815
1.14766
1.53038
2.2106
4.72589
10.4232
10.6066
10.4296
10.3836
10.4427
10.5678
10.6113
10.6036
10.5583
10.5105
1
1.00001
1.00005
1.00011
1.00032
1.00065
1.00187
1.00362
1.01141
1.01983
1.07334
1.12251
1.47712
2.04056
4.29365
9.55117
10.4521
10.3333
10.208
10.2271
10.2762
10.2598
10.1719
9.95737
9.6058
1.00001
1.00003
1.0001
1.00022
1.00064
1.0013
1.00372
1.00731
1.02265
1.04037
1.14762
1.25889
2.00594
3.34437
8.0566
11.6159
11.2161
10.9668
11.0484
11.2749
11.5
11.6315
11.7305
11.808
11.864
1.00001
1.00003
1.0001
1.00022
1.00063
1.00128
1.00367
1.00722
1.02232
1.03982
1.14541
1.25497
1.9887
3.30446
7.94876
11.625
11.2132
10.956
11.0387
11.2663
11.4914
11.6237
11.7247
11.8043
11.8626
1.00001
1.00003
1.0001
1.00021
1.00061
1.00125
1.00357
1.00702
1.02164
1.03872
1.14082
1.24692
1.95203
3.21844
7.70637
11.6429
11.2036
10.9236
11.0051
11.2309
11.4545
11.5862
11.6881
11.769
11.8293
1.00001
1.00003
1.00009
1.00021
1.00059
1.0012
1.00341
1.00673
1.02063
1.03704
1.13391
1.23486
1.89694
3.08876
7.33021
11.6706
11.1915
10.8709
10.9479
11.1673
11.389
11.5191
11.6205
11.7022
11.7661
1.00001
1.00003
1.00009
1.0002
1.00056
1.00114
1.00325
1.00651
1.01927
1.03624
1.12267
1.22262
1.82137
2.9213
6.82679
11.6965
11.1789
10.802
10.8713
11.0796
11.2986
11.4248
11.5232
11.605
11.6736
1.00001
1.00003
1.00008
1.00018
1.00052
1.00107
1.00302
1.0061
1.01772
1.03451
1.11048
1.20699
1.73645
2.72692
6.21835
11.6832
11.1549
10.7173
10.775
10.9641
11.1777
11.297
11.3879
11.4655
11.5387
1.00001
1.00002
1.00008
1.00017
1.00048
1.00098
1.00277
1.0056
1.01618
1.03186
1.09909
1.19101
1.65125
2.53019
5.58745
11.5495
11.0838
10.6155
10.6597
10.8204
11.02
11.1249
11.2003
11.2645
11.3352
1
1.00002
1.00007
1.00015
1.00043
1.00089
1.00251
1.00508
1.01465
1.02888
1.08969
1.17215
1.58643
2.37248
5.15196
11.127
10.8975
10.502
10.5262
10.6436
10.8177
10.8991
10.9444
10.9749
11.0229
1
1.00002
1.00006
1.00013
1.00038
1.00079
1.00222
1.00448
1.01303
1.02501
1.0815
1.14772
1.53037
2.2107
4.72601
10.4235
10.6067
10.4297
10.3836
10.4427
10.5679
10.6114
10.6036
10.5584
10.5105
1
1.00002
1.00005
1.00011
1.00032
1.00065
1.00187
1.00363
1.01142
1.01985
1.07336
1.12254
1.47713
2.04067
4.29375
9.55147
10.4521
10.3333
10.2081
10.2272
10.2763
10.2599
10.172
9.9574
9.60583
1.00001
1.00003
1.0001
1.00022
1.00064
1.0013
1.00372
1.00731
1.02265
1.04037
1.14762
1.25889
2.00595
3.34438
8.05662
11.6159
11.2161
10.9668
11.0484
11.2749
11.5
11.6315
11.7305
11.808
11.864
1.00001
1.00003
1.0001
1.00022
1.00063
1.00128
1.00367
1.00722
1.02232
1.03982
1.14541
1.25497
1.98871
3.30446
7.94878
11.625
11.2132
10.956
11.0387
11.2663
11.4914
11.6237
11.7247
11.8043
11.8626
1.00001
1.00003
1.0001
1.00021
1.00061
1.00125
1.00357
1.00702
1.02164
1.03872
1.14082
1.24692
1.95203
3.21845
7.70639
11.6429
11.2036
10.9236
11.0051
11.2309
11.4545
11.5862
11.6881
11.769
11.8293
1.00001
1.00003
1.00009
1.00021
1.00059
1.0012
1.00341
1.00673
1.02063
1.03704
1.13391
1.23486
1.89695
3.08877
7.33024
11.6705
11.1915
10.8709
10.9479
11.1673
11.389
11.5191
11.6205
11.7022
11.7661
1.00001
1.00003
1.00009
1.0002
1.00056
1.00114
1.00325
1.00651
1.01927
1.03624
1.12267
1.22262
1.82137
2.92131
6.82681
11.6965
11.1789
10.802
10.8713
11.0796
11.2986
11.4248
11.5232
11.605
11.6736
1.00001
1.00003
1.00008
1.00018
1.00052
1.00107
1.00302
1.0061
1.01772
1.03451
1.11048
1.20699
1.73645
2.72693
6.21837
11.6832
11.1549
10.7173
10.775
10.9641
11.1777
11.297
11.3879
11.4655
11.5387
1.00001
1.00002
1.00008
1.00017
1.00048
1.00098
1.00277
1.0056
1.01618
1.03186
1.09909
1.19101
1.65125
2.53019
5.58746
11.5495
11.0838
10.6155
10.6597
10.8204
11.02
11.1249
11.2003
11.2645
11.3352
1
1.00002
1.00007
1.00015
1.00043
1.00089
1.00251
1.00508
1.01465
1.02888
1.08969
1.17215
1.58643
2.37248
5.15197
11.127
10.8975
10.502
10.5262
10.6436
10.8177
10.8991
10.9444
10.9749
11.0229
1
1.00002
1.00006
1.00013
1.00038
1.00079
1.00222
1.00448
1.01303
1.02501
1.0815
1.14772
1.53037
2.21071
4.72602
10.4235
10.6067
10.4297
10.3836
10.4428
10.5679
10.6114
10.6036
10.5584
10.5105
1
1.00002
1.00005
1.00011
1.00032
1.00065
1.00187
1.00363
1.01142
1.01985
1.07336
1.12254
1.47713
2.04067
4.29375
9.55148
10.4521
10.3333
10.2081
10.2272
10.2763
10.2599
10.172
9.9574
9.60583
1.00001
1.00003
1.0001
1.00022
1.00064
1.0013
1.00372
1.00731
1.02265
1.04037
1.14762
1.25889
2.00595
3.34438
8.05662
11.6159
11.2161
10.9668
11.0484
11.2749
11.5
11.6315
11.7305
11.808
11.864
1.00001
1.00003
1.0001
1.00022
1.00063
1.00128
1.00367
1.00722
1.02232
1.03982
1.14541
1.25497
1.98871
3.30447
7.94878
11.625
11.2132
10.956
11.0387
11.2663
11.4914
11.6237
11.7247
11.8043
11.8626
1.00001
1.00003
1.0001
1.00021
1.00061
1.00125
1.00357
1.00702
1.02164
1.03872
1.14082
1.24692
1.95203
3.21845
7.70639
11.6429
11.2036
10.9236
11.0051
11.2309
11.4545
11.5862
11.6881
11.769
11.8293
1.00001
1.00003
1.00009
1.00021
1.00059
1.0012
1.00341
1.00673
1.02063
1.03704
1.13391
1.23486
1.89695
3.08877
7.33024
11.6705
11.1915
10.8709
10.9479
11.1673
11.389
11.5191
11.6205
11.7022
11.7661
1.00001
1.00003
1.00009
1.0002
1.00056
1.00114
1.00325
1.00651
1.01927
1.03624
1.12267
1.22262
1.82137
2.92131
6.82681
11.6965
11.1789
10.802
10.8713
11.0796
11.2986
11.4248
11.5232
11.605
11.6736
1.00001
1.00003
1.00008
1.00018
1.00052
1.00107
1.00302
1.0061
1.01772
1.03451
1.11048
1.20699
1.73645
2.72693
6.21837
11.6832
11.1549
10.7173
10.775
10.9641
11.1777
11.297
11.3879
11.4655
11.5387
1.00001
1.00002
1.00008
1.00017
1.00048
1.00098
1.00277
1.0056
1.01618
1.03186
1.09909
1.19101
1.65125
2.53019
5.58746
11.5495
11.0838
10.6155
10.6597
10.8204
11.02
11.1249
11.2003
11.2645
11.3352
1
1.00002
1.00007
1.00015
1.00043
1.00089
1.00251
1.00508
1.01465
1.02888
1.08969
1.17215
1.58643
2.37248
5.15197
11.127
10.8975
10.502
10.5262
10.6436
10.8177
10.8991
10.9444
10.9749
11.0229
1
1.00002
1.00006
1.00013
1.00038
1.00079
1.00222
1.00448
1.01303
1.02501
1.0815
1.14772
1.53037
2.21071
4.72602
10.4235
10.6067
10.4297
10.3836
10.4427
10.5679
10.6114
10.6036
10.5584
10.5105
1
1.00002
1.00005
1.00011
1.00032
1.00065
1.00187
1.00363
1.01142
1.01985
1.07336
1.12254
1.47713
2.04067
4.29376
9.55149
10.4521
10.3333
10.2081
10.2272
10.2763
10.2599
10.172
9.9574
9.60583
1.00001
1.00003
1.0001
1.00022
1.00064
1.0013
1.00372
1.00731
1.02265
1.04037
1.14762
1.25889
2.00595
3.34438
8.05662
11.6159
11.2161
10.9668
11.0484
11.2749
11.5
11.6315
11.7305
11.808
11.864
1.00001
1.00003
1.0001
1.00022
1.00063
1.00128
1.00367
1.00722
1.02232
1.03982
1.14541
1.25497
1.98871
3.30447
7.94878
11.625
11.2132
10.956
11.0387
11.2663
11.4914
11.6237
11.7247
11.8043
11.8626
1.00001
1.00003
1.0001
1.00021
1.00061
1.00125
1.00357
1.00702
1.02164
1.03872
1.14082
1.24692
1.95204
3.21845
7.70639
11.6429
11.2036
10.9236
11.0051
11.2309
11.4545
11.5862
11.6881
11.769
11.8293
1.00001
1.00003
1.00009
1.00021
1.00059
1.0012
1.00341
1.00673
1.02063
1.03704
1.13391
1.23487
1.89695
3.08878
7.33024
11.6705
11.1915
10.8709
10.9479
11.1673
11.389
11.5191
11.6205
11.7022
11.7661
1.00001
1.00003
1.00009
1.0002
1.00056
1.00114
1.00325
1.00651
1.01927
1.03624
1.12267
1.22262
1.82137
2.92131
6.82682
11.6965
11.1789
10.802
10.8713
11.0796
11.2986
11.4248
11.5232
11.605
11.6736
1.00001
1.00003
1.00008
1.00018
1.00052
1.00107
1.00302
1.0061
1.01772
1.03451
1.11048
1.20699
1.73645
2.72693
6.21837
11.6832
11.1549
10.7173
10.775
10.9641
11.1777
11.297
11.3879
11.4655
11.5387
1.00001
1.00002
1.00008
1.00017
1.00048
1.00098
1.00277
1.0056
1.01618
1.03186
1.09909
1.19101
1.65125
2.53019
5.58747
11.5495
11.0838
10.6155
10.6597
10.8204
11.02
11.1249
11.2003
11.2645
11.3352
1
1.00002
1.00007
1.00015
1.00043
1.00089
1.00251
1.00508
1.01465
1.02888
1.08969
1.17215
1.58643
2.37248
5.15197
11.127
10.8975
10.502
10.5262
10.6436
10.8177
10.8991
10.9444
10.9749
11.0229
1
1.00002
1.00006
1.00013
1.00038
1.00079
1.00222
1.00448
1.01303
1.02501
1.0815
1.14772
1.53038
2.21071
4.72603
10.4235
10.6067
10.4297
10.3836
10.4427
10.5679
10.6114
10.6036
10.5584
10.5105
1
1.00002
1.00005
1.00011
1.00032
1.00065
1.00187
1.00363
1.01142
1.01985
1.07336
1.12254
1.47713
2.04068
4.29376
9.55149
10.4521
10.3333
10.2081
10.2272
10.2763
10.2599
10.172
9.9574
9.60583
1.00001
1.00003
1.0001
1.00022
1.00064
1.0013
1.00372
1.00731
1.02265
1.04037
1.14762
1.25889
2.00595
3.34438
8.05662
11.6159
11.2161
10.9668
11.0484
11.2749
11.5
11.6315
11.7305
11.808
11.864
1.00001
1.00003
1.0001
1.00022
1.00063
1.00128
1.00367
1.00722
1.02232
1.03982
1.14541
1.25497
1.98871
3.30447
7.94878
11.625
11.2132
10.956
11.0387
11.2663
11.4914
11.6237
11.7247
11.8043
11.8626
1.00001
1.00003
1.0001
1.00021
1.00061
1.00125
1.00357
1.00702
1.02164
1.03872
1.14082
1.24692
1.95203
3.21845
7.70639
11.6429
11.2036
10.9236
11.0051
11.2309
11.4545
11.5862
11.6881
11.769
11.8293
1.00001
1.00003
1.00009
1.00021
1.00059
1.0012
1.00341
1.00673
1.02063
1.03704
1.13391
1.23486
1.89695
3.08877
7.33024
11.6705
11.1915
10.8709
10.9479
11.1673
11.389
11.5191
11.6205
11.7022
11.7661
1.00001
1.00003
1.00009
1.0002
1.00056
1.00114
1.00325
1.00651
1.01927
1.03624
1.12267
1.22262
1.82137
2.92131
6.82682
11.6965
11.1789
10.802
10.8713
11.0796
11.2986
11.4248
11.5232
11.605
11.6736
1.00001
1.00003
1.00008
1.00018
1.00052
1.00107
1.00302
1.0061
1.01772
1.03451
1.11048
1.20699
1.73645
2.72693
6.21837
11.6832
11.1549
10.7173
10.775
10.9641
11.1777
11.297
11.3879
11.4655
11.5387
1.00001
1.00002
1.00008
1.00017
1.00048
1.00098
1.00277
1.0056
1.01618
1.03186
1.09909
1.19101
1.65125
2.53019
5.58746
11.5495
11.0838
10.6155
10.6597
10.8204
11.02
11.1249
11.2003
11.2645
11.3352
1
1.00002
1.00007
1.00015
1.00043
1.00089
1.00251
1.00508
1.01465
1.02888
1.08969
1.17215
1.58643
2.37248
5.15197
11.127
10.8975
10.502
10.5262
10.6436
10.8177
10.8991
10.9444
10.9749
11.0229
1
1.00002
1.00006
1.00013
1.00038
1.00079
1.00222
1.00448
1.01303
1.02501
1.0815
1.14772
1.53037
2.21071
4.72602
10.4235
10.6067
10.4297
10.3836
10.4427
10.5679
10.6114
10.6036
10.5584
10.5105
1
1.00002
1.00005
1.00011
1.00032
1.00065
1.00187
1.00363
1.01142
1.01985
1.07336
1.12254
1.47713
2.04067
4.29376
9.55149
10.4521
10.3333
10.2081
10.2272
10.2763
10.2599
10.172
9.9574
9.60583
1.00001
1.00003
1.0001
1.00022
1.00064
1.0013
1.00372
1.00731
1.02265
1.04037
1.14762
1.25889
2.00595
3.34438
8.05662
11.6159
11.2161
10.9668
11.0484
11.2749
11.5
11.6315
11.7305
11.808
11.864
1.00001
1.00003
1.0001
1.00022
1.00063
1.00128
1.00367
1.00722
1.02232
1.03982
1.14541
1.25497
1.98871
3.30447
7.94878
11.625
11.2132
10.956
11.0387
11.2663
11.4914
11.6237
11.7247
11.8043
11.8626
1.00001
1.00003
1.0001
1.00021
1.00061
1.00125
1.00357
1.00702
1.02164
1.03872
1.14082
1.24692
1.95203
3.21845
7.70639
11.6429
11.2036
10.9236
11.0051
11.2309
11.4545
11.5862
11.6881
11.769
11.8293
1.00001
1.00003
1.00009
1.00021
1.00059
1.0012
1.00341
1.00673
1.02063
1.03704
1.13391
1.23486
1.89695
3.08877
7.33024
11.6705
11.1915
10.8709
10.9479
11.1673
11.389
11.5191
11.6205
11.7022
11.7661
1.00001
1.00003
1.00009
1.0002
1.00056
1.00114
1.00325
1.00651
1.01927
1.03624
1.12267
1.22262
1.82137
2.92131
6.82681
11.6965
11.1789
10.802
10.8713
11.0796
11.2986
11.4248
11.5232
11.605
11.6736
1.00001
1.00003
1.00008
1.00018
1.00052
1.00107
1.00302
1.0061
1.01772
1.03451
1.11048
1.20699
1.73645
2.72693
6.21837
11.6832
11.1549
10.7173
10.775
10.9641
11.1777
11.297
11.3879
11.4655
11.5387
1.00001
1.00002
1.00008
1.00017
1.00048
1.00098
1.00277
1.0056
1.01618
1.03186
1.09909
1.19101
1.65125
2.53019
5.58746
11.5495
11.0838
10.6155
10.6597
10.8204
11.02
11.1249
11.2003
11.2645
11.3352
1
1.00002
1.00007
1.00015
1.00043
1.00089
1.00251
1.00508
1.01465
1.02888
1.08969
1.17215
1.58643
2.37248
5.15197
11.127
10.8975
10.502
10.5262
10.6436
10.8177
10.8991
10.9444
10.9749
11.0229
1
1.00002
1.00006
1.00013
1.00038
1.00079
1.00222
1.00448
1.01303
1.02501
1.0815
1.14772
1.53037
2.21071
4.72602
10.4235
10.6067
10.4297
10.3836
10.4427
10.5679
10.6114
10.6036
10.5584
10.5105
1
1.00002
1.00005
1.00011
1.00032
1.00065
1.00187
1.00363
1.01142
1.01985
1.07336
1.12254
1.47713
2.04067
4.29376
9.55149
10.4521
10.3333
10.2081
10.2272
10.2763
10.2599
10.172
9.9574
9.60583
1.00001
1.00003
1.0001
1.00022
1.00064
1.0013
1.00372
1.00731
1.02265
1.04037
1.14762
1.25889
2.00595
3.34438
8.05662
11.6159
11.2161
10.9668
11.0484
11.2749
11.5
11.6315
11.7305
11.808
11.864
1.00001
1.00003
1.0001
1.00022
1.00063
1.00128
1.00367
1.00722
1.02232
1.03982
1.14541
1.25497
1.98871
3.30446
7.94878
11.625
11.2132
10.956
11.0387
11.2663
11.4914
11.6237
11.7247
11.8043
11.8626
1.00001
1.00003
1.0001
1.00021
1.00061
1.00125
1.00357
1.00702
1.02164
1.03872
1.14082
1.24692
1.95203
3.21845
7.70639
11.6429
11.2036
10.9236
11.0051
11.2309
11.4545
11.5862
11.6881
11.769
11.8293
1.00001
1.00003
1.00009
1.00021
1.00059
1.0012
1.00341
1.00673
1.02063
1.03704
1.13391
1.23486
1.89695
3.08877
7.33024
11.6705
11.1915
10.8709
10.9479
11.1673
11.389
11.5191
11.6205
11.7022
11.7661
1.00001
1.00003
1.00009
1.0002
1.00056
1.00114
1.00325
1.00651
1.01927
1.03624
1.12267
1.22262
1.82137
2.92131
6.82681
11.6965
11.1789
10.802
10.8713
11.0796
11.2986
11.4248
11.5232
11.605
11.6736
1.00001
1.00003
1.00008
1.00018
1.00052
1.00107
1.00302
1.0061
1.01772
1.03451
1.11048
1.20699
1.73645
2.72693
6.21837
11.6832
11.1549
10.7173
10.775
10.9641
11.1777
11.297
11.3879
11.4655
11.5387
1.00001
1.00002
1.00008
1.00017
1.00048
1.00098
1.00277
1.0056
1.01618
1.03186
1.09909
1.19101
1.65125
2.53019
5.58746
11.5495
11.0838
10.6155
10.6597
10.8204
11.02
11.1249
11.2003
11.2645
11.3352
1
1.00002
1.00007
1.00015
1.00043
1.00089
1.00251
1.00508
1.01465
1.02888
1.08969
1.17215
1.58643
2.37248
5.15197
11.127
10.8975
10.502
10.5262
10.6436
10.8177
10.8991
10.9444
10.9749
11.0229
1
1.00002
1.00006
1.00013
1.00038
1.00079
1.00222
1.00448
1.01303
1.02501
1.0815
1.14772
1.53037
2.21071
4.72602
10.4235
10.6067
10.4297
10.3836
10.4428
10.5679
10.6114
10.6036
10.5584
10.5105
1
1.00002
1.00005
1.00011
1.00032
1.00065
1.00187
1.00363
1.01142
1.01985
1.07336
1.12254
1.47713
2.04067
4.29375
9.55148
10.4521
10.3333
10.2081
10.2272
10.2763
10.2599
10.172
9.9574
9.60583
1.00001
1.00003
1.0001
1.00022
1.00064
1.0013
1.00372
1.00731
1.02265
1.04037
1.14762
1.25889
2.00594
3.34437
8.0566
11.6159
11.2161
10.9668
11.0484
11.2749
11.5
11.6315
11.7305
11.808
11.864
1.00001
1.00003
1.0001
1.00022
1.00063
1.00128
1.00367
1.00722
1.02232
1.03982
1.14541
1.25497
1.9887
3.30446
7.94876
11.625
11.2132
10.956
11.0387
11.2663
11.4914
11.6237
11.7247
11.8043
11.8626
1.00001
1.00003
1.0001
1.00021
1.00061
1.00125
1.00357
1.00702
1.02164
1.03872
1.14082
1.24692
1.95203
3.21844
7.70637
11.6429
11.2036
10.9236
11.0051
11.2309
11.4545
11.5862
11.6881
11.769
11.8293
1.00001
1.00003
1.00009
1.00021
1.00059
1.0012
1.00341
1.00673
1.02063
1.03704
1.13391
1.23486
1.89694
3.08876
7.33021
11.6706
11.1915
10.8709
10.9479
11.1673
11.389
11.5191
11.6205
11.7022
11.7661
1.00001
1.00003
1.00009
1.0002
1.00056
1.00114
1.00325
1.00651
1.01927
1.03624
1.12267
1.22262
1.82137
2.9213
6.82679
11.6965
11.1789
10.802
10.8713
11.0796
11.2986
11.4248
11.5232
11.605
11.6736
1.00001
1.00003
1.00008
1.00018
1.00052
1.00107
1.00302
1.0061
1.01772
1.03451
1.11048
1.20699
1.73645
2.72692
6.21835
11.6832
11.1549
10.7173
10.775
10.9641
11.1777
11.297
11.3879
11.4655
11.5387
1.00001
1.00002
1.00008
1.00017
1.00048
1.00098
1.00277
1.0056
1.01618
1.03186
1.09909
1.19101
1.65125
2.53018
5.58745
11.5495
11.0838
10.6155
10.6597
10.8204
11.02
11.1249
11.2003
11.2645
11.3352
1
1.00002
1.00007
1.00015
1.00043
1.00089
1.00251
1.00508
1.01465
1.02888
1.08969
1.17215
1.58643
2.37248
5.15196
11.127
10.8975
10.502
10.5262
10.6436
10.8177
10.8991
10.9444
10.9749
11.0229
1
1.00002
1.00006
1.00013
1.00038
1.00079
1.00222
1.00448
1.01303
1.02501
1.0815
1.14772
1.53037
2.2107
4.72601
10.4235
10.6067
10.4297
10.3836
10.4427
10.5679
10.6114
10.6036
10.5584
10.5105
1
1.00002
1.00005
1.00011
1.00032
1.00065
1.00187
1.00363
1.01142
1.01985
1.07336
1.12254
1.47713
2.04067
4.29375
9.55147
10.4521
10.3333
10.2081
10.2272
10.2763
10.2599
10.172
9.9574
9.60583
1.00001
1.00003
1.0001
1.00022
1.00063
1.00129
1.00371
1.0073
1.02264
1.04035
1.1476
1.25883
2.00589
3.34415
8.05621
11.616
11.2161
10.9667
11.0483
11.2749
11.4999
11.6315
11.7304
11.8079
11.8639
1.00001
1.00003
1.0001
1.00021
1.00062
1.00127
1.00366
1.00721
1.02231
1.0398
1.14539
1.25492
1.98865
3.30424
7.94837
11.6252
11.2132
10.9559
11.0386
11.2663
11.4914
11.6237
11.7247
11.8042
11.8625
1.00001
1.00003
1.0001
1.00021
1.00061
1.00124
1.00356
1.00701
1.02163
1.0387
1.1408
1.24687
1.95198
3.21823
7.70599
11.643
11.2035
10.9235
11.005
11.2308
11.4544
11.5862
11.6881
11.7689
11.8292
1.00001
1.00003
1.00009
1.0002
1.00058
1.00119
1.0034
1.00672
1.02062
1.03702
1.13389
1.23481
1.89691
3.08859
7.32989
11.6706
11.1914
10.8708
10.9478
11.1672
11.3889
11.519
11.6204
11.7022
11.7661
1.00001
1.00002
1.00009
1.00019
1.00055
1.00114
1.00324
1.0065
1.01926
1.03621
1.12267
1.22255
1.82137
2.92114
6.82651
11.6965
11.1788
10.8019
10.8712
11.0795
11.2985
11.4247
11.5231
11.605
11.6735
1
1.00002
1.00008
1.00018
1.00052
1.00106
1.00302
1.00609
1.01771
1.03449
1.11047
1.20694
1.73643
2.72678
6.21807
11.6832
11.1548
10.7172
10.7749
10.964
11.1777
11.2969
11.3879
11.4654
11.5387
1
1.00002
1.00007
1.00016
1.00047
1.00097
1.00277
1.00559
1.01617
1.03185
1.09908
1.19097
1.65122
2.53007
5.58726
11.5494
11.0837
10.6155
10.6596
10.8203
11.0199
11.1248
11.2003
11.2645
11.3352
1
1.00002
1.00007
1.00015
1.00043
1.00088
1.0025
1.00507
1.01464
1.02887
1.08967
1.17211
1.58641
2.37238
5.15178
11.1268
10.8974
10.5019
10.5262
10.6436
10.8177
10.8991
10.9443
10.9748
11.0229
1
1.00002
1.00006
1.00013
1.00038
1.00078
1.00221
1.00447
1.01302
1.02499
1.0815
1.14766
1.53038
2.2106
4.72588
10.4232
10.6066
10.4296
10.3836
10.4427
10.5678
10.6113
10.6036
10.5583
10.5105
1
1.00001
1.00005
1.00011
1.00032
1.00065
1.00187
1.00362
1.01141
1.01983
1.07334
1.12251
1.47712
2.04056
4.29364
9.55117
10.4521
10.3333
10.208
10.2271
10.2762
10.2598
10.1719
9.95737
9.6058
1
1.00001
1.00004
1.00012
1.00024
1.0007
1.00142
1.0041
1.00799
1.02524
1.04446
1.16334
1.29205
2.11012
3.62771
8.53649
10.3576
10.2451
10.0277
9.99027
9.96435
9.86968
9.61157
9.00805
7.47558
1
1.00001
1.00003
1.0001
1.00021
1.00061
1.00124
1.00355
1.00698
1.02146
1.03846
1.13903
1.24464
1.93104
3.1564
7.34445
10.2761
10.148
9.86273
9.74552
9.65639
9.46247
9.04917
8.21953
6.62155
1
1.00001
1.00003
1.00009
1.00018
1.00052
1.00107
1.00305
1.00615
1.01788
1.03471
1.11158
1.20809
1.73979
2.71874
6.06288
10.1662
10.0406
9.72271
9.50848
9.35304
9.07685
8.56728
7.71218
6.40933
1
1.00001
1.00002
1.00007
1.00015
1.00043
1.00089
1.00251
1.00509
1.01461
1.02895
1.08804
1.17411
1.56583
2.3197
4.82946
9.83638
9.8332
9.60667
9.2909
9.06342
8.74044
8.21421
7.42224
6.3693
1
1.00001
1.00002
1.00005
1.00012
1.00034
1.0007
1.00199
1.004
1.01174
1.02213
1.07312
1.13111
1.46592
2.04798
4.15084
8.94674
9.55836
9.41044
9.09135
8.80659
8.45831
7.95609
7.24943
6.36258
1
1
1.00001
1.00003
1.00011
1.00023
1.00065
1.00133
1.00382
1.00738
1.02334
1.04075
1.14958
1.26302
2.00589
3.30926
7.51187
9.28813
9.19708
8.93976
8.5938
8.22632
7.75378
7.12183
6.35777
0.999999
1
1.00001
1.00003
1.00009
1.00019
1.00054
1.0011
1.00311
1.00627
1.01824
1.03513
1.11385
1.211
1.74828
2.7249
5.94648
9.09523
9.05228
8.83802
8.43144
8.04165
7.58938
7.02135
6.35055
0.999998
0.999999
1.00001
1.00002
1.00007
1.00014
1.00041
1.00084
1.00238
1.00482
1.01382
1.02737
1.08286
1.16427
1.52507
2.21269
4.41008
8.66957
8.91634
8.74104
8.34076
7.90145
7.45709
6.93946
6.34237
0.999996
0.999998
1
1.00002
1.00004
1.00012
1.00026
1.00073
1.00149
1.00423
1.00829
1.02547
1.04551
1.16156
1.29166
2.05879
3.46904
7.62941
8.67805
8.5623
8.24921
7.78866
7.34888
6.87038
6.33271
0.999995
0.999996
0.999999
1.00001
1.00003
1.00009
1.00019
1.00056
1.00114
1.00323
1.00646
1.01905
1.03561
1.1198
1.21728
1.78
2.77773
6.00599
8.41775
8.37741
8.16587
7.72079
7.26701
6.81464
6.32609
0.999994
0.999994
0.999997
1
1.00002
1.00005
1.00016
1.00033
1.00094
1.00191
1.00545
1.01055
1.03308
1.05817
1.20748
1.39964
2.29492
4.14789
7.95555
8.25767
8.09715
7.70745
7.21999
6.77314
6.31871
0.999993
0.999993
0.999995
0.999999
1.00001
1.00004
1.00011
1.00024
1.00068
1.00139
1.00395
1.00776
1.02362
1.04243
1.14943
1.2666
1.9668
3.19781
6.85028
8.03227
7.94742
7.6752
7.20184
6.74812
6.31584
0.999992
0.999993
0.999993
0.999997
1
1.00003
1.00006
1.00019
1.0004
1.00114
1.00224
1.00679
1.01207
1.04247
1.07021
1.26376
1.51948
2.66222
5.11361
7.67081
7.73474
7.59166
7.21918
6.74961
6.31831
0.999992
0.999992
0.999993
0.999995
1
1.00002
1.00004
1.00014
1.00029
1.00082
1.00168
1.00471
1.00943
1.02762
1.05212
1.16981
1.32913
2.06787
3.45861
6.94692
7.58734
7.48928
7.21326
6.76552
6.32976
0.999991
0.999991
0.999992
0.999993
0.999998
1.00001
1.00003
1.00008
1.00023
1.00047
1.00132
1.00264
1.00769
1.01434
1.04722
1.08088
1.29466
1.58108
2.82023
5.39783
7.30964
7.3088
7.17468
6.82801
6.36136
0.999991
0.999991
0.999992
0.999992
0.999996
1
1.00002
1.00005
1.00015
1.00032
1.0009
1.00184
1.00514
1.01032
1.0296
1.05846
1.17589
1.36833
2.08615
3.52844
6.75976
7.20866
7.11765
6.87129
6.42637
0.999991
0.999991
0.999991
0.999992
0.999993
0.999999
1.00001
1.00004
1.00008
1.00025
1.00051
1.00142
1.00288
1.00813
1.01598
1.04828
1.0892
1.29592
1.61965
2.81848
5.40613
6.97375
6.97914
6.85833
6.55277
0.999991
0.999991
0.999991
0.999991
0.999992
0.999996
1
1.00002
1.00005
1.00016
1.00033
1.00092
1.00188
1.00522
1.01035
1.03047
1.05609
1.18465
1.35682
2.09981
3.54623
6.4405
6.87666
6.80998
6.60457
0.999991
0.999991
0.999991
0.999991
0.999992
0.999993
0.999999
1.00001
1.00004
1.00008
1.00025
1.00051
1.00142
1.00288
1.0081
1.01602
1.04752
1.09082
1.28495
1.62692
2.73221
5.18257
6.63289
6.68617
6.58446
0.999991
0.99999
0.99999
0.999991
0.999991
0.999993
0.999995
1
1.00002
1.00006
1.00013
1.00038
1.00077
1.00214
1.00433
1.01214
1.02403
1.07017
1.14073
1.41591
1.93248
3.35164
6.07351
6.56478
6.51918
0.999991
0.99999
0.99999
0.999991
0.999991
0.999992
0.999993
0.999998
1.00001
1.00003
1.00008
1.00024
1.00049
1.00136
1.00276
1.00767
1.01529
1.04419
1.08576
1.26255
1.56625
2.58058
4.77372
6.27633
6.3882
0.999991
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999995
1
1.00001
1.00005
1.00012
1.00035
1.00071
1.00197
1.00398
1.01111
1.02226
1.0632
1.13056
1.37119
1.8368
3.10975
5.61466
6.24009
0.999991
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999993
0.999998
1.00001
1.00003
1.00007
1.00021
1.00044
1.00122
1.00248
1.00683
1.01365
1.0391
1.07471
1.23206
1.47359
2.36991
4.20041
5.87452
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999995
0.999999
1.00001
1.00004
1.00012
1.00026
1.00073
1.00149
1.00406
1.00817
1.02284
1.04453
1.1335
1.26184
1.78391
2.74161
5.07484
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999993
0.999996
1
1.00002
1.00007
1.00015
1.00043
1.00088
1.0024
1.00484
1.01342
1.02649
1.0775
1.15047
1.45634
1.98822
3.46683
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999994
0.999997
1.00001
1.00003
1.0001
1.00021
1.00058
1.00117
1.00323
1.00637
1.01858
1.03382
1.11086
1.19823
1.6475
2.37121
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999995
1
1.00002
1.00004
1.00014
1.00029
1.00079
1.0016
1.00439
1.00879
1.02472
1.04773
1.142
1.28703
1.79824
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999993
0.999997
1
1.00003
1.00006
1.00019
1.00039
1.00107
1.00218
1.00596
1.0119
1.03361
1.06534
1.19384
1.39969
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999994
0.999998
1.00001
1.00003
1.0001
1.00022
1.0006
1.00124
1.00335
1.00676
1.01865
1.03647
1.10822
1.20407
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999995
1
1.00002
1.00004
1.00013
1.00028
1.00078
1.00158
1.00428
1.00857
1.02369
1.04735
1.13256
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999993
0.999997
1
1.00002
1.00006
1.00018
1.00037
1.00101
1.00205
1.00556
1.01112
1.03089
1.06147
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999993
0.999998
1.00001
1.00003
1.00008
1.00023
1.00048
1.0013
1.00262
1.00714
1.01435
1.0394
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999995
0.999999
1.00001
1.00004
1.00012
1.00025
1.00069
1.00141
1.0038
1.00764
1.02079
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999996
1
1.00002
1.00005
1.00015
1.00031
1.00084
1.00171
1.00458
1.00918
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999993
0.999997
1
1.00003
1.00006
1.00019
1.00039
1.00105
1.00212
1.00569
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999993
0.999999
1.00001
1.00004
1.00008
1.00023
1.00048
1.00129
1.00261
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999994
1
1.00001
1.00005
1.0001
1.00029
1.00059
1.00158
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999996
1
1.00002
1.00005
1.00015
1.00032
1.00087
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999993
0.999998
1.00001
1.00003
1.00008
1.00023
1.00048
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999993
0.999997
1
1.00003
1.00006
1.00019
1.00039
1
1.00002
1.00004
1.00012
1.00025
1.0007
1.00143
1.00411
1.008
1.02525
1.04448
1.16336
1.2921
2.11015
3.62788
8.53678
10.3576
10.2452
10.0278
9.99035
9.96442
9.86974
9.61162
9.00808
7.4756
1
1.00001
1.00004
1.0001
1.00022
1.00061
1.00125
1.00355
1.007
1.02147
1.03848
1.13905
1.24469
1.93107
3.15656
7.34475
10.2761
10.148
9.8628
9.74559
9.65646
9.46253
9.04921
8.21956
6.62158
1
1.00001
1.00003
1.00009
1.00019
1.00053
1.00108
1.00305
1.00616
1.01789
1.03473
1.11159
1.20814
1.73981
2.71888
6.06317
10.1662
10.0406
9.72278
9.50854
9.3531
9.07691
8.56732
7.71222
6.40938
1
1.00001
1.00003
1.00008
1.00016
1.00044
1.0009
1.00252
1.0051
1.01462
1.02896
1.08806
1.17415
1.56585
2.31981
4.82961
9.83652
9.83329
9.60673
9.29096
9.06348
8.7405
8.21425
7.42228
6.36933
1
1.00001
1.00002
1.00006
1.00012
1.00035
1.00071
1.002
1.00401
1.01175
1.02215
1.07312
1.13117
1.46591
2.04808
4.15094
8.94698
9.55844
9.4105
9.09141
8.80665
8.45837
7.95614
7.24948
6.36262
1
1.00001
1.00002
1.00004
1.00012
1.00024
1.00066
1.00134
1.00383
1.0074
1.02335
1.04077
1.1496
1.26306
2.00591
3.3094
7.51209
9.28818
9.19713
8.93981
8.59385
8.22637
7.75382
7.12187
6.35781
1
1
1.00002
1.00003
1.00009
1.00019
1.00054
1.00111
1.00312
1.00629
1.01825
1.03515
1.11385
1.21105
1.74828
2.72502
5.94669
9.0953
9.05235
8.83806
8.43149
8.04169
7.58943
7.02139
6.35059
1
1
1.00001
1.00003
1.00007
1.00015
1.00042
1.00085
1.00239
1.00483
1.01383
1.02738
1.08287
1.1643
1.52509
2.21277
4.4102
8.66971
8.91639
8.74109
8.34079
7.9015
7.45713
6.93949
6.3424
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00424
1.0083
1.02548
1.04553
1.16158
1.2917
2.05884
3.46917
7.62965
8.67809
8.56234
8.24924
7.7887
7.34892
6.8704
6.33273
1
1
1.00001
1.00002
1.00004
1.0001
1.0002
1.00057
1.00115
1.00324
1.00647
1.01906
1.03563
1.1198
1.21734
1.78
2.77787
6.00618
8.41778
8.37744
8.1659
7.72081
7.26704
6.81467
6.32612
1
1
1
1.00001
1.00003
1.00006
1.00017
1.00034
1.00095
1.00192
1.00546
1.01056
1.03309
1.05819
1.2075
1.39972
2.295
4.1482
7.95562
8.25769
8.09716
7.70747
7.22
6.77316
6.31873
1
1
1
1.00001
1.00002
1.00004
1.00012
1.00025
1.00069
1.0014
1.00396
1.00778
1.02363
1.04244
1.14945
1.26664
1.96684
3.19797
6.85049
8.03228
7.94743
7.6752
7.20184
6.74813
6.31586
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.00041
1.00115
1.00225
1.00679
1.01209
1.04248
1.07024
1.26378
1.51955
2.66233
5.11391
7.67086
7.73472
7.59164
7.21917
6.74961
6.31833
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.00083
1.00169
1.00472
1.00944
1.02763
1.05214
1.16983
1.32919
2.06792
3.45877
6.94708
7.58734
7.48928
7.21325
6.76552
6.32977
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00048
1.00133
1.00265
1.0077
1.01436
1.04723
1.08091
1.29468
1.58115
2.82033
5.39807
7.30969
7.30883
7.17469
6.828
6.36138
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00091
1.00185
1.00515
1.01033
1.02961
1.05848
1.1759
1.3684
2.08612
3.52871
6.75988
7.20871
7.11768
6.87131
6.42639
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00025
1.00052
1.00143
1.00289
1.00814
1.016
1.04829
1.08922
1.29596
1.61967
2.81866
5.40641
6.97384
6.9792
6.85836
6.55277
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00017
1.00034
1.00093
1.00189
1.00523
1.01036
1.03048
1.05611
1.18466
1.35686
2.09996
3.5466
6.44061
6.8767
6.81001
6.60459
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00026
1.00052
1.00143
1.00289
1.00811
1.01603
1.04753
1.09085
1.28498
1.62702
2.73237
5.18291
6.63297
6.68619
6.58448
1
1
1
1
1
1
1
1.00001
1.00003
1.00007
1.00014
1.00039
1.00078
1.00215
1.00434
1.01215
1.02405
1.07019
1.14076
1.41595
1.93259
3.3518
6.07372
6.56484
6.51921
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00025
1.0005
1.00137
1.00277
1.00768
1.0153
1.0442
1.08579
1.26258
1.56632
2.58075
4.77411
6.27645
6.38824
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00013
1.00036
1.00072
1.00198
1.00399
1.01112
1.02227
1.06322
1.13059
1.37123
1.8369
3.10994
5.61492
6.24017
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00008
1.00022
1.00045
1.00123
1.00249
1.00684
1.01366
1.03911
1.07475
1.23205
1.47376
2.36999
4.20089
5.8747
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00407
1.00818
1.02285
1.04456
1.13352
1.26191
1.78399
2.74185
5.07524
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00008
1.00016
1.00044
1.00089
1.00241
1.00485
1.01343
1.0265
1.07753
1.15052
1.45643
1.98844
3.46734
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00022
1.00059
1.00118
1.00324
1.00638
1.01859
1.03384
1.11088
1.19828
1.64759
2.37144
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.0008
1.00161
1.0044
1.0088
1.02473
1.04775
1.14201
1.28711
1.79831
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00108
1.00219
1.00597
1.01191
1.03363
1.06535
1.19389
1.39975
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00023
1.00061
1.00125
1.00336
1.00677
1.01866
1.03649
1.10824
1.20413
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00014
1.00029
1.00079
1.00159
1.00429
1.00858
1.0237
1.04737
1.13258
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00007
1.00019
1.00038
1.00102
1.00206
1.00558
1.01113
1.03091
1.06147
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.00131
1.00264
1.00715
1.01437
1.03942
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00026
1.0007
1.00142
1.00381
1.00765
1.02081
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00032
1.00085
1.00172
1.0046
1.00919
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00106
1.00213
1.0057
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.0013
1.00262
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00011
1.0003
1.0006
1.00159
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00088
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1
1.00002
1.00004
1.00012
1.00025
1.0007
1.00143
1.00411
1.008
1.02525
1.04448
1.16336
1.2921
2.11015
3.62789
8.53679
10.3576
10.2452
10.0278
9.99035
9.96442
9.86974
9.61162
9.00808
7.4756
1
1.00001
1.00004
1.0001
1.00022
1.00061
1.00125
1.00355
1.007
1.02147
1.03848
1.13905
1.24469
1.93107
3.15657
7.34477
10.2761
10.148
9.8628
9.74559
9.65646
9.46253
9.04921
8.21957
6.62158
1
1.00001
1.00003
1.00009
1.00019
1.00053
1.00108
1.00305
1.00616
1.01789
1.03473
1.11159
1.20814
1.73982
2.71889
6.06318
10.1662
10.0406
9.72278
9.50855
9.3531
9.07691
8.56732
7.71222
6.40938
1
1.00001
1.00003
1.00008
1.00016
1.00044
1.0009
1.00252
1.0051
1.01462
1.02896
1.08806
1.17415
1.56586
2.31981
4.82962
9.83653
9.8333
9.60673
9.29096
9.06348
8.7405
8.21425
7.42228
6.36934
1
1.00001
1.00002
1.00006
1.00012
1.00035
1.00071
1.002
1.00401
1.01175
1.02215
1.07312
1.13117
1.46591
2.04808
4.15094
8.94699
9.55844
9.4105
9.09141
8.80665
8.45837
7.95614
7.24948
6.36262
1
1.00001
1.00002
1.00004
1.00012
1.00024
1.00066
1.00134
1.00383
1.0074
1.02335
1.04077
1.1496
1.26306
2.00591
3.3094
7.5121
9.28818
9.19713
8.93981
8.59385
8.22637
7.75382
7.12187
6.35781
1
1
1.00002
1.00003
1.00009
1.00019
1.00054
1.00111
1.00312
1.00629
1.01825
1.03515
1.11385
1.21105
1.74828
2.72502
5.9467
9.0953
9.05235
8.83806
8.43149
8.0417
7.58943
7.02139
6.35059
1
1
1.00001
1.00003
1.00007
1.00015
1.00042
1.00085
1.00239
1.00483
1.01383
1.02738
1.08287
1.1643
1.52509
2.21278
4.4102
8.66972
8.91639
8.74109
8.3408
7.9015
7.45713
6.93949
6.3424
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00424
1.0083
1.02548
1.04553
1.16158
1.2917
2.05885
3.46917
7.62966
8.67809
8.56234
8.24924
7.7887
7.34892
6.8704
6.33273
1
1
1.00001
1.00002
1.00004
1.0001
1.0002
1.00057
1.00115
1.00324
1.00647
1.01906
1.03563
1.1198
1.21734
1.78001
2.77787
6.00619
8.41778
8.37744
8.1659
7.72081
7.26704
6.81467
6.32612
1
1
1
1.00001
1.00003
1.00006
1.00017
1.00034
1.00095
1.00192
1.00546
1.01056
1.03309
1.05819
1.2075
1.39972
2.295
4.14822
7.95562
8.25769
8.09717
7.70747
7.22
6.77316
6.31873
1
1
1
1.00001
1.00002
1.00004
1.00012
1.00025
1.00069
1.0014
1.00396
1.00778
1.02363
1.04244
1.14946
1.26664
1.96685
3.19798
6.8505
8.03229
7.94743
7.6752
7.20184
6.74813
6.31586
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.00041
1.00115
1.00225
1.00679
1.01209
1.04248
1.07024
1.26378
1.51955
2.66233
5.11393
7.67086
7.73472
7.59164
7.21917
6.74961
6.31833
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.00083
1.00169
1.00472
1.00944
1.02763
1.05214
1.16983
1.3292
2.06792
3.45878
6.94709
7.58734
7.48928
7.21325
6.76552
6.32977
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00048
1.00133
1.00265
1.0077
1.01436
1.04723
1.08091
1.29469
1.58115
2.82033
5.39809
7.30969
7.30883
7.17469
6.828
6.36138
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00091
1.00185
1.00515
1.01033
1.02961
1.05848
1.1759
1.36841
2.08612
3.52872
6.75989
7.20871
7.11768
6.87131
6.42639
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00025
1.00052
1.00143
1.00289
1.00814
1.016
1.04829
1.08922
1.29596
1.61967
2.81867
5.40642
6.97385
6.9792
6.85837
6.55278
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00017
1.00034
1.00093
1.00189
1.00523
1.01036
1.03048
1.05611
1.18466
1.35686
2.09996
3.54662
6.44062
6.8767
6.81002
6.60459
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00026
1.00052
1.00143
1.00289
1.00811
1.01603
1.04753
1.09085
1.28498
1.62702
2.73238
5.18293
6.63298
6.6862
6.58448
1
1
1
1
1
1
1
1.00001
1.00003
1.00007
1.00014
1.00039
1.00078
1.00215
1.00434
1.01215
1.02405
1.07019
1.14076
1.41596
1.93259
3.35181
6.07373
6.56484
6.51922
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00025
1.0005
1.00137
1.00277
1.00768
1.0153
1.0442
1.08579
1.26258
1.56632
2.58076
4.77413
6.27645
6.38825
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00013
1.00036
1.00072
1.00198
1.00399
1.01112
1.02227
1.06322
1.13059
1.37123
1.83691
3.10994
5.61493
6.24018
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00008
1.00022
1.00045
1.00123
1.00249
1.00684
1.01366
1.03911
1.07475
1.23205
1.47377
2.36999
4.20091
5.87471
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00407
1.00818
1.02285
1.04456
1.13352
1.26192
1.78399
2.74186
5.07525
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00008
1.00016
1.00044
1.00089
1.00241
1.00485
1.01343
1.0265
1.07753
1.15052
1.45643
1.98845
3.46736
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00022
1.00059
1.00119
1.00324
1.00638
1.01859
1.03384
1.11088
1.19828
1.6476
2.37145
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.0008
1.00161
1.0044
1.0088
1.02473
1.04775
1.14202
1.28712
1.79832
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00108
1.00219
1.00597
1.01191
1.03363
1.06535
1.1939
1.39975
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00023
1.00061
1.00125
1.00336
1.00677
1.01866
1.03649
1.10824
1.20413
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00014
1.00029
1.00079
1.00159
1.00429
1.00858
1.0237
1.04737
1.13258
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00007
1.00019
1.00038
1.00102
1.00206
1.00558
1.01113
1.03091
1.06147
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.00131
1.00264
1.00715
1.01437
1.03942
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00026
1.0007
1.00142
1.00381
1.00765
1.02081
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00032
1.00085
1.00172
1.0046
1.00919
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00106
1.00213
1.0057
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.0013
1.00262
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00011
1.0003
1.0006
1.00159
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00088
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1
1.00002
1.00004
1.00012
1.00025
1.0007
1.00143
1.00411
1.008
1.02525
1.04448
1.16336
1.2921
2.11015
3.62789
8.53679
10.3576
10.2452
10.0278
9.99035
9.96442
9.86974
9.61162
9.00808
7.4756
1
1.00001
1.00004
1.0001
1.00022
1.00061
1.00125
1.00355
1.007
1.02147
1.03848
1.13905
1.24469
1.93107
3.15657
7.34477
10.2761
10.148
9.8628
9.74559
9.65646
9.46253
9.04921
8.21957
6.62158
1
1.00001
1.00003
1.00009
1.00019
1.00053
1.00108
1.00305
1.00616
1.01789
1.03473
1.11159
1.20814
1.73982
2.71889
6.06319
10.1662
10.0406
9.72278
9.50855
9.3531
9.07691
8.56732
7.71222
6.40938
1
1.00001
1.00003
1.00008
1.00016
1.00044
1.0009
1.00252
1.0051
1.01462
1.02896
1.08806
1.17415
1.56586
2.31981
4.82962
9.83653
9.8333
9.60673
9.29096
9.06348
8.7405
8.21425
7.42228
6.36934
1
1.00001
1.00002
1.00006
1.00012
1.00035
1.00071
1.002
1.00401
1.01175
1.02215
1.07312
1.13117
1.46591
2.04808
4.15094
8.947
9.55844
9.4105
9.09141
8.80665
8.45837
7.95614
7.24948
6.36262
1
1.00001
1.00002
1.00004
1.00012
1.00024
1.00066
1.00134
1.00383
1.0074
1.02335
1.04077
1.1496
1.26306
2.00591
3.3094
7.5121
9.28818
9.19713
8.93981
8.59385
8.22637
7.75382
7.12187
6.35781
1
1
1.00002
1.00003
1.00009
1.00019
1.00054
1.00111
1.00312
1.00629
1.01825
1.03515
1.11385
1.21105
1.74828
2.72502
5.94671
9.0953
9.05235
8.83806
8.43149
8.0417
7.58943
7.02139
6.35059
1
1
1.00001
1.00003
1.00007
1.00015
1.00042
1.00085
1.00239
1.00483
1.01383
1.02738
1.08287
1.1643
1.52509
2.21278
4.41021
8.66972
8.91639
8.74109
8.3408
7.9015
7.45713
6.93949
6.3424
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00424
1.0083
1.02548
1.04553
1.16158
1.2917
2.05885
3.46917
7.62966
8.67809
8.56234
8.24924
7.7887
7.34892
6.8704
6.33273
1
1
1.00001
1.00002
1.00004
1.0001
1.0002
1.00057
1.00115
1.00324
1.00647
1.01906
1.03563
1.1198
1.21734
1.78001
2.77787
6.00619
8.41778
8.37744
8.1659
7.72081
7.26704
6.81467
6.32612
1
1
1
1.00001
1.00003
1.00006
1.00017
1.00034
1.00095
1.00192
1.00546
1.01056
1.03309
1.05819
1.2075
1.39972
2.295
4.14822
7.95562
8.25769
8.09716
7.70747
7.22
6.77316
6.31873
1
1
1
1.00001
1.00002
1.00004
1.00012
1.00025
1.00069
1.0014
1.00396
1.00778
1.02363
1.04244
1.14946
1.26664
1.96685
3.19798
6.85051
8.03229
7.94743
7.6752
7.20184
6.74813
6.31586
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.00041
1.00115
1.00225
1.00679
1.01209
1.04248
1.07024
1.26378
1.51955
2.66234
5.11393
7.67086
7.73472
7.59164
7.21917
6.74961
6.31833
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.00083
1.00169
1.00472
1.00944
1.02763
1.05214
1.16983
1.3292
2.06792
3.45878
6.94709
7.58734
7.48928
7.21325
6.76552
6.32977
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00048
1.00133
1.00265
1.0077
1.01436
1.04723
1.08091
1.29469
1.58115
2.82033
5.39809
7.30969
7.30883
7.17469
6.828
6.36138
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00091
1.00185
1.00515
1.01033
1.02961
1.05848
1.1759
1.36841
2.08612
3.52872
6.75989
7.20871
7.11768
6.87131
6.42639
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00025
1.00052
1.00143
1.00289
1.00814
1.016
1.04829
1.08922
1.29596
1.61967
2.81867
5.40642
6.97385
6.9792
6.85837
6.55278
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00017
1.00034
1.00093
1.00189
1.00523
1.01036
1.03048
1.05611
1.18466
1.35686
2.09996
3.54662
6.44062
6.8767
6.81002
6.60459
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00026
1.00052
1.00143
1.00289
1.00811
1.01603
1.04753
1.09085
1.28498
1.62703
2.73238
5.18293
6.63298
6.6862
6.58448
1
1
1
1
1
1
1
1.00001
1.00003
1.00007
1.00014
1.00039
1.00078
1.00215
1.00434
1.01215
1.02405
1.07019
1.14076
1.41596
1.93259
3.35181
6.07373
6.56484
6.51922
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00025
1.0005
1.00137
1.00277
1.00768
1.0153
1.0442
1.08579
1.26258
1.56632
2.58076
4.77413
6.27646
6.38825
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00013
1.00036
1.00072
1.00198
1.00399
1.01112
1.02227
1.06322
1.13059
1.37123
1.83691
3.10995
5.61493
6.24018
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00008
1.00022
1.00045
1.00123
1.00249
1.00684
1.01366
1.03911
1.07475
1.23205
1.47377
2.37
4.20091
5.87471
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00407
1.00818
1.02285
1.04456
1.13352
1.26192
1.78399
2.74186
5.07526
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00008
1.00016
1.00044
1.00089
1.00241
1.00485
1.01343
1.0265
1.07753
1.15052
1.45643
1.98845
3.46737
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00022
1.00059
1.00119
1.00324
1.00638
1.01859
1.03384
1.11088
1.19828
1.6476
2.37145
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.0008
1.00161
1.0044
1.0088
1.02473
1.04775
1.14202
1.28712
1.79832
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00108
1.00219
1.00597
1.01191
1.03363
1.06535
1.1939
1.39975
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00023
1.00061
1.00125
1.00336
1.00677
1.01866
1.03649
1.10824
1.20413
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00014
1.00029
1.00079
1.00159
1.00429
1.00858
1.0237
1.04737
1.13258
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00007
1.00019
1.00038
1.00102
1.00206
1.00558
1.01113
1.03091
1.06147
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.00131
1.00264
1.00715
1.01437
1.03942
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00026
1.0007
1.00142
1.00381
1.00765
1.02081
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00032
1.00085
1.00172
1.0046
1.00919
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00106
1.00213
1.0057
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.0013
1.00262
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00011
1.0003
1.0006
1.00159
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00088
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1
1.00002
1.00004
1.00012
1.00025
1.0007
1.00143
1.00411
1.008
1.02525
1.04448
1.16336
1.2921
2.11015
3.62789
8.5368
10.3576
10.2452
10.0278
9.99035
9.96442
9.86974
9.61162
9.00808
7.4756
1
1.00001
1.00004
1.0001
1.00022
1.00061
1.00125
1.00355
1.007
1.02147
1.03848
1.13905
1.24469
1.93108
3.15657
7.34477
10.2761
10.148
9.8628
9.74559
9.65646
9.46253
9.04921
8.21956
6.62158
1
1.00001
1.00003
1.00009
1.00019
1.00053
1.00108
1.00305
1.00616
1.01789
1.03473
1.11159
1.20814
1.73982
2.71889
6.06319
10.1662
10.0406
9.72278
9.50855
9.3531
9.07691
8.56732
7.71222
6.40938
1
1.00001
1.00003
1.00008
1.00016
1.00044
1.0009
1.00252
1.0051
1.01462
1.02896
1.08806
1.17415
1.56586
2.31981
4.82962
9.83653
9.8333
9.60673
9.29096
9.06348
8.7405
8.21425
7.42228
6.36934
1
1.00001
1.00002
1.00006
1.00012
1.00035
1.00071
1.002
1.00401
1.01175
1.02215
1.07312
1.13117
1.46591
2.04808
4.15095
8.947
9.55844
9.4105
9.09141
8.80665
8.45837
7.95614
7.24948
6.36262
1
1.00001
1.00002
1.00004
1.00012
1.00024
1.00066
1.00134
1.00383
1.0074
1.02335
1.04077
1.1496
1.26306
2.00591
3.30941
7.51211
9.28818
9.19713
8.93981
8.59385
8.22637
7.75382
7.12187
6.35781
1
1
1.00002
1.00003
1.00009
1.00019
1.00054
1.00111
1.00312
1.00629
1.01825
1.03515
1.11385
1.21106
1.74828
2.72502
5.94671
9.0953
9.05235
8.83806
8.43149
8.0417
7.58943
7.02139
6.35059
1
1
1.00001
1.00003
1.00007
1.00015
1.00042
1.00085
1.00239
1.00483
1.01383
1.02738
1.08287
1.1643
1.52509
2.21278
4.41021
8.66973
8.91639
8.74109
8.3408
7.9015
7.45713
6.93949
6.3424
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00424
1.0083
1.02548
1.04553
1.16158
1.2917
2.05885
3.46918
7.62967
8.67809
8.56234
8.24924
7.7887
7.34892
6.8704
6.33273
1
1
1.00001
1.00002
1.00004
1.0001
1.0002
1.00057
1.00115
1.00324
1.00647
1.01906
1.03563
1.1198
1.21734
1.78001
2.77787
6.0062
8.41778
8.37744
8.1659
7.72081
7.26704
6.81467
6.32612
1
1
1
1.00001
1.00003
1.00006
1.00017
1.00034
1.00095
1.00192
1.00546
1.01056
1.03309
1.05819
1.2075
1.39972
2.295
4.14823
7.95562
8.25769
8.09716
7.70747
7.22
6.77316
6.31873
1
1
1
1.00001
1.00002
1.00004
1.00012
1.00025
1.00069
1.0014
1.00396
1.00778
1.02363
1.04244
1.14946
1.26664
1.96685
3.19798
6.85051
8.03229
7.94743
7.6752
7.20184
6.74813
6.31586
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.00041
1.00115
1.00225
1.00679
1.01209
1.04248
1.07024
1.26378
1.51955
2.66234
5.11394
7.67086
7.73472
7.59164
7.21917
6.74961
6.31833
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.00083
1.00169
1.00472
1.00944
1.02763
1.05214
1.16983
1.3292
2.06792
3.45878
6.94709
7.58734
7.48928
7.21325
6.76552
6.32977
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00048
1.00133
1.00265
1.0077
1.01436
1.04723
1.08091
1.29469
1.58115
2.82033
5.39809
7.30969
7.30883
7.17469
6.828
6.36138
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00091
1.00185
1.00515
1.01033
1.02961
1.05848
1.1759
1.36841
2.08612
3.52872
6.75989
7.20871
7.11768
6.87131
6.42639
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00025
1.00052
1.00143
1.00289
1.00814
1.016
1.04829
1.08922
1.29596
1.61967
2.81868
5.40643
6.97385
6.9792
6.85837
6.55278
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00017
1.00034
1.00093
1.00189
1.00523
1.01036
1.03048
1.05611
1.18466
1.35686
2.09997
3.54663
6.44062
6.8767
6.81002
6.60459
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00026
1.00052
1.00143
1.00289
1.00811
1.01603
1.04753
1.09085
1.28498
1.62703
2.73238
5.18293
6.63298
6.6862
6.58448
1
1
1
1
1
1
1
1.00001
1.00003
1.00007
1.00014
1.00039
1.00078
1.00215
1.00434
1.01215
1.02405
1.07019
1.14076
1.41596
1.93259
3.35181
6.07373
6.56484
6.51922
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00025
1.0005
1.00137
1.00277
1.00768
1.0153
1.0442
1.08579
1.26258
1.56632
2.58076
4.77414
6.27646
6.38825
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00013
1.00036
1.00072
1.00198
1.00399
1.01112
1.02227
1.06322
1.13059
1.37123
1.83691
3.10995
5.61494
6.24018
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00008
1.00022
1.00045
1.00123
1.00249
1.00684
1.01366
1.03911
1.07475
1.23205
1.47377
2.37
4.20092
5.87471
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00407
1.00818
1.02285
1.04456
1.13352
1.26192
1.78399
2.74186
5.07526
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00008
1.00016
1.00044
1.00089
1.00241
1.00485
1.01343
1.02651
1.07753
1.15052
1.45643
1.98845
3.46737
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00022
1.00059
1.00119
1.00324
1.00638
1.01859
1.03384
1.11088
1.19828
1.6476
2.37146
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.0008
1.00161
1.0044
1.0088
1.02473
1.04775
1.14202
1.28712
1.79832
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00108
1.00219
1.00597
1.01191
1.03363
1.06535
1.1939
1.39975
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00023
1.00061
1.00125
1.00336
1.00677
1.01866
1.03649
1.10824
1.20413
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00014
1.00029
1.00079
1.00159
1.00429
1.00858
1.0237
1.04738
1.13258
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00007
1.00019
1.00038
1.00102
1.00206
1.00558
1.01113
1.03091
1.06147
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.00131
1.00264
1.00715
1.01437
1.03942
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00026
1.0007
1.00142
1.00381
1.00765
1.02081
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00032
1.00085
1.00172
1.0046
1.00919
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00106
1.00213
1.0057
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.0013
1.00262
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00011
1.0003
1.0006
1.00159
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00088
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1
1.00002
1.00004
1.00012
1.00025
1.0007
1.00143
1.00411
1.008
1.02525
1.04448
1.16336
1.2921
2.11015
3.62789
8.5368
10.3576
10.2452
10.0278
9.99035
9.96442
9.86974
9.61162
9.00808
7.4756
1
1.00001
1.00004
1.0001
1.00022
1.00061
1.00125
1.00355
1.007
1.02147
1.03848
1.13905
1.24469
1.93108
3.15657
7.34477
10.2761
10.148
9.8628
9.74559
9.65646
9.46253
9.04921
8.21957
6.62158
1
1.00001
1.00003
1.00009
1.00019
1.00053
1.00108
1.00305
1.00616
1.01789
1.03473
1.11159
1.20814
1.73982
2.71889
6.06319
10.1662
10.0406
9.72278
9.50855
9.3531
9.07691
8.56732
7.71222
6.40938
1
1.00001
1.00003
1.00008
1.00016
1.00044
1.0009
1.00252
1.0051
1.01462
1.02896
1.08806
1.17415
1.56586
2.31981
4.82962
9.83653
9.8333
9.60673
9.29096
9.06348
8.7405
8.21425
7.42228
6.36934
1
1.00001
1.00002
1.00006
1.00012
1.00035
1.00071
1.002
1.00401
1.01175
1.02215
1.07312
1.13117
1.46591
2.04808
4.15095
8.947
9.55844
9.4105
9.09141
8.80665
8.45837
7.95614
7.24948
6.36262
1
1.00001
1.00002
1.00004
1.00012
1.00024
1.00066
1.00134
1.00383
1.0074
1.02335
1.04077
1.1496
1.26306
2.00591
3.3094
7.5121
9.28818
9.19713
8.93981
8.59385
8.22637
7.75382
7.12187
6.35781
1
1
1.00002
1.00003
1.00009
1.00019
1.00054
1.00111
1.00312
1.00629
1.01825
1.03515
1.11385
1.21105
1.74828
2.72502
5.94671
9.0953
9.05235
8.83806
8.43149
8.0417
7.58943
7.02139
6.35059
1
1
1.00001
1.00003
1.00007
1.00015
1.00042
1.00085
1.00239
1.00483
1.01383
1.02738
1.08287
1.1643
1.52509
2.21278
4.41021
8.66972
8.91639
8.74109
8.3408
7.9015
7.45713
6.93949
6.3424
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00424
1.0083
1.02548
1.04553
1.16158
1.2917
2.05885
3.46917
7.62966
8.67809
8.56234
8.24924
7.7887
7.34892
6.8704
6.33273
1
1
1.00001
1.00002
1.00004
1.0001
1.0002
1.00057
1.00115
1.00324
1.00647
1.01906
1.03563
1.1198
1.21734
1.78001
2.77787
6.00619
8.41778
8.37744
8.1659
7.72081
7.26704
6.81467
6.32612
1
1
1
1.00001
1.00003
1.00006
1.00017
1.00034
1.00095
1.00192
1.00546
1.01056
1.03309
1.05819
1.2075
1.39972
2.295
4.14823
7.95562
8.25769
8.09716
7.70747
7.22
6.77316
6.31873
1
1
1
1.00001
1.00002
1.00004
1.00012
1.00025
1.00069
1.0014
1.00396
1.00778
1.02363
1.04244
1.14946
1.26664
1.96685
3.19798
6.85051
8.03229
7.94743
7.6752
7.20184
6.74813
6.31586
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.00041
1.00115
1.00225
1.00679
1.01209
1.04248
1.07024
1.26378
1.51955
2.66234
5.11393
7.67086
7.73472
7.59164
7.21917
6.74961
6.31833
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.00083
1.00169
1.00472
1.00944
1.02763
1.05214
1.16983
1.3292
2.06792
3.45878
6.94709
7.58734
7.48928
7.21325
6.76552
6.32977
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00048
1.00133
1.00265
1.0077
1.01436
1.04723
1.08091
1.29469
1.58115
2.82033
5.39809
7.30969
7.30883
7.17469
6.828
6.36138
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00091
1.00185
1.00515
1.01033
1.02961
1.05848
1.1759
1.36841
2.08612
3.52872
6.75989
7.20871
7.11768
6.87131
6.42639
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00025
1.00052
1.00143
1.00289
1.00814
1.016
1.04829
1.08922
1.29596
1.61967
2.81867
5.40642
6.97385
6.9792
6.85837
6.55278
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00017
1.00034
1.00093
1.00189
1.00523
1.01036
1.03048
1.05611
1.18466
1.35686
2.09996
3.54662
6.44062
6.8767
6.81002
6.60459
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00026
1.00052
1.00143
1.00289
1.00811
1.01603
1.04753
1.09085
1.28498
1.62703
2.73238
5.18293
6.63298
6.6862
6.58448
1
1
1
1
1
1
1
1.00001
1.00003
1.00007
1.00014
1.00039
1.00078
1.00215
1.00434
1.01215
1.02405
1.07019
1.14076
1.41596
1.93259
3.35181
6.07373
6.56484
6.51922
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00025
1.0005
1.00137
1.00277
1.00768
1.0153
1.0442
1.08579
1.26258
1.56632
2.58076
4.77413
6.27646
6.38825
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00013
1.00036
1.00072
1.00198
1.00399
1.01112
1.02227
1.06322
1.13059
1.37123
1.83691
3.10995
5.61494
6.24018
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00008
1.00022
1.00045
1.00123
1.00249
1.00684
1.01366
1.03911
1.07475
1.23205
1.47377
2.37
4.20092
5.87471
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00407
1.00818
1.02285
1.04456
1.13352
1.26192
1.78399
2.74186
5.07526
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00008
1.00016
1.00044
1.00089
1.00241
1.00485
1.01343
1.02651
1.07753
1.15052
1.45643
1.98845
3.46737
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00022
1.00059
1.00119
1.00324
1.00638
1.01859
1.03384
1.11088
1.19828
1.6476
2.37145
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.0008
1.00161
1.0044
1.0088
1.02473
1.04775
1.14202
1.28712
1.79832
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00108
1.00219
1.00597
1.01191
1.03363
1.06535
1.1939
1.39975
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00023
1.00061
1.00125
1.00336
1.00677
1.01866
1.03649
1.10824
1.20413
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00014
1.00029
1.00079
1.00159
1.00429
1.00858
1.0237
1.04737
1.13258
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00007
1.00019
1.00038
1.00102
1.00206
1.00558
1.01113
1.03091
1.06147
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.00131
1.00264
1.00715
1.01437
1.03942
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00026
1.0007
1.00142
1.00381
1.00765
1.02081
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00032
1.00085
1.00172
1.0046
1.00919
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00106
1.00213
1.0057
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.0013
1.00262
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00011
1.0003
1.0006
1.00159
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00088
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1
1.00002
1.00004
1.00012
1.00025
1.0007
1.00143
1.00411
1.008
1.02525
1.04448
1.16336
1.2921
2.11015
3.62789
8.53679
10.3576
10.2452
10.0278
9.99035
9.96442
9.86974
9.61162
9.00808
7.4756
1
1.00001
1.00004
1.0001
1.00022
1.00061
1.00125
1.00355
1.007
1.02147
1.03848
1.13905
1.24469
1.93107
3.15657
7.34477
10.2761
10.148
9.8628
9.74559
9.65646
9.46253
9.04921
8.21957
6.62158
1
1.00001
1.00003
1.00009
1.00019
1.00053
1.00108
1.00305
1.00616
1.01789
1.03473
1.11159
1.20814
1.73982
2.71889
6.06319
10.1662
10.0406
9.72278
9.50855
9.3531
9.07691
8.56732
7.71222
6.40938
1
1.00001
1.00003
1.00008
1.00016
1.00044
1.0009
1.00252
1.0051
1.01462
1.02896
1.08806
1.17415
1.56586
2.31981
4.82962
9.83653
9.8333
9.60673
9.29096
9.06348
8.7405
8.21425
7.42228
6.36934
1
1.00001
1.00002
1.00006
1.00012
1.00035
1.00071
1.002
1.00401
1.01175
1.02215
1.07312
1.13117
1.46591
2.04808
4.15094
8.94699
9.55844
9.4105
9.09141
8.80665
8.45837
7.95614
7.24948
6.36262
1
1.00001
1.00002
1.00004
1.00012
1.00024
1.00066
1.00134
1.00383
1.0074
1.02335
1.04077
1.1496
1.26306
2.00591
3.3094
7.5121
9.28818
9.19713
8.93981
8.59385
8.22637
7.75382
7.12187
6.35781
1
1
1.00002
1.00003
1.00009
1.00019
1.00054
1.00111
1.00312
1.00629
1.01825
1.03515
1.11385
1.21105
1.74828
2.72502
5.94671
9.0953
9.05235
8.83806
8.43149
8.0417
7.58943
7.02139
6.35059
1
1
1.00001
1.00003
1.00007
1.00015
1.00042
1.00085
1.00239
1.00483
1.01383
1.02738
1.08287
1.1643
1.52509
2.21278
4.4102
8.66972
8.91639
8.74109
8.3408
7.9015
7.45713
6.93949
6.3424
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00424
1.0083
1.02548
1.04553
1.16158
1.2917
2.05885
3.46917
7.62966
8.67809
8.56234
8.24924
7.7887
7.34892
6.8704
6.33273
1
1
1.00001
1.00002
1.00004
1.0001
1.0002
1.00057
1.00115
1.00324
1.00647
1.01906
1.03563
1.1198
1.21734
1.78001
2.77787
6.00619
8.41778
8.37744
8.1659
7.72081
7.26704
6.81467
6.32612
1
1
1
1.00001
1.00003
1.00006
1.00017
1.00034
1.00095
1.00192
1.00546
1.01056
1.03309
1.05819
1.2075
1.39972
2.295
4.14822
7.95562
8.25769
8.09716
7.70747
7.22
6.77316
6.31873
1
1
1
1.00001
1.00002
1.00004
1.00012
1.00025
1.00069
1.0014
1.00396
1.00778
1.02363
1.04244
1.14946
1.26664
1.96685
3.19798
6.85051
8.03229
7.94743
7.6752
7.20184
6.74813
6.31586
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.00041
1.00115
1.00225
1.00679
1.01209
1.04248
1.07024
1.26378
1.51955
2.66234
5.11393
7.67086
7.73472
7.59164
7.21917
6.74961
6.31833
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.00083
1.00169
1.00472
1.00944
1.02763
1.05214
1.16983
1.3292
2.06792
3.45878
6.94709
7.58734
7.48928
7.21325
6.76552
6.32977
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00048
1.00133
1.00265
1.0077
1.01436
1.04723
1.08091
1.29469
1.58115
2.82033
5.39809
7.30969
7.30883
7.17469
6.828
6.36138
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00091
1.00185
1.00515
1.01033
1.02961
1.05848
1.1759
1.36841
2.08612
3.52872
6.75989
7.20871
7.11768
6.87131
6.42639
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00025
1.00052
1.00143
1.00289
1.00814
1.016
1.04829
1.08922
1.29596
1.61967
2.81867
5.40642
6.97385
6.9792
6.85837
6.55278
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00017
1.00034
1.00093
1.00189
1.00523
1.01036
1.03048
1.05611
1.18466
1.35686
2.09996
3.54662
6.44062
6.8767
6.81002
6.60459
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00026
1.00052
1.00143
1.00289
1.00811
1.01603
1.04753
1.09085
1.28498
1.62703
2.73238
5.18293
6.63298
6.6862
6.58448
1
1
1
1
1
1
1
1.00001
1.00003
1.00007
1.00014
1.00039
1.00078
1.00215
1.00434
1.01215
1.02405
1.07019
1.14076
1.41596
1.93259
3.35181
6.07373
6.56484
6.51922
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00025
1.0005
1.00137
1.00277
1.00768
1.0153
1.0442
1.08579
1.26258
1.56632
2.58076
4.77413
6.27645
6.38825
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00013
1.00036
1.00072
1.00198
1.00399
1.01112
1.02227
1.06322
1.13059
1.37123
1.83691
3.10995
5.61493
6.24018
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00008
1.00022
1.00045
1.00123
1.00249
1.00684
1.01366
1.03911
1.07475
1.23205
1.47377
2.37
4.20091
5.87471
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00407
1.00818
1.02285
1.04456
1.13352
1.26192
1.78399
2.74186
5.07525
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00008
1.00016
1.00044
1.00089
1.00241
1.00485
1.01343
1.0265
1.07753
1.15052
1.45643
1.98845
3.46737
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00022
1.00059
1.00119
1.00324
1.00638
1.01859
1.03384
1.11088
1.19828
1.6476
2.37145
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.0008
1.00161
1.0044
1.0088
1.02473
1.04775
1.14202
1.28712
1.79832
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00108
1.00219
1.00597
1.01191
1.03363
1.06535
1.1939
1.39975
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00023
1.00061
1.00125
1.00336
1.00677
1.01866
1.03649
1.10824
1.20413
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00014
1.00029
1.00079
1.00159
1.00429
1.00858
1.0237
1.04737
1.13258
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00007
1.00019
1.00038
1.00102
1.00206
1.00558
1.01113
1.03091
1.06147
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.00131
1.00264
1.00715
1.01437
1.03942
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00026
1.0007
1.00142
1.00381
1.00765
1.02081
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00032
1.00085
1.00172
1.0046
1.00919
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00106
1.00213
1.0057
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.0013
1.00262
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00011
1.0003
1.0006
1.00159
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00088
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1
1.00002
1.00004
1.00012
1.00025
1.0007
1.00143
1.00411
1.008
1.02525
1.04448
1.16336
1.2921
2.11015
3.62789
8.53679
10.3576
10.2452
10.0278
9.99035
9.96442
9.86974
9.61162
9.00808
7.4756
1
1.00001
1.00004
1.0001
1.00022
1.00061
1.00125
1.00355
1.007
1.02147
1.03848
1.13905
1.24469
1.93107
3.15657
7.34477
10.2761
10.148
9.8628
9.74559
9.65646
9.46253
9.04921
8.21957
6.62158
1
1.00001
1.00003
1.00009
1.00019
1.00053
1.00108
1.00305
1.00616
1.01789
1.03473
1.11159
1.20814
1.73982
2.71889
6.06318
10.1662
10.0406
9.72278
9.50855
9.3531
9.07691
8.56732
7.71222
6.40938
1
1.00001
1.00003
1.00008
1.00016
1.00044
1.0009
1.00252
1.0051
1.01462
1.02896
1.08806
1.17415
1.56586
2.31981
4.82962
9.83653
9.8333
9.60673
9.29096
9.06348
8.7405
8.21425
7.42228
6.36934
1
1.00001
1.00002
1.00006
1.00012
1.00035
1.00071
1.002
1.00401
1.01175
1.02215
1.07312
1.13117
1.46591
2.04808
4.15094
8.94699
9.55844
9.4105
9.09141
8.80665
8.45837
7.95614
7.24948
6.36262
1
1.00001
1.00002
1.00004
1.00012
1.00024
1.00066
1.00134
1.00383
1.0074
1.02335
1.04077
1.1496
1.26306
2.00591
3.3094
7.5121
9.28818
9.19713
8.93981
8.59385
8.22637
7.75382
7.12187
6.35781
1
1
1.00002
1.00003
1.00009
1.00019
1.00054
1.00111
1.00312
1.00629
1.01825
1.03515
1.11385
1.21105
1.74828
2.72502
5.9467
9.0953
9.05235
8.83806
8.43149
8.0417
7.58943
7.02139
6.35059
1
1
1.00001
1.00003
1.00007
1.00015
1.00042
1.00085
1.00239
1.00483
1.01383
1.02738
1.08287
1.1643
1.52509
2.21278
4.4102
8.66972
8.91639
8.74109
8.3408
7.9015
7.45713
6.93949
6.3424
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00424
1.0083
1.02548
1.04553
1.16158
1.2917
2.05885
3.46917
7.62966
8.67809
8.56234
8.24924
7.7887
7.34892
6.8704
6.33273
1
1
1.00001
1.00002
1.00004
1.0001
1.0002
1.00057
1.00115
1.00324
1.00647
1.01906
1.03563
1.1198
1.21734
1.78001
2.77787
6.00619
8.41778
8.37744
8.1659
7.72081
7.26704
6.81467
6.32612
1
1
1
1.00001
1.00003
1.00006
1.00017
1.00034
1.00095
1.00192
1.00546
1.01056
1.03309
1.05819
1.2075
1.39972
2.295
4.14822
7.95562
8.25769
8.09717
7.70747
7.22
6.77316
6.31873
1
1
1
1.00001
1.00002
1.00004
1.00012
1.00025
1.00069
1.0014
1.00396
1.00778
1.02363
1.04244
1.14946
1.26664
1.96685
3.19798
6.8505
8.03229
7.94743
7.6752
7.20184
6.74813
6.31586
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.00041
1.00115
1.00225
1.00679
1.01209
1.04248
1.07024
1.26378
1.51955
2.66233
5.11393
7.67086
7.73472
7.59164
7.21917
6.74961
6.31833
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.00083
1.00169
1.00472
1.00944
1.02763
1.05214
1.16983
1.3292
2.06792
3.45878
6.94709
7.58734
7.48928
7.21325
6.76552
6.32977
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00048
1.00133
1.00265
1.0077
1.01436
1.04723
1.08091
1.29469
1.58115
2.82033
5.39809
7.30969
7.30883
7.17469
6.828
6.36138
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00091
1.00185
1.00515
1.01033
1.02961
1.05848
1.1759
1.36841
2.08612
3.52872
6.75989
7.20871
7.11768
6.87131
6.42639
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00025
1.00052
1.00143
1.00289
1.00814
1.016
1.04829
1.08922
1.29596
1.61967
2.81867
5.40642
6.97385
6.9792
6.85837
6.55278
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00017
1.00034
1.00093
1.00189
1.00523
1.01036
1.03048
1.05611
1.18466
1.35686
2.09996
3.54662
6.44062
6.8767
6.81002
6.60459
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00026
1.00052
1.00143
1.00289
1.00811
1.01603
1.04753
1.09085
1.28498
1.62702
2.73238
5.18293
6.63298
6.6862
6.58448
1
1
1
1
1
1
1
1.00001
1.00003
1.00007
1.00014
1.00039
1.00078
1.00215
1.00434
1.01215
1.02405
1.07019
1.14076
1.41596
1.93259
3.35181
6.07373
6.56484
6.51922
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00025
1.0005
1.00137
1.00277
1.00768
1.0153
1.0442
1.08579
1.26258
1.56632
2.58076
4.77413
6.27645
6.38825
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00013
1.00036
1.00072
1.00198
1.00399
1.01112
1.02227
1.06322
1.13059
1.37123
1.83691
3.10994
5.61493
6.24018
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00008
1.00022
1.00045
1.00123
1.00249
1.00684
1.01366
1.03911
1.07475
1.23205
1.47377
2.36999
4.20091
5.87471
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00407
1.00818
1.02285
1.04456
1.13352
1.26192
1.78399
2.74186
5.07525
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00008
1.00016
1.00044
1.00089
1.00241
1.00485
1.01343
1.0265
1.07753
1.15052
1.45643
1.98845
3.46736
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00022
1.00059
1.00119
1.00324
1.00638
1.01859
1.03384
1.11088
1.19828
1.6476
2.37145
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.0008
1.00161
1.0044
1.0088
1.02473
1.04775
1.14202
1.28712
1.79832
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00108
1.00219
1.00597
1.01191
1.03363
1.06535
1.1939
1.39975
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00023
1.00061
1.00125
1.00336
1.00677
1.01866
1.03649
1.10824
1.20413
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00014
1.00029
1.00079
1.00159
1.00429
1.00858
1.0237
1.04737
1.13258
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00007
1.00019
1.00038
1.00102
1.00206
1.00558
1.01113
1.03091
1.06147
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.00131
1.00264
1.00715
1.01437
1.03942
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00026
1.0007
1.00142
1.00381
1.00765
1.02081
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00032
1.00085
1.00172
1.0046
1.00919
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00106
1.00213
1.0057
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.0013
1.00262
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00011
1.0003
1.0006
1.00159
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00088
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1
1.00002
1.00004
1.00012
1.00025
1.0007
1.00143
1.00411
1.008
1.02525
1.04448
1.16336
1.2921
2.11015
3.62788
8.53678
10.3576
10.2452
10.0278
9.99035
9.96442
9.86974
9.61162
9.00808
7.4756
1
1.00001
1.00004
1.0001
1.00022
1.00061
1.00125
1.00355
1.007
1.02147
1.03848
1.13905
1.24469
1.93107
3.15656
7.34475
10.2761
10.148
9.8628
9.74559
9.65646
9.46253
9.04921
8.21956
6.62158
1
1.00001
1.00003
1.00009
1.00019
1.00053
1.00108
1.00305
1.00616
1.01789
1.03473
1.11159
1.20814
1.73981
2.71888
6.06317
10.1662
10.0406
9.72278
9.50854
9.3531
9.07691
8.56732
7.71222
6.40938
1
1.00001
1.00003
1.00008
1.00016
1.00044
1.0009
1.00252
1.0051
1.01462
1.02896
1.08806
1.17415
1.56585
2.31981
4.82961
9.83652
9.83329
9.60673
9.29096
9.06348
8.7405
8.21425
7.42228
6.36933
1
1.00001
1.00002
1.00006
1.00012
1.00035
1.00071
1.002
1.00401
1.01175
1.02215
1.07312
1.13117
1.46591
2.04808
4.15094
8.94698
9.55844
9.4105
9.09141
8.80665
8.45837
7.95614
7.24948
6.36262
1
1.00001
1.00002
1.00004
1.00012
1.00024
1.00066
1.00134
1.00383
1.0074
1.02335
1.04077
1.1496
1.26306
2.00591
3.3094
7.51209
9.28818
9.19713
8.93981
8.59385
8.22637
7.75382
7.12187
6.35781
1
1
1.00002
1.00003
1.00009
1.00019
1.00054
1.00111
1.00312
1.00629
1.01825
1.03515
1.11385
1.21105
1.74828
2.72502
5.94669
9.0953
9.05235
8.83806
8.43149
8.04169
7.58943
7.02139
6.35059
1
1
1.00001
1.00003
1.00007
1.00015
1.00042
1.00085
1.00239
1.00483
1.01383
1.02738
1.08287
1.1643
1.52509
2.21277
4.4102
8.66971
8.91639
8.74109
8.34079
7.9015
7.45713
6.93949
6.3424
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00424
1.0083
1.02548
1.04553
1.16158
1.2917
2.05884
3.46917
7.62965
8.67809
8.56234
8.24924
7.7887
7.34892
6.8704
6.33273
1
1
1.00001
1.00002
1.00004
1.0001
1.0002
1.00057
1.00115
1.00324
1.00647
1.01906
1.03563
1.1198
1.21734
1.78
2.77787
6.00618
8.41778
8.37744
8.1659
7.72081
7.26704
6.81467
6.32612
1
1
1
1.00001
1.00003
1.00006
1.00017
1.00034
1.00095
1.00192
1.00546
1.01056
1.03309
1.05819
1.2075
1.39972
2.295
4.1482
7.95562
8.25769
8.09716
7.70747
7.22
6.77316
6.31873
1
1
1
1.00001
1.00002
1.00004
1.00012
1.00025
1.00069
1.0014
1.00396
1.00778
1.02363
1.04244
1.14945
1.26664
1.96684
3.19797
6.85049
8.03228
7.94743
7.6752
7.20184
6.74813
6.31586
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.00041
1.00115
1.00225
1.00679
1.01209
1.04248
1.07024
1.26378
1.51955
2.66233
5.11391
7.67086
7.73472
7.59164
7.21917
6.74961
6.31833
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.00083
1.00169
1.00472
1.00944
1.02763
1.05214
1.16983
1.32919
2.06792
3.45877
6.94708
7.58734
7.48928
7.21325
6.76552
6.32977
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00048
1.00133
1.00265
1.0077
1.01436
1.04723
1.08091
1.29468
1.58115
2.82033
5.39807
7.30969
7.30883
7.17469
6.828
6.36138
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00091
1.00185
1.00515
1.01033
1.02961
1.05848
1.1759
1.3684
2.08612
3.52871
6.75988
7.20871
7.11768
6.87131
6.42639
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00025
1.00052
1.00143
1.00289
1.00814
1.016
1.04829
1.08922
1.29596
1.61967
2.81866
5.40641
6.97384
6.9792
6.85836
6.55277
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00017
1.00034
1.00093
1.00189
1.00523
1.01036
1.03048
1.05611
1.18466
1.35686
2.09996
3.5466
6.44061
6.8767
6.81001
6.60459
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00009
1.00026
1.00052
1.00143
1.00289
1.00811
1.01603
1.04753
1.09085
1.28498
1.62702
2.73237
5.18291
6.63297
6.68619
6.58448
1
1
1
1
1
1
1
1.00001
1.00003
1.00007
1.00014
1.00039
1.00078
1.00215
1.00434
1.01215
1.02405
1.07019
1.14076
1.41595
1.93259
3.3518
6.07372
6.56484
6.51921
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00025
1.0005
1.00137
1.00277
1.00768
1.0153
1.0442
1.08579
1.26258
1.56632
2.58075
4.77411
6.27645
6.38824
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00013
1.00036
1.00072
1.00198
1.00399
1.01112
1.02227
1.06322
1.13059
1.37123
1.8369
3.10994
5.61492
6.24017
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00008
1.00022
1.00045
1.00123
1.00249
1.00684
1.01366
1.03911
1.07475
1.23205
1.47376
2.36999
4.20089
5.8747
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00027
1.00074
1.0015
1.00407
1.00818
1.02285
1.04456
1.13352
1.26191
1.78399
2.74185
5.07524
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00008
1.00016
1.00044
1.00089
1.00241
1.00485
1.01343
1.0265
1.07753
1.15052
1.45643
1.98844
3.46734
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00022
1.00059
1.00118
1.00324
1.00638
1.01859
1.03384
1.11088
1.19828
1.64759
2.37144
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00015
1.0003
1.0008
1.00161
1.0044
1.0088
1.02473
1.04775
1.14201
1.28711
1.79831
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00108
1.00219
1.00597
1.01191
1.03363
1.06535
1.19389
1.39975
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00011
1.00023
1.00061
1.00125
1.00336
1.00677
1.01866
1.03649
1.10824
1.20413
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00003
1.00005
1.00014
1.00029
1.00079
1.00159
1.00429
1.00858
1.0237
1.04737
1.13258
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00007
1.00019
1.00038
1.00102
1.00206
1.00558
1.01113
1.03091
1.06147
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.00131
1.00264
1.00715
1.01437
1.03942
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00005
1.00013
1.00026
1.0007
1.00142
1.00381
1.00765
1.02081
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00032
1.00085
1.00172
1.0046
1.00919
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1.00106
1.00213
1.0057
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1.0013
1.00262
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00006
1.00011
1.0003
1.0006
1.00159
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00003
1.00006
1.00016
1.00033
1.00088
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00002
1.00004
1.00009
1.00024
1.00049
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1.00001
1.00001
1.00004
1.00007
1.0002
1.0004
1
1.00001
1.00004
1.00012
1.00024
1.0007
1.00142
1.0041
1.00799
1.02524
1.04446
1.16334
1.29205
2.11012
3.62771
8.53649
10.3576
10.2451
10.0277
9.99027
9.96435
9.86968
9.61157
9.00805
7.47558
1
1.00001
1.00003
1.0001
1.00021
1.00061
1.00124
1.00355
1.00698
1.02146
1.03846
1.13903
1.24464
1.93104
3.1564
7.34445
10.2761
10.148
9.86273
9.74551
9.65639
9.46247
9.04917
8.21953
6.62155
1
1.00001
1.00003
1.00009
1.00018
1.00052
1.00107
1.00305
1.00615
1.01788
1.03471
1.11158
1.20809
1.73979
2.71874
6.06288
10.1662
10.0406
9.72271
9.50848
9.35304
9.07685
8.56728
7.71218
6.40933
1
1.00001
1.00002
1.00007
1.00015
1.00043
1.00089
1.00251
1.00509
1.01461
1.02895
1.08804
1.17411
1.56583
2.3197
4.82946
9.83638
9.8332
9.60667
9.2909
9.06342
8.74044
8.21421
7.42224
6.3693
1
1.00001
1.00002
1.00005
1.00012
1.00034
1.0007
1.00199
1.004
1.01174
1.02213
1.07312
1.13111
1.46592
2.04798
4.15084
8.94673
9.55836
9.41044
9.09135
8.80659
8.45831
7.95609
7.24943
6.36258
1
1
1.00001
1.00003
1.00011
1.00023
1.00065
1.00133
1.00382
1.00738
1.02334
1.04075
1.14958
1.26302
2.00589
3.30926
7.51187
9.28813
9.19708
8.93976
8.5938
8.22632
7.75378
7.12183
6.35777
0.999999
1
1.00001
1.00003
1.00009
1.00019
1.00054
1.0011
1.00311
1.00627
1.01824
1.03513
1.11385
1.211
1.74828
2.7249
5.94648
9.09523
9.05228
8.83802
8.43144
8.04165
7.58938
7.02135
6.35055
0.999998
0.999999
1.00001
1.00002
1.00007
1.00014
1.00041
1.00084
1.00238
1.00482
1.01382
1.02737
1.08286
1.16427
1.52507
2.21269
4.41008
8.66956
8.91634
8.74104
8.34076
7.90145
7.45709
6.93946
6.34237
0.999996
0.999998
1
1.00002
1.00004
1.00012
1.00026
1.00073
1.00149
1.00423
1.00829
1.02547
1.04551
1.16156
1.29166
2.05879
3.46904
7.62941
8.67805
8.5623
8.24921
7.78866
7.34888
6.87038
6.3327
0.999995
0.999996
0.999999
1.00001
1.00003
1.00009
1.00019
1.00056
1.00114
1.00323
1.00646
1.01905
1.03561
1.1198
1.21728
1.78
2.77773
6.00598
8.41775
8.37741
8.16587
7.72079
7.26701
6.81464
6.32609
0.999994
0.999994
0.999997
1
1.00002
1.00005
1.00016
1.00033
1.00094
1.00191
1.00545
1.01055
1.03308
1.05817
1.20748
1.39964
2.29492
4.14788
7.95555
8.25767
8.09715
7.70745
7.21999
6.77314
6.31871
0.999993
0.999993
0.999995
0.999999
1.00001
1.00004
1.00011
1.00024
1.00068
1.00139
1.00395
1.00776
1.02362
1.04243
1.14943
1.2666
1.9668
3.19781
6.85027
8.03227
7.94742
7.6752
7.20184
6.74812
6.31584
0.999992
0.999993
0.999993
0.999997
1
1.00003
1.00006
1.00019
1.0004
1.00114
1.00224
1.00679
1.01207
1.04247
1.07021
1.26376
1.51948
2.66222
5.11361
7.67081
7.73475
7.59166
7.21918
6.74961
6.31831
0.999992
0.999992
0.999993
0.999995
1
1.00002
1.00004
1.00014
1.00029
1.00082
1.00168
1.00471
1.00943
1.02762
1.05212
1.16981
1.32913
2.06787
3.45861
6.94692
7.58734
7.48928
7.21325
6.76552
6.32976
0.999991
0.999991
0.999992
0.999993
0.999998
1.00001
1.00003
1.00008
1.00023
1.00047
1.00132
1.00264
1.00769
1.01434
1.04722
1.08088
1.29466
1.58108
2.82023
5.39783
7.30964
7.3088
7.17468
6.828
6.36136
0.999991
0.999991
0.999992
0.999992
0.999996
1
1.00002
1.00005
1.00015
1.00032
1.0009
1.00184
1.00514
1.01032
1.0296
1.05846
1.17589
1.36833
2.08615
3.52844
6.75976
7.20866
7.11765
6.8713
6.42637
0.999991
0.999991
0.999991
0.999992
0.999993
0.999999
1.00001
1.00004
1.00008
1.00025
1.00051
1.00142
1.00288
1.00813
1.01598
1.04828
1.0892
1.29592
1.61965
2.81848
5.40613
6.97375
6.97914
6.85833
6.55277
0.999991
0.999991
0.999991
0.999991
0.999992
0.999996
1
1.00002
1.00005
1.00016
1.00033
1.00092
1.00188
1.00522
1.01035
1.03047
1.05609
1.18465
1.35682
2.0998
3.54623
6.4405
6.87666
6.80998
6.60457
0.999991
0.999991
0.999991
0.999991
0.999992
0.999993
0.999999
1.00001
1.00004
1.00008
1.00025
1.00051
1.00142
1.00288
1.0081
1.01602
1.04752
1.09082
1.28494
1.62692
2.73221
5.18256
6.63289
6.68617
6.58446
0.999991
0.99999
0.99999
0.999991
0.999991
0.999993
0.999995
1
1.00002
1.00006
1.00013
1.00038
1.00077
1.00214
1.00433
1.01214
1.02403
1.07017
1.14073
1.41591
1.93248
3.35163
6.07351
6.56478
6.51918
0.999991
0.99999
0.99999
0.999991
0.999991
0.999992
0.999993
0.999998
1.00001
1.00003
1.00008
1.00024
1.00049
1.00136
1.00276
1.00767
1.01529
1.04419
1.08576
1.26255
1.56625
2.58058
4.77372
6.27633
6.3882
0.999991
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999995
1
1.00001
1.00005
1.00012
1.00035
1.00071
1.00197
1.00398
1.01111
1.02226
1.0632
1.13056
1.37119
1.8368
3.10975
5.61465
6.24009
0.999991
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999993
0.999998
1.00001
1.00003
1.00007
1.00021
1.00044
1.00122
1.00248
1.00683
1.01365
1.0391
1.07471
1.23206
1.47359
2.36991
4.2004
5.87452
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999995
0.999999
1.00001
1.00004
1.00012
1.00026
1.00073
1.00149
1.00406
1.00817
1.02284
1.04453
1.1335
1.26184
1.78391
2.74161
5.07484
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999993
0.999996
1
1.00002
1.00007
1.00015
1.00043
1.00088
1.0024
1.00484
1.01342
1.02649
1.0775
1.15047
1.45634
1.98822
3.46682
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999994
0.999997
1.00001
1.00003
1.0001
1.00021
1.00058
1.00117
1.00323
1.00637
1.01858
1.03382
1.11085
1.19823
1.6475
2.37121
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999995
1
1.00002
1.00004
1.00014
1.00029
1.00079
1.0016
1.00439
1.00879
1.02472
1.04773
1.142
1.28703
1.79824
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999993
0.999997
1
1.00003
1.00006
1.00019
1.00039
1.00107
1.00218
1.00596
1.0119
1.03361
1.06534
1.19384
1.39969
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999994
0.999998
1.00001
1.00003
1.0001
1.00022
1.0006
1.00124
1.00335
1.00676
1.01865
1.03647
1.10822
1.20406
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999995
1
1.00002
1.00004
1.00013
1.00028
1.00078
1.00158
1.00428
1.00857
1.02369
1.04735
1.13256
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999993
0.999997
1
1.00002
1.00006
1.00018
1.00037
1.00101
1.00205
1.00556
1.01112
1.03089
1.06147
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999993
0.999998
1.00001
1.00003
1.00008
1.00023
1.00048
1.0013
1.00262
1.00714
1.01435
1.0394
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999995
0.999999
1.00001
1.00004
1.00012
1.00025
1.00069
1.00141
1.0038
1.00764
1.02079
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999996
1
1.00002
1.00005
1.00015
1.00031
1.00084
1.00171
1.00458
1.00918
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999993
0.999997
1
1.00003
1.00006
1.00019
1.00039
1.00105
1.00212
1.00569
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999993
0.999999
1.00001
1.00004
1.00008
1.00023
1.00048
1.00129
1.00261
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999994
1
1.00001
1.00005
1.0001
1.00029
1.00059
1.00158
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999992
0.999996
1
1.00002
1.00005
1.00015
1.00032
1.00087
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999992
0.999993
0.999998
1.00001
1.00003
1.00008
1.00023
1.00048
0.999991
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.99999
0.999991
0.999991
0.999993
0.999997
1
1.00003
1.00006
1.00019
1.00039
3.06389
1.5557
1.04736
0.942483
0.968234
1.047
1.21278
1.34496
1.38604
1.3844
1.37913
1.37929
1.38126
1.38658
1.39739
1.40525
1.40782
1.40764
1.40702
1.40565
1.40382
1.40228
1.40089
1.39921
1.3971
1.39489
1.39411
1.39455
1.39657
1.40278
1.41911
1.45908
1.55313
1.77012
2.27216
3.2952
3.70007
3.67842
3.70216
3.72307
3.7914
3.90608
4.05294
4.19834
4.3231
4.41639
4.5032
4.55881
4.59359
4.61186
4.61766
4.61511
4.60532
4.58425
4.55613
4.52456
4.49091
4.45446
4.41542
4.37383
4.32979
4.28377
4.23591
4.18651
4.13597
4.0841
4.03175
3.9789
3.92574
3.8721
3.81868
3.76523
3.71185
3.6586
3.60553
3.55282
3.5004
3.44857
3.39721
3.34646
3.29633
3.24691
3.19809
3.14998
3.10243
3.05568
3.00951
2.96411
2.91932
2.87551
2.83228
2.78992
2.74818
2.70744
2.66752
2.62899
2.592
2.55784
2.52789
2.50682
3.71839
2.31608
1.71691
1.46597
1.34998
1.27844
1.26402
1.27193
1.29406
1.33968
1.38503
1.40381
1.40352
1.40221
1.4001
1.40044
1.40157
1.40405
1.40681
1.40679
1.40646
1.4055
1.40342
1.40019
1.39707
1.39438
1.39271
1.39309
1.39488
1.40033
1.41415
1.4475
1.52622
1.70988
2.13692
3.08996
3.72008
3.70363
3.69947
3.72624
3.79491
3.8954
4.02287
4.16699
4.29396
4.39653
4.47934
4.53664
4.57342
4.59319
4.60051
4.59918
4.59305
4.57738
4.54869
4.51609
4.48256
4.44661
4.4084
4.36722
4.32378
4.27804
4.23065
4.18157
4.13138
4.07997
4.02789
3.97525
3.92232
3.86906
3.81576
3.76245
3.70919
3.65606
3.6031
3.55047
3.49817
3.4464
3.3951
3.34443
3.29431
3.2449
3.19612
3.14803
3.10059
3.05397
3.00811
2.96292
2.91843
2.87445
2.83128
2.78879
2.74721
2.70636
2.66656
2.6278
2.59073
2.55603
2.52546
2.50374
4.54538
3.2422
2.42434
1.90808
1.57867
1.37481
1.25761
1.24501
1.2524
1.27385
1.31852
1.36075
1.3879
1.40075
1.40314
1.40283
1.402
1.40144
1.40151
1.40151
1.40141
1.40107
1.40023
1.3985
1.39579
1.3929
1.39003
1.3899
1.39066
1.39385
1.40252
1.42604
1.47845
1.60922
1.89716
2.56152
3.61142
3.77512
3.7999
3.84124
3.90295
3.9809
4.06984
4.1699
4.26672
4.36256
4.44311
4.50234
4.54163
4.56316
4.57153
4.57078
4.56707
4.55679
4.53481
4.50236
4.46862
4.43325
4.39565
4.35531
4.31263
4.26763
4.22083
4.17241
4.12275
4.07202
4.02048
3.96836
3.91583
3.86302
3.81003
3.75698
3.70397
3.65104
3.59833
3.54586
3.49381
3.44216
3.39113
3.34062
3.29075
3.2415
3.19306
3.14526
3.09824
3.05166
3.00582
2.96058
2.91614
2.87227
2.82925
2.78683
2.74536
2.70451
2.66476
2.62587
2.5886
2.55334
2.52198
2.49847
4.99806
3.8235
2.95367
2.34792
1.94205
1.66923
1.49827
1.39167
1.32998
1.31426
1.31768
1.32906
1.35328
1.38141
1.40082
1.41087
1.41081
1.4101
1.40834
1.40525
1.40331
1.40216
1.40129
1.40029
1.39852
1.39598
1.39276
1.3901
1.39042
1.39201
1.39769
1.41149
1.44738
1.53155
1.72861
2.18756
3.20278
3.79342
4.03477
4.12452
4.16751
4.19607
4.20563
4.21649
4.24363
4.29926
4.36868
4.43256
4.484
4.51569
4.5303
4.53182
4.52979
4.52336
4.50878
4.48058
4.44756
4.41248
4.37557
4.33646
4.29508
4.2514
4.20573
4.15836
4.10963
4.05978
4.0091
3.9577
3.90585
3.85359
3.80114
3.74852
3.69593
3.64336
3.59103
3.53889
3.48721
3.43587
3.38513
3.33492
3.28554
3.23665
3.18846
3.1408
3.0939
3.04749
3.00187
2.95678
2.91256
2.86885
2.82604
2.78372
2.74239
2.70158
2.66188
2.62291
2.58546
2.54969
2.51738
2.49205
5.27092
4.24377
3.40832
2.77519
2.31289
1.9767
1.73296
1.55882
1.4372
1.36078
1.32043
1.32044
1.32387
1.33373
1.3541
1.37435
1.38908
1.39825
1.40088
1.40054
1.39948
1.39724
1.39456
1.39226
1.39029
1.38848
1.38709
1.38525
1.3854
1.38638
1.38951
1.39836
1.4207
1.4734
1.60089
1.88333
2.50854
3.68277
4.37195
4.59433
4.58973
4.5464
4.43792
4.30892
4.24921
4.25296
4.27417
4.32401
4.38814
4.43747
4.46831
4.48232
4.48212
4.47934
4.47105
4.45265
4.4219
4.38685
4.35015
4.31198
4.272
4.22995
4.18592
4.14008
4.0927
4.04403
3.99438
3.94391
3.89287
3.84131
3.7895
3.73745
3.68541
3.6333
3.58149
3.52977
3.47858
3.4278
3.37772
3.32804
3.27905
3.23046
3.18257
3.13512
3.08848
3.04229
2.99695
2.95206
2.90808
2.86454
2.82197
2.77981
2.73867
2.698
2.65842
2.61947
2.58194
2.54584
2.51297
2.48609
5.4569
4.56562
3.78999
3.16117
2.67018
2.29314
2.00587
1.78921
1.62705
1.5101
1.42543
1.37172
1.34285
1.34037
1.34279
1.35001
1.36509
1.3818
1.39465
1.40286
1.40425
1.40384
1.4026
1.3999
1.39592
1.39225
1.38918
1.38641
1.3852
1.38566
1.38734
1.3936
1.4066
1.44411
1.52295
1.71972
2.16153
3.1777
4.68266
5.19978
5.14476
4.98588
4.69455
4.45152
4.29511
4.22955
4.22152
4.22859
4.25413
4.30692
4.3572
4.39471
4.41421
4.41816
4.41577
4.40742
4.38855
4.35652
4.32019
4.28223
4.24298
4.20237
4.1603
4.11654
4.07112
4.02416
3.97598
3.92673
3.87672
3.82605
3.77504
3.72369
3.67233
3.62077
3.5696
3.51873
3.46834
3.41822
3.36869
3.31941
3.27079
3.22249
3.17495
3.12777
3.08145
3.03551
2.9905
2.94586
2.90218
2.85889
2.81658
2.77468
2.73375
2.6933
2.65385
2.61503
2.57747
2.54119
2.50798
2.47996
5.58459
4.81007
4.10285
3.49782
2.99977
2.59865
2.27954
2.02733
1.82855
1.67353
1.55326
1.46482
1.39991
1.36188
1.34197
1.34206
1.34413
1.34993
1.36188
1.3744
1.38372
1.39015
1.3907
1.39039
1.3894
1.38731
1.3842
1.38125
1.37964
1.38
1.38164
1.38627
1.39815
1.42665
1.49256
1.64825
2.01033
2.86277
4.72372
5.84313
5.75911
5.50691
5.07342
4.70734
4.44756
4.2873
4.20593
4.17968
4.17701
4.1856
4.21157
4.2622
4.30337
4.33325
4.34421
4.34284
4.33634
4.32045
4.28875
4.25212
4.2127
4.17237
4.13143
4.08943
4.04604
4.00114
3.95486
3.90718
3.85848
3.80885
3.75873
3.70815
3.65754
3.60699
3.55671
3.50655
3.45688
3.4073
3.35829
3.30944
3.26128
3.21336
3.16625
3.11943
3.0735
3.0279
2.98322
2.93893
2.89555
2.85259
2.81054
2.76895
2.72825
2.68808
2.6488
2.61017
2.57269
2.53634
2.50299
2.47419
5.67767
4.99567
4.35233
3.77989
3.28964
2.87958
2.54173
2.26557
2.04106
1.85971
1.71378
1.59808
1.50782
1.44057
1.39123
1.36296
1.34731
1.34738
1.34911
1.35398
1.36404
1.37527
1.38408
1.39068
1.39093
1.3904
1.38889
1.38577
1.38232
1.38248
1.38359
1.3892
1.39925
1.43146
1.49046
1.64457
1.95391
2.66304
4.13381
5.9037
5.98434
5.85009
5.51995
5.11758
4.74846
4.48658
4.30487
4.19298
4.14268
4.12423
4.12493
4.13446
4.15985
4.20722
4.2385
4.25925
4.26019
4.25656
4.24483
4.21939
4.1826
4.14232
4.10112
4.05924
4.01685
3.97362
3.92937
3.88362
3.83667
3.78846
3.73943
3.68995
3.64049
3.59089
3.54156
3.49212
3.44313
3.39414
3.34572
3.2974
3.24978
3.20237
3.15574
3.1094
3.06389
3.01875
2.97446
2.93059
2.88756
2.845
2.80327
2.76205
2.72164
2.68178
2.64275
2.60434
2.56702
2.53069
2.49732
2.46803
5.74505
5.13905
4.55373
4.01708
3.54291
3.13407
2.78717
2.49591
2.2527
2.05079
1.88342
1.74564
1.633
1.54205
1.4706
1.41679
1.37791
1.35649
1.34565
1.34583
1.34735
1.35139
1.3596
1.36789
1.37381
1.37783
1.37974
1.3797
1.37974
1.3805
1.38274
1.39094
1.40774
1.45159
1.54111
1.74055
2.14039
2.93998
3.70091
4.69307
5.51933
5.67654
5.61657
5.43035
5.08923
4.80048
4.52472
4.32954
4.19623
4.11386
4.08126
4.06551
4.06735
4.07815
4.1037
4.14075
4.16255
4.17231
4.17054
4.16314
4.14571
4.11136
4.0723
4.02973
3.98681
3.94392
3.90086
3.85676
3.81172
3.76526
3.71818
3.6701
3.62189
3.57326
3.52478
3.47609
3.42777
3.37945
3.33166
3.28401
3.23699
3.1902
3.14411
3.09834
3.05331
3.00868
2.96483
2.92142
2.8788
2.83667
2.79531
2.75447
2.7144
2.67487
2.63614
2.59798
2.56089
2.52464
2.49137
2.46176
5.79761
5.25186
4.71699
4.21579
3.76182
3.36069
3.01199
2.71252
2.45693
2.24013
2.05658
1.90191
1.77193
1.66361
1.57428
1.50164
1.44515
1.40175
1.37075
1.35342
1.34462
1.3448
1.34617
1.34976
1.35708
1.36503
1.37167
1.376
1.37849
1.38193
1.38946
1.405
1.4405
1.51464
1.67418
1.99768
2.64668
3.19814
3.52359
3.91903
4.43817
5.01552
5.34966
5.32931
5.24003
5.04683
4.79028
4.5726
4.36255
4.2116
4.11013
4.04677
4.02097
4.00421
4.00609
4.01509
4.03521
4.06184
4.07681
4.07764
4.07431
4.06328
4.0393
4.00065
3.9584
3.91472
3.87107
3.82727
3.78343
3.73876
3.69355
3.6473
3.6006
3.55317
3.50567
3.45783
3.41028
3.36269
3.31561
3.26867
3.22233
3.17623
3.13078
3.08564
3.0412
2.99714
2.95382
2.91093
2.86881
2.82714
2.78625
2.74582
2.70618
2.667
2.62866
2.59077
2.55399
2.51787
2.48478
2.45492
5.83726
5.34166
4.8508
4.38341
3.95186
3.56271
3.21751
2.91516
2.65225
2.42515
2.22944
2.06149
1.91747
1.7946
1.69011
1.60201
1.52881
1.46887
1.42185
1.38614
1.36122
1.34713
1.34064
1.34087
1.34221
1.34551
1.35219
1.36006
1.36867
1.3783
1.39406
1.42572
1.49288
1.63059
1.91491
2.48822
3.07947
3.33901
3.45772
3.59965
3.8128
4.11355
4.53423
4.86128
5.02014
4.99989
4.92293
4.75384
4.56623
4.40206
4.24035
4.11597
4.03341
3.97933
3.95429
3.93517
3.9368
3.94339
3.95718
3.97561
3.983
3.98147
3.97511
3.95934
3.92752
3.88686
3.84245
3.79773
3.75394
3.71019
3.66634
3.62171
3.57662
3.53066
3.48444
3.4377
3.39112
3.34441
3.29815
3.25199
3.2064
3.16103
3.11629
3.07183
3.02804
2.98458
2.94186
2.89951
2.85794
2.81675
2.77636
2.73637
2.69719
2.6584
2.62046
2.58291
2.54647
2.51055
2.47769
2.44767
5.8702
5.41431
4.96142
4.5255
4.11683
3.74215
3.40388
3.10255
2.83613
2.60235
2.39774
2.21949
2.06425
1.92958
1.81291
1.71234
1.62619
1.55316
1.49223
1.44238
1.40333
1.37371
1.35331
1.34152
1.33797
1.33869
1.34135
1.34742
1.35977
1.37844
1.40848
1.4694
1.59259
1.84482
2.35284
3.00776
3.30903
3.40161
3.43287
3.4704
3.53315
3.64159
3.81473
4.0496
4.37004
4.61609
4.74554
4.73004
4.67251
4.54572
4.39085
4.26001
4.13441
4.0242
3.95003
3.90414
3.87684
3.85749
3.85864
3.86333
3.873
3.88554
3.88531
3.88232
3.87298
3.852
3.8133
3.77023
3.72589
3.68152
3.63771
3.59376
3.54982
3.50521
3.46042
3.41506
3.36977
3.32422
3.279
3.23379
3.18907
3.14451
3.10052
3.05677
3.01367
2.97086
2.92876
2.88701
2.846
2.80537
2.76551
2.72602
2.68732
2.64898
2.61146
2.57429
2.53821
2.50254
2.46995
2.43978
5.89537
5.47315
5.05496
4.64879
4.26265
3.90343
3.5743
3.27654
3.00951
2.7717
2.56087
2.3746
2.21049
2.06607
1.93938
1.82832
1.7315
1.64732
1.57493
1.51311
1.46157
1.41936
1.38631
1.36207
1.34496
1.34078
1.34216
1.34684
1.35969
1.38442
1.43853
1.5446
1.76505
2.20549
2.8815
3.27984
3.40112
3.42084
3.42005
3.41534
3.40706
3.41544
3.44975
3.53006
3.68784
3.9036
4.18187
4.38892
4.51059
4.49984
4.45997
4.37534
4.23903
4.12907
4.02778
3.92981
3.86357
3.82251
3.79421
3.7741
3.77506
3.77859
3.78485
3.78925
3.7878
3.78197
3.76772
3.73837
3.69851
3.6544
3.61016
3.56592
3.52211
3.47813
3.43439
3.39037
3.34649
3.30235
3.25837
3.2143
3.17056
3.1269
3.08371
3.04074
2.99834
2.95623
2.91477
2.87365
2.83323
2.79318
2.75385
2.71489
2.67668
2.63882
2.60174
2.56499
2.5293
2.49392
2.46166
2.43137
5.92496
5.53097
5.14071
4.75901
4.39346
4.04914
3.72978
3.43704
3.17121
2.9315
2.71652
2.5244
2.35326
2.20107
2.06604
1.94635
1.84062
1.74725
1.66548
1.59393
1.5322
1.47953
1.43546
1.40021
1.373
1.35818
1.35947
1.36502
1.38408
1.42084
1.51008
1.68517
2.04895
2.71362
3.20934
3.3918
3.42422
3.42193
3.40986
3.38005
3.32384
3.27793
3.27714
3.2879
3.3244
3.40568
3.55952
3.75129
3.98204
4.16349
4.29077
4.29024
4.27038
4.21679
4.10836
4.00613
3.91688
3.83812
3.77593
3.73471
3.70718
3.68861
3.68787
3.6892
3.69233
3.69182
3.68867
3.67952
3.65961
3.6227
3.58127
3.5376
3.49362
3.44964
3.40637
3.36335
3.32074
3.27808
3.23553
3.19287
3.15035
3.10783
3.06561
3.02353
2.9819
2.94054
2.89974
2.85929
2.81947
2.78003
2.74127
2.70287
2.66518
2.62782
2.59123
2.5549
2.51967
2.48458
2.4527
2.42234
5.96346
5.58946
5.2218
4.86087
4.51281
4.18236
3.87232
3.58524
3.32164
3.0816
2.86397
2.66786
2.49125
2.33303
2.19119
2.06437
1.95127
1.85021
1.76066
1.68098
1.61095
1.54965
1.4964
1.45247
1.41568
1.39558
1.39757
1.4079
1.43406
1.50366
1.64231
1.94232
2.53697
3.09975
3.36239
3.42313
3.42205
3.41144
3.38215
3.32225
3.25921
3.20644
3.16872
3.14619
3.14947
3.16363
3.20014
3.27545
3.40708
3.57289
3.76817
3.94257
4.06967
4.10687
4.09591
4.06177
3.98669
3.89063
3.81231
3.74369
3.68456
3.64453
3.61734
3.60005
3.5965
3.59689
3.59675
3.59503
3.58896
3.57414
3.54392
3.50515
3.46339
3.42036
3.37762
3.33526
3.29351
3.252
3.21076
3.1695
3.12835
3.08713
3.04607
3.00504
2.96434
2.92381
2.88377
2.844
2.80484
2.766
2.72784
2.68998
2.65285
2.61599
2.57993
2.54402
2.50928
2.4745
2.44305
2.41266
6.0219
5.65393
5.30096
4.95754
4.62374
4.30415
4.00281
3.72146
3.46094
3.22185
3.00297
2.80434
2.62391
2.46094
2.31389
2.18112
2.06201
1.95442
1.85835
1.77183
1.69482
1.62651
1.5656
1.51584
1.47078
1.45643
1.46056
1.48062
1.52429
1.64916
1.88655
2.40025
3.00608
3.33244
3.42765
3.42666
3.41575
3.38554
3.3235
3.25771
3.20119
3.15189
3.1082
3.07008
3.04201
3.02214
3.02488
3.03665
3.066
3.12677
3.23719
3.38251
3.55187
3.72383
3.8508
3.93548
3.93023
3.91095
3.8719
3.79461
3.71349
3.64564
3.59248
3.55239
3.52337
3.50879
3.50663
3.50628
3.50467
3.49963
3.48763
3.46254
3.42873
3.3901
3.34936
3.30782
3.26647
3.22539
3.18482
3.14451
3.10453
3.06457
3.02482
2.98499
2.94543
2.90586
2.86673
2.82771
2.78929
2.75106
2.71352
2.67621
2.63966
2.60329
2.56776
2.53231
2.49807
2.46365
2.43264
2.40226
6.1063
5.72369
5.37716
5.04495
4.72371
4.41537
4.12201
3.84683
3.58969
3.35263
3.13378
2.93371
2.75098
2.58435
2.4334
2.2958
2.17173
2.05875
1.95707
1.86486
1.78191
1.70778
1.64137
1.587
1.5413
1.54207
1.55332
1.58415
1.68522
1.8787
2.31451
2.95974
3.33221
3.45601
3.45488
3.44244
3.40561
3.33109
3.25854
3.19814
3.14775
3.1014
3.0578
3.01629
2.97729
2.94243
2.91564
2.89391
2.89564
2.90355
2.92492
2.97099
3.06288
3.1883
3.34092
3.50435
3.64675
3.74901
3.78678
3.77874
3.75232
3.69418
3.61927
3.55099
3.4956
3.45332
3.42781
3.4171
3.41348
3.41147
3.40714
3.39764
3.37872
3.35042
3.31639
3.27872
3.23935
3.19916
3.1591
3.11922
3.07991
3.04079
3.00211
2.9634
2.92502
2.88654
2.84845
2.81032
2.77273
2.7352
2.69835
2.66161
2.62564
2.58978
2.55479
2.51981
2.48607
2.45202
2.42147
2.39114
6.19149
5.79932
5.45031
5.12561
4.81421
4.51609
4.23134
3.96254
3.70973
3.47484
3.2574
3.05662
2.87267
2.70351
2.54938
2.40817
2.27972
2.16245
2.05582
1.95888
1.87105
1.79192
1.72346
1.66427
1.6411
1.64716
1.67379
1.74723
1.92026
2.28225
2.95763
3.38006
3.52276
3.5207
3.50379
3.45485
3.36833
3.28996
3.2202
3.15892
3.10403
3.0549
3.01068
2.96756
2.92589
2.88603
2.84821
2.81465
2.78706
2.76533
2.76202
2.7668
2.78268
2.81804
2.89103
2.99866
3.13554
3.29057
3.44704
3.565
3.64809
3.6458
3.63161
3.60053
3.53693
3.4651
3.40713
3.36491
3.33866
3.3247
3.3176
3.31273
3.30545
3.29079
3.26882
3.24027
3.20714
3.17077
3.13283
3.09402
3.05532
3.01668
2.97862
2.94068
2.90324
2.86575
2.8287
2.79154
2.7549
2.71819
2.68211
2.64604
2.6107
2.57541
2.54096
2.50649
2.47327
2.43962
2.40956
2.37931
6.31797
5.89296
5.52641
5.20173
4.89765
4.60822
4.33166
4.07006
3.82261
3.59043
3.37464
3.17431
2.9894
2.8189
2.66203
2.5181
2.38596
2.26503
2.1543
2.05334
1.9615
1.87995
1.80967
1.7621
1.76482
1.78461
1.84373
1.99892
2.31996
2.97827
3.468
3.63729
3.63418
3.61169
3.54927
3.4475
3.35377
3.27396
3.2039
3.14099
3.08232
3.02692
2.97472
2.92644
2.88195
2.83893
2.79746
2.75792
2.72067
2.68769
2.65891
2.63782
2.62777
2.63079
2.64203
2.6687
2.72533
2.81703
2.93825
3.08822
3.24706
3.38949
3.49461
3.53547
3.52619
3.49867
3.44139
3.37464
3.32302
3.28116
3.2521
3.23485
3.22406
3.21445
3.2024
3.18491
3.16195
3.13359
3.10147
3.06635
3.02985
2.99238
2.95501
2.91758
2.88074
2.84392
2.8077
2.77141
2.73569
2.69987
2.66465
2.62937
2.59474
2.56011
2.52628
2.49235
2.4597
2.42648
2.39694
2.3668
6.34674
5.98754
5.60775
5.27782
4.9768
4.69438
4.42531
4.16979
3.92856
3.70054
3.48666
3.28729
3.10198
2.93044
2.77171
2.62531
2.49039
2.36619
2.25217
2.14811
2.05339
1.97323
1.90439
1.89941
1.9132
1.95933
2.10763
2.39633
3.03012
3.59826
3.80246
3.79867
3.77123
3.69627
3.56423
3.447
3.35135
3.27065
3.19973
3.13565
3.074
3.01445
2.95678
2.9014
2.8496
2.80165
2.75615
2.7128
2.67147
2.63219
2.59557
2.56268
2.53348
2.5125
2.49665
2.49866
2.50671
2.52642
2.56678
2.64453
2.75369
2.89617
3.05576
3.21998
3.34535
3.42326
3.4158
3.39322
3.35038
3.2906
3.24096
3.19864
3.16777
3.1471
3.132
3.118
3.10234
3.08271
3.05904
3.03076
2.99952
2.96544
2.93021
2.89398
2.85788
2.82162
2.78597
2.75032
2.71532
2.6803
2.64591
2.61146
2.57765
2.54377
2.51065
2.47735
2.44532
2.41259
2.38361
2.35364
6.31294
6.1011
5.7074
5.36032
5.05772
4.77989
4.51591
4.2655
4.02873
3.80529
3.5943
3.39609
3.21101
3.0387
2.87865
2.73027
2.59301
2.46623
2.3497
2.24335
2.15019
2.07107
2.04335
2.05399
2.09722
2.22645
2.50709
3.10978
3.76779
4.01471
4.01034
3.97779
3.88855
3.73131
3.59016
3.47298
3.3743
3.28806
3.21045
3.13881
3.0724
3.01068
2.94933
2.88974
2.83182
2.77654
2.72516
2.67762
2.63235
2.58931
2.54852
2.50984
2.47404
2.44112
2.41237
2.3901
2.3718
2.37151
2.37563
2.38981
2.4207
2.48529
2.58398
2.71696
2.87754
3.05462
3.2036
3.30849
3.30476
3.28986
3.26058
3.20268
3.15536
3.11426
3.08322
3.06
3.04128
3.02365
3.00532
2.98378
2.95963
2.93119
2.90079
2.86762
2.83353
2.79852
2.76369
2.72867
2.69426
2.65988
2.62617
2.59249
2.55944
2.52637
2.49401
2.46145
2.43013
2.39799
2.36962
2.33991
6.22053
6.09895
5.82401
5.45852
5.14248
4.86278
4.6045
4.35926
4.12563
3.90487
3.697
3.50078
3.31623
3.14381
2.98276
2.83305
2.69396
2.56541
2.44724
2.34223
2.25174
2.20411
2.21152
2.25014
2.36111
2.63332
3.2046
3.96331
4.26481
4.26064
4.224
4.12029
3.93858
3.77469
3.6379
3.52102
3.41789
3.32444
3.23852
3.15851
3.08375
3.01328
2.94743
2.88577
2.82378
2.76416
2.70691
2.65296
2.60276
2.55582
2.5114
2.46922
2.42923
2.39147
2.35647
2.324
2.29593
2.27219
2.25437
2.24832
2.2513
2.26203
2.28657
2.33889
2.42744
2.55019
2.71205
2.89952
3.07345
3.19169
3.20136
3.19094
3.16493
3.11292
3.06841
3.03023
2.99884
2.97304
2.95132
2.93073
2.91042
2.88739
2.86286
2.83454
2.80474
2.7726
2.73972
2.70603
2.67253
2.63888
2.60578
2.57276
2.54037
2.50804
2.47641
2.44461
2.41405
2.38258
2.3549
2.32558
6.11635
6.06168
5.89568
5.56041
5.23392
4.94868
4.69078
4.44926
4.22006
4.00184
3.79564
3.60149
3.41826
3.24588
3.08446
2.93359
2.79354
2.66388
2.54727
2.44611
2.37939
2.38404
2.41707
2.51838
2.78005
3.33033
4.19196
4.55036
4.54641
4.50545
4.38563
4.17915
3.99272
3.83628
3.70205
3.58246
3.47344
3.37237
3.27814
3.18973
3.10673
3.02856
2.95518
2.88568
2.82131
2.75924
2.69844
2.6399
2.58404
2.53191
2.48349
2.43759
2.39418
2.35313
2.31425
2.27769
2.24357
2.21198
2.18443
2.16001
2.14275
2.13226
2.1343
2.14256
2.1621
2.20531
2.28347
2.39809
2.56165
2.7591
2.95278
3.07597
3.10174
3.09316
3.06955
3.02348
2.98248
2.94601
2.91376
2.88569
2.86178
2.83911
2.81741
2.79351
2.76864
2.74084
2.7116
2.68064
2.64906
2.61681
2.58469
2.55247
2.52074
2.48908
2.45813
2.42703
2.3972
2.36643
2.33945
2.31064
5.9155
5.95649
5.88158
5.68752
5.34703
5.0445
4.78
4.53844
4.31212
4.09688
3.89207
3.69894
3.51717
3.3456
3.18404
3.03285
2.89254
2.764
2.65395
2.56756
2.56953
2.59647
2.69055
2.93121
3.44842
4.42379
4.85836
4.85522
4.81126
4.67997
4.44753
4.23765
4.06192
3.9106
3.77542
3.65127
3.53585
3.42743
3.32556
3.2294
3.13886
3.05342
2.97292
2.897
2.82559
2.75834
2.69566
2.63421
2.57502
2.51825
2.46447
2.41431
2.36749
2.32324
2.28133
2.24166
2.20409
2.16884
2.13574
2.10528
2.07816
2.05387
2.03678
2.02327
2.02475
2.03113
2.04733
2.083
2.15212
2.26261
2.42668
2.63092
2.84498
2.96622
3.0036
2.99595
2.97497
2.93411
2.89656
2.86078
2.82775
2.79838
2.77319
2.74932
2.72662
2.70251
2.67733
2.6502
2.62181
2.59213
2.56188
2.5311
2.5004
2.4696
2.43936
2.40895
2.37981
2.34973
2.32343
2.2952
5.42831
5.83986
5.82015
5.71281
5.47263
5.15422
4.87551
4.62922
4.40287
4.19019
3.98862
3.79642
3.61414
3.44281
3.28179
3.13118
2.99217
2.87203
2.77148
2.76574
2.78966
2.87958
3.11835
3.63335
4.66537
5.17642
5.18784
5.14312
4.99909
4.74005
4.50645
4.31098
4.14282
3.99207
3.85338
3.72368
3.60174
3.48643
3.3776
3.27453
3.17728
3.08527
2.99845
2.91643
2.83901
2.76606
2.69715
2.63267
2.57174
2.51198
2.45471
2.40009
2.34898
2.30122
2.2561
2.21343
2.17305
2.13488
2.09879
2.06491
2.03304
2.00379
1.97725
1.95366
1.93643
1.92138
1.92229
1.92737
1.94064
1.97158
2.03436
2.14388
2.30493
2.51259
2.74373
2.85985
2.90457
2.89835
2.8808
2.8463
2.81049
2.77511
2.74201
2.71234
2.68639
2.6621
2.63856
2.61444
2.58943
2.56307
2.5357
2.5073
2.47844
2.44907
2.41993
2.39042
2.36206
2.33269
2.30706
2.27942
4.37129
5.56484
5.7353
5.6891
5.55307
5.27186
4.97916
4.72445
4.49564
4.28302
4.08217
3.89156
3.7107
3.53953
3.37908
3.23011
3.09944
2.98979
2.97023
2.99326
3.08307
3.3253
3.86
4.94369
5.53037
5.55636
5.50618
5.34421
5.05655
4.79758
4.58165
4.3961
4.22987
4.07648
3.93286
3.79722
3.66896
3.54729
3.43219
3.323
3.21981
3.12198
3.02953
2.94199
2.85923
2.781
2.70705
2.63739
2.57146
2.50996
2.45058
2.39331
2.33847
2.28649
2.23804
2.19236
2.14919
2.10835
2.06972
2.03317
1.99863
1.96617
1.93558
1.90753
1.88174
1.85903
1.84161
1.82658
1.82639
1.82988
1.84227
1.87006
1.92902
2.03997
2.20296
2.40703
2.64741
2.75853
2.80737
2.80273
2.78848
2.75946
2.7249
2.69041
2.65776
2.62827
2.60205
2.57754
2.55382
2.52987
2.50535
2.47984
2.4536
2.42644
2.39911
2.37101
2.3438
2.31535
2.29049
2.26354
2.75711
4.93543
5.57603
5.61587
5.55086
5.39074
5.10064
4.83072
4.59234
4.37667
4.17543
3.98546
3.80539
3.63559
3.4771
3.33671
3.2186
3.18686
3.20906
3.29996
3.54826
4.10916
5.25008
5.91709
5.95923
5.90227
5.71799
5.39822
5.11159
4.87352
4.66983
4.48748
4.31921
4.16126
4.01199
3.87038
3.73611
3.60861
3.48785
3.37321
3.26473
3.16175
3.0643
2.97184
2.88432
2.80138
2.72288
2.64862
2.57841
2.51211
2.44962
2.39094
2.3336
2.27876
2.22657
2.17767
2.13167
2.08817
2.047
2.00803
1.97117
1.93629
1.90334
1.87237
1.84316
1.81638
1.79158
1.76975
1.75261
1.7378
1.73698
1.74027
1.75177
1.77891
1.83674
1.9488
2.1117
2.32256
2.55822
2.66336
2.71425
2.71092
2.69886
2.67408
2.64086
2.60747
2.57568
2.5467
2.52065
2.49626
2.47275
2.44922
2.42544
2.40083
2.37589
2.34986
2.32439
2.29736
2.27358
2.24762
2.10177
3.51921
5.14086
5.50898
5.50174
5.42278
5.23812
4.9531
4.69881
4.47429
4.26974
4.07798
3.89928
3.73187
3.58211
3.45577
3.41468
3.43646
3.52893
3.78458
4.36484
5.55254
6.32147
6.38233
6.31915
6.11513
5.76294
5.44768
5.1866
4.96368
4.76455
4.58065
4.40799
4.24448
4.08935
3.94193
3.80206
3.66921
3.54335
3.42381
3.31063
3.20308
3.10121
3.0044
2.91264
2.82551
2.74292
2.66459
2.59041
2.52015
2.4538
2.39089
2.33201
2.27542
2.22089
2.16882
2.11988
2.07375
2.03008
1.98873
1.94959
1.91253
1.87746
1.8443
1.81295
1.78352
1.75573
1.73024
1.70661
1.68565
1.66925
1.6549
1.65411
1.65742
1.66861
1.69649
1.75424
1.86757
2.02608
2.24762
2.47683
2.5737
2.62494
2.62268
2.61256
2.59077
2.55915
2.52706
2.49644
2.46829
2.44281
2.41884
2.39588
2.37291
2.35012
2.32638
2.30307
2.27804
2.25576
2.2314
1.62565
2.32861
4.18652
5.23857
5.42205
5.3954
5.2959
5.08042
4.81114
4.57365
4.36304
4.172
3.9945
3.8359
3.70128
3.65241
3.67444
3.77068
4.03891
4.65222
5.91733
6.76007
6.83019
6.75932
6.53348
6.14773
5.80358
5.519
5.27652
5.05993
4.85998
4.67193
4.49384
4.32455
4.16375
4.01091
3.86592
3.72824
3.59777
3.47384
3.35642
3.24476
3.13891
3.03819
2.94266
2.85177
2.76554
2.68362
2.6059
2.53219
2.46235
2.3962
2.33361
2.27459
2.21862
2.16454
2.11284
2.06408
2.01801
1.97436
1.933
1.89384
1.85676
1.82167
1.78846
1.75708
1.7274
1.69958
1.67327
1.64908
1.62678
1.60667
1.59136
1.57752
1.57762
1.58114
1.59246
1.62176
1.68217
1.79912
1.95393
2.17769
2.40083
2.48974
2.53968
2.53852
2.53023
2.51077
2.48084
2.45021
2.42094
2.39379
2.36916
2.34579
2.32366
2.30134
2.27992
2.25696
2.23655
2.21439
1.27929
1.73785
2.62672
4.60688
5.25094
5.3319
5.2874
5.16998
4.92993
4.68128
4.46295
4.26931
4.09932
3.95755
3.90019
3.92284
4.02428
4.30856
4.96196
6.31357
7.24673
7.314
7.23073
6.9756
6.55389
6.17931
5.87061
5.60794
5.37346
5.15667
4.95272
4.75922
4.57534
4.40042
4.2343
4.07649
3.92684
3.78479
3.65014
3.52227
3.40099
3.28567
3.17622
3.07202
2.97308
2.87886
2.78939
2.70427
2.62344
2.54667
2.4738
2.40469
2.33914
2.2771
2.21828
2.16298
2.10944
2.05828
2.01
1.96423
1.92082
1.87968
1.84068
1.80374
1.76875
1.73564
1.7043
1.67472
1.64672
1.62048
1.59572
1.57279
1.552
1.53268
1.51876
1.50577
1.5065
1.51153
1.52219
1.55594
1.6161
1.73824
1.90208
2.12104
2.33021
2.41298
2.45995
2.45952
2.45228
2.43453
2.40645
2.37751
2.34985
2.32386
2.30029
2.27761
2.25671
2.2351
2.21624
2.19631
1.17391
1.36804
1.96764
3.19671
4.79326
5.20827
5.23417
5.17936
5.04649
4.80255
4.57526
4.3819
4.22294
4.15808
4.18188
4.29041
4.59704
5.30415
6.77008
7.78159
7.83125
7.7309
7.44162
6.98291
6.57734
6.2436
5.95984
5.70619
5.47151
5.25034
5.04059
4.84106
4.65149
4.47127
4.30031
4.138
3.98416
3.83815
3.69973
3.56824
3.44348
3.32482
3.21211
3.10477
3.00278
2.9056
2.81325
2.72532
2.64177
2.5623
2.48682
2.41511
2.34703
2.2824
2.22114
2.16295
2.10823
2.05546
2.00502
1.95738
1.91213
1.86918
1.82842
1.78976
1.75312
1.7184
1.68553
1.65442
1.62498
1.5972
1.57089
1.54621
1.52304
1.50132
1.48205
1.46374
1.45095
1.44003
1.44105
1.44623
1.46037
1.49335
1.55999
1.68301
1.85327
2.07269
2.26492
2.34142
2.38514
2.38585
2.37959
2.36292
2.33684
2.30971
2.28378
2.259
2.23685
2.21515
2.19643
2.17805
1.08124
1.22115
1.48524
2.21385
3.74711
4.87782
5.14112
5.13607
5.0764
4.93472
4.7076
4.51315
4.42719
4.45179
4.56911
4.90178
5.67255
7.26898
8.34085
8.36911
8.24946
7.92596
7.43322
6.99693
6.63847
6.33344
6.06008
5.80621
5.56656
5.33888
5.12256
4.91695
4.72191
4.53677
4.36138
4.19497
4.03732
3.8877
3.74585
3.61106
3.48315
3.36146
3.24582
3.13567
3.03095
2.93114
2.83625
2.74584
2.65992
2.57811
2.50037
2.42641
2.35613
2.28932
2.22585
2.16561
2.10835
2.05442
2.00247
1.95306
1.90617
1.86161
1.81928
1.77908
1.74095
1.70476
1.67048
1.63798
1.6072
1.57808
1.55049
1.52445
1.49985
1.47664
1.45511
1.4346
1.41685
1.39988
1.38792
1.37987
1.3811
1.3876
1.40249
1.4397
1.51178
1.6438
1.81698
2.03074
2.20538
2.27703
2.31657
2.31791
2.31214
2.29686
2.27274
2.24755
2.22361
2.20032
2.18067
2.16195
1.04141
1.11581
1.2358
1.63994
2.38297
4.13999
4.91737
5.07116
5.05692
4.99522
4.85514
4.72166
4.7434
4.86738
5.22769
6.07851
7.8326
8.96485
8.95104
8.79398
8.41239
7.89568
7.4358
7.05492
6.729
6.43536
6.16144
5.90186
5.65498
5.42019
5.19743
4.98618
4.78618
4.59664
4.41724
4.24712
4.086
3.93306
3.78806
3.6503
3.5195
3.39504
3.27676
3.16408
3.05692
2.9548
2.85768
2.76512
2.67712
2.59329
2.51359
2.4377
2.36553
2.29687
2.23158
2.16949
2.1105
2.05441
2.00144
1.95053
1.9022
1.85624
1.81255
1.77102
1.73158
1.69411
1.65856
1.62482
1.59283
1.5625
1.53376
1.50656
1.4808
1.45645
1.43356
1.41181
1.39187
1.37281
1.35628
1.34135
1.32968
1.32528
1.32694
1.33454
1.3516
1.39275
1.46991
1.60763
1.78778
1.99702
2.15201
2.2189
2.25454
2.25656
2.25122
2.23715
2.2151
2.19207
2.17157
2.15129
1.02508
1.04974
1.13845
1.28672
1.73853
2.60407
4.36338
4.91679
5.02651
5.02265
5.00891
5.03349
5.17478
5.57973
6.53735
8.4814
9.59831
9.56739
9.36628
8.91404
8.37097
7.89191
7.49078
7.14456
6.83029
6.5354
6.25498
5.98768
5.73349
5.4923
5.26401
5.04794
4.84366
4.65025
4.46728
4.29385
4.12958
3.97368
3.82585
3.68535
3.55194
3.42498
3.3043
3.18936
3.08007
2.97594
2.87691
2.78254
2.69279
2.60727
2.52592
2.44839
2.37466
2.30444
2.23764
2.17403
2.11355
2.05598
2.00133
1.94935
1.89981
1.85265
1.80779
1.7651
1.72452
1.68593
1.64927
1.61444
1.58137
1.54997
1.52018
1.49195
1.46519
1.43983
1.41591
1.39322
1.37203
1.3519
1.33339
1.31618
1.30053
1.28812
1.27707
1.2761
1.27827
1.28808
1.30698
1.35396
1.43978
1.58277
1.7663
1.96896
2.10604
2.16861
2.20021
2.20259
2.19772
2.18497
2.16623
2.14697
1.01147
1.03104
1.06362
1.17129
1.37177
1.93319
3.10949
4.49046
4.92728
5.05556
5.16444
5.41609
5.95329
7.09783
9.31006
10.3349
10.2698
10.0021
9.44078
8.866
8.37328
7.95734
7.59082
7.25322
6.93405
6.62964
6.33954
6.06392
5.80295
5.55621
5.32324
5.1031
4.89513
4.69831
4.51214
4.33567
4.16851
4.00988
3.85943
3.71647
3.58065
3.45143
3.32857
3.21162
3.10038
2.99443
2.89366
2.79766
2.70637
2.61939
2.53668
2.45788
2.38288
2.31139
2.24334
2.17851
2.11678
2.05803
2.00208
1.94901
1.89837
1.85016
1.80429
1.76066
1.71912
1.67963
1.64205
1.60632
1.57234
1.54005
1.50936
1.48021
1.45256
1.42632
1.40152
1.37801
1.3559
1.33497
1.31539
1.29708
1.27989
1.26469
1.25019
1.23987
1.23113
1.23192
1.23536
1.24836
1.27042
1.32463
1.41783
1.56327
1.75208
1.94803
2.06785
2.12669
2.15409
2.15807
2.15423
2.14489
1.00704
1.01421
1.03835
1.07945
1.21155
1.4595
2.12377
3.48865
4.62657
5.04142
5.43124
6.20914
7.73421
10.2513
11.147
11.0406
10.6962
10.0016
9.37208
8.86357
8.43742
8.05541
7.69581
7.35116
7.02084
6.70588
6.40718
6.1249
5.85873
5.60774
5.3711
5.14764
4.93663
4.73699
4.54814
4.36917
4.19963
4.03873
3.88611
3.7411
3.60343
3.47253
3.34808
3.22961
3.11687
3.00956
2.90745
2.81024
2.71775
2.62966
2.54583
2.46594
2.38989
2.31739
2.24835
2.18253
2.11985
2.06012
2.00325
1.94913
1.8976
1.84851
1.80182
1.75737
1.71507
1.6748
1.63646
1.59997
1.56523
1.53218
1.50074
1.47086
1.44248
1.41556
1.39004
1.36585
1.343
1.32141
1.30109
1.28204
1.26408
1.24764
1.23203
1.21848
1.20619
1.19666
1.19251
1.19365
1.19961
1.21129
1.2433
1.30238
1.40721
1.55415
1.74577
1.93622
2.03756
2.09619
2.11799
2.13314
1.00319
1.00857
1.01723
1.04661
1.09612
1.25568
1.55411
2.32869
3.90231
4.97287
6.03382
8.15309
11.3332
12.1261
11.9604
11.4773
10.6059
9.91427
9.38099
8.94341
8.54601
8.16453
7.79385
7.4362
7.09475
6.77131
6.46636
6.17927
5.90911
5.65459
5.41469
5.18817
4.97427
4.77191
4.58051
4.39915
4.22736
4.06437
3.90976
3.76292
3.62342
3.49082
3.36473
3.24482
3.13074
3.02222
2.91896
2.8207
2.72719
2.63815
2.55339
2.47261
2.39569
2.32234
2.25249
2.18586
2.12242
2.06191
2.00432
1.94939
1.89713
1.84734
1.8
1.75493
1.71204
1.67118
1.63227
1.5952
1.55989
1.52627
1.49425
1.46379
1.43483
1.40731
1.38119
1.35643
1.33301
1.31087
1.28999
1.27039
1.25191
1.23476
1.21864
1.20386
1.1904
1.17808
1.16868
1.16027
1.16046
1.16257
1.16952
1.18599
1.22163
1.29162
1.40444
1.55794
1.74331
1.93642
2.01534
2.09506
1.00176
1.00469
1.00946
1.02535
1.05161
1.13824
1.29281
1.75163
2.64757
4.72412
7.57921
12.3283
13.1164
12.8491
12.1597
11.244
10.5411
9.9908
9.52609
9.08653
8.66398
8.25703
7.86729
7.49673
7.1466
6.817
6.50728
6.21622
5.94257
5.68489
5.44216
5.21314
4.99701
4.79269
4.59951
4.41658
4.24332
4.07901
3.92315
3.7752
3.63467
3.50118
3.37425
3.25364
3.13888
3.02978
2.92594
2.82716
2.73311
2.64356
2.55827
2.47698
2.39952
2.32564
2.25525
2.18807
2.1241
2.06303
2.00491
1.94944
1.89671
1.84643
1.79858
1.75297
1.70955
1.66819
1.62881
1.59131
1.55557
1.52155
1.48914
1.45829
1.42893
1.40102
1.37451
1.34936
1.32553
1.303
1.28172
1.26171
1.24286
1.22526
1.20881
1.1935
1.17947
1.16642
1.15506
1.1448
1.13694
1.13314
1.13393
1.13756
1.14688
1.16807
1.21139
1.2983
1.3971
1.58881
1.74696
1.97887
1.00131
1.00265
1.0073
1.01445
1.04175
1.08009
1.24627
1.52225
2.50958
4.82885
10.7405
13.7819
13.5033
12.7624
11.9009
11.2197
10.6555
10.1536
9.66956
9.19617
8.7422
8.31461
7.91366
7.53745
7.18424
6.85237
6.54046
6.247
5.97091
5.71089
5.46597
5.23495
5.01699
4.81103
4.61634
4.43203
4.25749
4.09202
3.93507
3.78611
3.64463
3.51027
3.38252
3.26115
3.14568
3.03594
2.93148
2.83214
2.73756
2.64753
2.56177
2.48007
2.40224
2.32801
2.25729
2.18978
2.1255
2.06412
2.00569
1.94992
1.89686
1.84625
1.79806
1.75213
1.70838
1.66672
1.62701
1.58922
1.55318
1.51888
1.48617
1.45505
1.42541
1.39722
1.37043
1.345
1.32088
1.29807
1.27651
1.25622
1.23711
1.21922
1.20251
1.18695
1.17259
1.15931
1.14727
1.13642
1.12677
1.11939
1.11332
1.11369
1.11552
1.12142
1.13329
1.16161
1.2128
1.31751
1.44054
1.69932
1.00109
1.00223
1.00622
1.0124
1.03659
1.06838
1.22859
1.46061
2.523
4.97339
11.5944
13.0418
12.8241
12.3776
11.9089
11.411
10.8748
10.3179
9.7758
9.26649
8.79319
8.35344
7.94446
7.56313
7.2063
6.87149
6.55691
6.26111
5.98293
5.72113
5.4747
5.24244
5.02344
4.8166
4.62116
4.4362
4.26108
4.0951
3.9377
3.78836
3.64653
3.51188
3.38386
3.26227
3.14659
3.03668
2.93205
2.83257
2.73784
2.64768
2.56179
2.47996
2.40198
2.3276
2.25674
2.18909
2.12465
2.06312
2.00456
1.94864
1.89544
1.84469
1.79639
1.75035
1.70651
1.66476
1.62495
1.58708
1.55093
1.51656
1.48375
1.45257
1.42283
1.39457
1.3677
1.34217
1.31799
1.29507
1.27343
1.25303
1.23383
1.21586
1.19904
1.18339
1.16893
1.15553
1.1434
1.13221
1.12248
1.11355
1.10691
1.10117
1.10153
1.10324
1.1084
1.11828
1.14258
1.18753
1.27822
1.46947
3.06392
1.55572
1.04738
0.94249
0.968239
1.047
1.21278
1.34496
1.38604
1.3844
1.37913
1.37929
1.38125
1.38658
1.39739
1.40524
1.40782
1.40764
1.40702
1.40564
1.40382
1.40227
1.40089
1.3992
1.3971
1.39489
1.39411
1.39456
1.39658
1.40281
1.41917
1.45922
1.55343
1.77076
2.27355
3.29712
3.69942
3.67791
3.70169
3.72278
3.79123
3.90593
4.05279
4.19821
4.32303
4.41638
4.50332
4.55898
4.59376
4.612
4.61775
4.61518
4.60537
4.58427
4.55616
4.52457
4.4909
4.45442
4.41535
4.37373
4.32966
4.28362
4.23575
4.18634
4.13581
4.08394
4.0316
3.97875
3.9256
3.87198
3.81857
3.76514
3.71177
3.65854
3.60548
3.55278
3.50036
3.44853
3.39716
3.3464
3.29627
3.24684
3.19802
3.1499
3.10236
3.05561
3.00944
2.96405
2.91927
2.87547
2.83225
2.7899
2.74816
2.70743
2.66752
2.62899
2.592
2.55784
2.52788
2.50681
3.71842
2.31611
1.71692
1.46598
1.34999
1.27844
1.26402
1.27193
1.29406
1.33967
1.38503
1.4038
1.40351
1.4022
1.4001
1.40043
1.40156
1.40405
1.4068
1.40678
1.40646
1.40549
1.40342
1.40019
1.39707
1.39438
1.39272
1.39309
1.39489
1.40035
1.4142
1.44761
1.52647
1.71045
2.13809
3.09217
3.71962
3.70309
3.69901
3.72593
3.79477
3.89525
4.02265
4.16675
4.29373
4.39639
4.47929
4.53668
4.57355
4.59333
4.60062
4.59927
4.59311
4.57741
4.54871
4.5161
4.48255
4.44657
4.40834
4.36712
4.32367
4.2779
4.2305
4.18142
4.13122
4.07982
4.02775
3.97511
3.92219
3.86894
3.81565
3.76236
3.70911
3.65599
3.60304
3.55043
3.49812
3.44635
3.39505
3.34437
3.29425
3.24484
3.19606
3.14796
3.10052
3.0539
3.00805
2.96286
2.91838
2.87441
2.83125
2.78877
2.7472
2.70635
2.66656
2.6278
2.59073
2.55603
2.52546
2.50373
4.54542
3.24223
2.42437
1.90809
1.57868
1.37482
1.25762
1.24501
1.2524
1.27385
1.31851
1.36075
1.3879
1.40075
1.40314
1.40283
1.402
1.40143
1.40151
1.4015
1.4014
1.40106
1.40023
1.3985
1.39579
1.39289
1.39003
1.38991
1.39067
1.39385
1.40259
1.42603
1.47869
1.60932
1.89811
2.56385
3.61138
3.77475
3.79951
3.84108
3.90286
3.98071
4.06962
4.16962
4.26638
4.36225
4.4429
4.50225
4.54164
4.56324
4.57161
4.57086
4.56714
4.55684
4.53482
4.50236
4.46861
4.43321
4.3956
4.35524
4.31254
4.26752
4.22071
4.17228
4.12261
4.07188
4.02034
3.96822
3.9157
3.8629
3.80992
3.75689
3.70389
3.65098
3.59827
3.54581
3.49377
3.44212
3.39108
3.34057
3.2907
3.24145
3.193
3.14519
3.09818
3.0516
3.00576
2.96053
2.9161
2.87223
2.82923
2.78682
2.74535
2.70451
2.66476
2.62587
2.5886
2.55334
2.52197
2.49845
4.99809
3.82353
2.95369
2.34794
1.94206
1.66924
1.49828
1.39167
1.32999
1.31426
1.31767
1.32906
1.35327
1.38141
1.40082
1.41087
1.4108
1.41009
1.40834
1.40524
1.40331
1.40216
1.40128
1.40028
1.39852
1.39597
1.39276
1.39011
1.39042
1.39192
1.39798
1.41074
1.44901
1.52888
1.73309
2.18589
3.20626
3.79425
4.03498
4.12456
4.16767
4.19629
4.20546
4.21626
4.24326
4.2987
4.36831
4.43236
4.48391
4.51569
4.53036
4.53189
4.52985
4.52341
4.50881
4.48058
4.44754
4.41245
4.37553
4.3364
4.29501
4.25131
4.20563
4.15825
4.10951
4.05966
4.00897
3.95758
3.90573
3.85348
3.80104
3.74843
3.69586
3.64329
3.59097
3.53883
3.48716
3.43583
3.38508
3.33488
3.28549
3.2366
3.18841
3.14074
3.09385
3.04744
3.00182
2.95674
2.91252
2.86882
2.82602
2.7837
2.74237
2.70157
2.66187
2.6229
2.58545
2.54969
2.51737
2.49204
5.27096
4.2438
3.40834
2.77521
2.31291
1.97671
1.73297
1.55883
1.4372
1.36078
1.32043
1.32044
1.32386
1.33372
1.35409
1.37434
1.38908
1.39825
1.40087
1.40054
1.39948
1.39724
1.39456
1.39226
1.39029
1.38848
1.38709
1.38523
1.38537
1.38646
1.38896
1.39947
1.41798
1.47797
1.59388
1.88929
2.50741
3.68444
4.37384
4.59508
4.5903
4.54698
4.4379
4.30852
4.24881
4.25255
4.27379
4.32373
4.38798
4.43742
4.46832
4.48237
4.48216
4.47937
4.47108
4.45265
4.42188
4.38681
4.35011
4.31192
4.27193
4.22987
4.18583
4.13998
4.09259
4.04391
3.99427
3.9438
3.89276
3.84121
3.78941
3.73737
3.68534
3.63323
3.58143
3.52972
3.47852
3.42775
3.37767
3.32799
3.27901
3.23042
3.18253
3.13508
3.08843
3.04225
2.99691
2.95202
2.90806
2.86452
2.82195
2.7798
2.73866
2.69799
2.65841
2.61947
2.58193
2.54584
2.51296
2.48608
5.45694
4.56565
3.79002
3.16119
2.6702
2.29315
2.00588
1.78922
1.62705
1.5101
1.42543
1.37172
1.34284
1.34037
1.34279
1.35001
1.36509
1.38179
1.39464
1.40286
1.40425
1.40384
1.4026
1.3999
1.39592
1.39225
1.38918
1.38641
1.3852
1.38566
1.38738
1.39349
1.40699
1.44365
1.52383
1.7198
2.16312
3.18007
4.68701
5.20046
5.1451
4.9857
4.69408
4.45095
4.29465
4.22913
4.22121
4.22831
4.25394
4.30691
4.35728
4.39482
4.41427
4.41816
4.41576
4.4074
4.3885
4.35648
4.32014
4.28217
4.24291
4.2023
4.16021
4.11645
4.07102
4.02406
3.97588
3.92663
3.87663
3.82596
3.77496
3.72361
3.67225
3.6207
3.56953
3.51867
3.46828
3.41817
3.36863
3.31936
3.27075
3.22245
3.17491
3.12773
3.08142
3.03548
2.99047
2.94583
2.90216
2.85887
2.81656
2.77466
2.73374
2.69329
2.65384
2.61502
2.57746
2.54118
2.50797
2.47994
5.58462
4.8101
4.10287
3.49784
2.99978
2.59866
2.27955
2.02734
1.82855
1.67353
1.55326
1.46482
1.39991
1.36188
1.34196
1.34205
1.34413
1.34993
1.36187
1.3744
1.38372
1.39015
1.3907
1.39038
1.3894
1.38731
1.3842
1.38124
1.37965
1.38002
1.38162
1.38636
1.39808
1.42689
1.49253
1.64903
2.01107
2.86548
4.7289
5.84291
5.75854
5.506
5.07239
4.7067
4.4471
4.28691
4.20564
4.17945
4.17692
4.18554
4.21158
4.26225
4.3034
4.33324
4.34417
4.34279
4.3363
4.3204
4.2887
4.25206
4.21262
4.17229
4.13135
4.08934
4.04596
4.00105
3.95477
3.9071
3.8584
3.80878
3.75866
3.70808
3.65747
3.60692
3.55664
3.50649
3.45682
3.40725
3.35824
3.30939
3.26124
3.21332
3.16621
3.1194
3.07347
3.02787
2.9832
2.9389
2.89552
2.85257
2.81052
2.76893
2.72824
2.68806
2.64879
2.61016
2.57268
2.53633
2.50298
2.47417
5.6777
4.9957
4.35235
3.77991
3.28965
2.87959
2.54174
2.26558
2.04107
1.85971
1.71378
1.59808
1.50782
1.44057
1.39123
1.36296
1.3473
1.34738
1.34911
1.35398
1.36404
1.37527
1.38408
1.39068
1.39093
1.3904
1.38889
1.38577
1.38232
1.38248
1.3836
1.3892
1.39934
1.43144
1.49069
1.64489
1.955
2.6651
4.13882
5.90548
5.98421
5.84987
5.51929
5.11701
4.74797
4.48621
4.30457
4.19277
4.14259
4.1242
4.12493
4.13448
4.15986
4.20731
4.23852
4.25926
4.26016
4.25653
4.24479
4.21932
4.18251
4.14222
4.10102
4.05916
4.01677
3.97354
3.9293
3.88355
3.8366
3.7884
3.73937
3.68988
3.64043
3.59083
3.5415
3.49207
3.44308
3.39408
3.34567
3.29736
3.24974
3.20233
3.15571
3.10937
3.06387
3.01873
2.97443
2.93056
2.88754
2.84498
2.80325
2.76203
2.72162
2.68176
2.64273
2.60433
2.567
2.53067
2.49731
2.46801
5.74508
5.13907
4.55375
4.0171
3.54292
3.13408
2.78718
2.49591
2.2527
2.05079
1.88342
1.74564
1.633
1.54205
1.4706
1.41679
1.37791
1.35649
1.34565
1.34582
1.34734
1.35139
1.3596
1.36789
1.37381
1.37783
1.37974
1.3797
1.37974
1.3805
1.38276
1.39095
1.40781
1.45171
1.54134
1.74109
2.14147
2.94159
3.7029
4.69561
5.52063
5.67665
5.61654
5.43006
5.08887
4.80009
4.52433
4.32927
4.19608
4.11381
4.08125
4.06549
4.06733
4.07814
4.10372
4.14082
4.1625
4.17228
4.17053
4.16312
4.14563
4.11124
4.07218
4.02962
3.98672
3.94383
3.90078
3.85668
3.81165
3.76519
3.71811
3.67004
3.62184
3.57321
3.52473
3.47604
3.42773
3.37941
3.33163
3.28398
3.23696
3.19017
3.14408
3.09832
3.05329
3.00866
2.96481
2.9214
2.87878
2.83665
2.79529
2.75445
2.71438
2.67485
2.63612
2.59796
2.56087
2.52462
2.49135
2.46173
5.79763
5.25187
4.717
4.21581
3.76183
3.36071
3.012
2.71253
2.45694
2.24014
2.05659
1.90192
1.77194
1.66362
1.57429
1.50165
1.44515
1.40175
1.37075
1.35342
1.34462
1.3448
1.34617
1.34976
1.35708
1.36503
1.37167
1.37601
1.37849
1.38195
1.38946
1.40511
1.44051
1.51498
1.6745
1.99857
2.6481
3.19888
3.52426
3.91996
4.4396
5.01688
5.35033
5.32985
5.24017
5.04643
4.79004
4.5723
4.36221
4.21134
4.10998
4.04669
4.02092
4.00414
4.00604
4.01506
4.03524
4.06185
4.07673
4.07759
4.07424
4.06317
4.03919
4.00053
3.95828
3.91462
3.87098
3.82719
3.78336
3.73869
3.69349
3.64725
3.60055
3.55313
3.50563
3.4578
3.41025
3.36267
3.31558
3.26865
3.22231
3.17621
3.13076
3.08563
3.04119
2.99713
2.95381
2.91091
2.86879
2.82712
2.78623
2.7458
2.70616
2.66698
2.62864
2.59075
2.55397
2.51784
2.48476
2.4549
5.83728
5.34166
4.85081
4.38343
3.95187
3.56273
3.21752
2.91517
2.65226
2.42516
2.22945
2.0615
1.91748
1.79461
1.69012
1.60202
1.52882
1.46888
1.42186
1.38615
1.36122
1.34713
1.34064
1.34087
1.34221
1.34551
1.35219
1.36007
1.36868
1.37833
1.39408
1.42587
1.49296
1.63108
1.9156
2.48972
3.08022
3.33919
3.45782
3.59987
3.81338
4.11452
4.53554
4.86242
5.02052
5.00021
4.92305
4.75349
4.56602
4.40182
4.24001
4.1157
4.03317
3.97915
3.95414
3.9351
3.93678
3.94329
3.95719
3.97565
3.9829
3.98138
3.97503
3.95924
3.92743
3.88674
3.84234
3.79764
3.75386
3.71012
3.66628
3.62167
3.57658
3.53063
3.48442
3.43769
3.39111
3.34441
3.29814
3.25199
3.2064
3.16103
3.11629
3.07182
3.02803
2.98457
2.94185
2.8995
2.85792
2.81673
2.77634
2.73635
2.69717
2.65837
2.62044
2.58288
2.54644
2.51052
2.47767
2.44764
5.87021
5.41434
4.96143
4.52552
4.11685
3.74216
3.4039
3.10257
2.83615
2.60237
2.39775
2.2195
2.06426
1.9296
1.81292
1.71235
1.6262
1.55316
1.49224
1.44239
1.40334
1.37371
1.3533
1.34152
1.33797
1.3387
1.34136
1.34742
1.35979
1.37847
1.40855
1.46956
1.59288
1.84551
2.35422
3.00869
3.30921
3.40155
3.43274
3.47037
3.53332
3.64197
3.81533
4.05054
4.37118
4.61708
4.74581
4.73029
4.67262
4.54549
4.39062
4.25971
4.13405
4.02394
3.94983
3.90398
3.87671
3.85743
3.85861
3.86328
3.87305
3.88555
3.88531
3.8823
3.87292
3.85189
3.81319
3.77013
3.72581
3.68146
3.63766
3.59373
3.5498
3.5052
3.46041
3.41507
3.36977
3.32423
3.27901
3.2338
3.18907
3.14451
3.10052
3.05677
3.01367
2.97086
2.92876
2.88699
2.84599
2.80535
2.76549
2.726
2.68729
2.64895
2.61143
2.57426
2.53818
2.50251
2.46993
2.43975
5.89539
5.47315
5.05501
4.64881
4.26268
3.90345
3.57432
3.27656
3.00953
2.77171
2.56089
2.37462
2.21051
2.06608
1.93939
1.82833
1.73151
1.64732
1.57493
1.51311
1.46157
1.41936
1.38631
1.36207
1.34496
1.34079
1.34217
1.34685
1.35971
1.38446
1.43863
1.54482
1.76553
2.20651
2.88272
3.28017
3.40107
3.42071
3.41992
3.41523
3.40705
3.41552
3.44999
3.53054
3.68865
3.90459
4.18275
4.38964
4.5108
4.50003
4.46002
4.37499
4.2387
4.12875
4.02747
3.92955
3.86338
3.82239
3.79411
3.77407
3.77505
3.77862
3.78493
3.78927
3.7878
3.78197
3.76771
3.73832
3.69846
3.65435
3.61012
3.5659
3.5221
3.47813
3.43439
3.39038
3.3465
3.30236
3.25839
3.21432
3.17056
3.12691
3.08371
3.04074
2.99833
2.95622
2.91475
2.87363
2.83321
2.79315
2.75382
2.71486
2.67664
2.63879
2.60171
2.56496
2.52927
2.4939
2.46164
2.43135
5.92498
5.531
5.14072
4.75906
4.39348
4.04917
3.7298
3.43706
3.17123
2.93152
2.71654
2.52442
2.35327
2.20109
2.06605
1.94636
1.84063
1.74726
1.66548
1.59393
1.53221
1.47953
1.43546
1.40021
1.373
1.35818
1.35947
1.36503
1.3841
1.42087
1.5102
1.68542
2.04954
2.71478
3.20989
3.3918
3.42409
3.4218
3.40971
3.37989
3.32374
3.27792
3.27732
3.28812
3.32475
3.4062
3.56011
3.75206
3.98273
4.16397
4.29102
4.29027
4.27021
4.21658
4.108
4.00586
3.91666
3.83788
3.77577
3.73462
3.70712
3.68859
3.68794
3.68926
3.69238
3.69188
3.68872
3.67957
3.6596
3.62268
3.58125
3.53759
3.49361
3.44964
3.40638
3.36337
3.32075
3.27809
3.23554
3.19288
3.15035
3.10783
3.0656
3.02353
2.98189
2.94053
2.89973
2.85927
2.81945
2.78001
2.74124
2.70284
2.66515
2.62779
2.5912
2.55487
2.51964
2.48455
2.45267
2.42231
5.96348
5.5895
5.22183
4.86089
4.51285
4.18239
3.87236
3.58526
3.32167
3.08162
2.864
2.66788
2.49127
2.33304
2.19121
2.06439
1.95129
1.85022
1.76067
1.68099
1.61095
1.54965
1.4964
1.45247
1.41569
1.39557
1.39756
1.40787
1.4341
1.50356
1.6425
1.94255
2.53763
3.10067
3.36252
3.42302
3.42192
3.4113
3.38202
3.32213
3.25915
3.20644
3.16878
3.14636
3.14966
3.16384
3.20042
3.27592
3.40763
3.57355
3.76883
3.94305
4.07003
4.10694
4.09579
4.06165
3.98647
3.8904
3.81209
3.74354
3.68444
3.64446
3.61732
3.60009
3.59658
3.59697
3.59683
3.5951
3.58903
3.57418
3.54394
3.50515
3.46339
3.42037
3.37762
3.33526
3.29352
3.25201
3.21077
3.16951
3.12835
3.08712
3.04606
3.00503
2.96433
2.9238
2.88376
2.84398
2.80482
2.76597
2.72781
2.68995
2.65282
2.61595
2.57989
2.54399
2.50925
2.47447
2.44302
2.41264
6.02193
5.65397
5.301
4.95758
4.62378
4.30418
4.00284
3.72149
3.46095
3.22188
3.00298
2.80436
2.62392
2.46095
2.3139
2.18113
2.06202
1.95443
1.85836
1.77184
1.69482
1.62652
1.56561
1.51584
1.47078
1.45637
1.4605
1.48053
1.52421
1.64907
1.88653
2.40035
3.0068
3.33271
3.42764
3.42661
3.41563
3.38539
3.32338
3.25764
3.20117
3.1519
3.10825
3.07015
3.04211
3.02231
3.02506
3.03685
3.06629
3.12718
3.23772
3.3832
3.55261
3.72448
3.85129
3.93571
3.93038
3.91092
3.87168
3.79438
3.71333
3.64552
3.5924
3.55237
3.5234
3.50883
3.50673
3.50638
3.50476
3.4997
3.48767
3.46257
3.42875
3.39011
3.34936
3.30782
3.26647
3.22539
3.18483
3.14451
3.10453
3.06457
3.02481
2.98498
2.94542
2.90585
2.86671
2.82769
2.78926
2.75102
2.71349
2.67617
2.63962
2.60324
2.56772
2.53227
2.49804
2.46361
2.4326
2.40224
6.10633
5.72373
5.37719
5.04502
4.72375
4.41543
4.12205
3.84687
3.58973
3.35265
3.13381
2.93372
2.75101
2.58435
2.43343
2.29579
2.17175
2.05876
1.95707
1.86487
1.7819
1.70779
1.64136
1.58701
1.54123
1.54199
1.55319
1.58434
1.68491
1.87889
2.31432
2.96048
3.33272
3.45613
3.45496
3.44238
3.4054
3.33077
3.25836
3.19801
3.14767
3.10135
3.05777
3.01629
2.97732
2.94249
2.91573
2.89404
2.89578
2.90375
2.92517
2.97134
3.06335
3.18887
3.34158
3.50504
3.64727
3.74944
3.78683
3.77876
3.75229
3.6941
3.61912
3.55088
3.49556
3.45333
3.42784
3.41716
3.41356
3.41156
3.40722
3.39771
3.37875
3.35044
3.3164
3.27873
3.23936
3.19917
3.15911
3.11923
3.07991
3.04079
3.0021
2.96339
2.92501
2.88652
2.84843
2.8103
2.7727
2.73517
2.69831
2.66157
2.62559
2.58974
2.55474
2.51977
2.48603
2.45198
2.42144
2.39111
6.19149
5.79935
5.45036
5.12565
4.81424
4.51614
4.23137
3.96255
3.70976
3.47485
3.25742
3.05663
2.87268
2.70353
2.54937
2.40821
2.27969
2.16251
2.05579
1.95893
1.87102
1.79195
1.72343
1.66429
1.64081
1.64676
1.67473
1.74438
1.9234
2.28261
2.9586
3.38068
3.52311
3.52097
3.50391
3.45459
3.36807
3.2897
3.21995
3.15869
3.10382
3.05473
3.01055
2.96747
2.92583
2.886
2.84819
2.81464
2.78708
2.76535
2.76211
2.76692
2.78284
2.81825
2.8914
2.99917
3.1362
3.29129
3.44771
3.5655
3.64837
3.6459
3.63151
3.60047
3.53676
3.46499
3.40704
3.36486
3.33868
3.32475
3.31767
3.31281
3.30551
3.29084
3.26887
3.24031
3.20718
3.17079
3.13285
3.09403
3.05533
3.01669
2.97863
2.94067
2.90324
2.86573
2.82869
2.79152
2.75487
2.71816
2.68207
2.646
2.61065
2.57537
2.54092
2.50644
2.47323
2.43958
2.40953
2.37928
6.31796
5.89299
5.52644
5.20176
4.89771
4.60823
4.33171
4.07009
3.82262
3.59045
3.37465
3.17433
2.9894
2.81893
2.66201
2.51815
2.38592
2.26508
2.15427
2.05338
1.96148
1.87998
1.80966
1.76214
1.76487
1.78424
1.84504
1.99774
2.32137
2.97822
3.46868
3.63759
3.63443
3.61182
3.54924
3.4473
3.35353
3.27368
3.20361
3.14072
3.08206
3.02668
2.9745
2.92625
2.88179
2.83879
2.79734
2.75783
2.72059
2.68763
2.65888
2.63779
2.62783
2.63086
2.64216
2.66889
2.72571
2.81756
2.93889
3.08891
3.24776
3.38998
3.495
3.5355
3.52618
3.49862
3.44128
3.37447
3.32289
3.2811
3.2521
3.23489
3.22411
3.21452
3.20246
3.18497
3.162
3.13364
3.1015
3.06638
3.02987
2.9924
2.95502
2.91758
2.88073
2.84391
2.80768
2.77139
2.73566
2.69984
2.6646
2.62932
2.5947
2.56007
2.52624
2.49231
2.45966
2.42644
2.3969
2.36677
6.34676
5.98755
5.60779
5.27785
4.97685
4.69439
4.42534
4.16981
3.92858
3.70055
3.48666
3.2873
3.10197
2.93047
2.7717
2.62534
2.49038
2.36622
2.25217
2.14813
2.05339
1.97325
1.9044
1.89945
1.91325
1.95937
2.1077
2.39644
3.03019
3.59824
3.80246
3.79865
3.7712
3.69627
3.56418
3.44684
3.35113
3.27038
3.19943
3.13536
3.0737
3.01417
2.95652
2.90116
2.84938
2.80143
2.75596
2.71264
2.67134
2.63207
2.59547
2.5626
2.53342
2.51248
2.4967
2.49872
2.50683
2.52657
2.56715
2.64496
2.75423
2.8968
3.05642
3.22054
3.34581
3.42333
3.41586
3.39328
3.35019
3.29043
3.24086
3.19857
3.16774
3.1471
3.13202
3.11804
3.10238
3.08276
3.05907
3.03079
2.99954
2.96546
2.93022
2.89398
2.85788
2.8216
2.78595
2.75029
2.71529
2.68026
2.64587
2.61141
2.5776
2.54372
2.5106
2.4773
2.44528
2.41255
2.38357
2.35361
6.31297
6.1011
5.70748
5.36036
5.05773
4.77991
4.51589
4.26552
4.02873
3.80531
3.5943
3.3961
3.21101
3.03872
2.87864
2.73029
2.59301
2.46624
2.3497
2.24337
2.1502
2.07109
2.04342
2.05407
2.09722
2.22682
2.50722
3.11041
3.7681
4.01477
4.01037
3.97778
3.88849
3.73127
3.5901
3.47285
3.3741
3.28781
3.21016
3.13849
3.07209
3.01038
2.94905
2.88949
2.83159
2.77633
2.72496
2.67744
2.63218
2.58916
2.54839
2.50973
2.47394
2.44106
2.41232
2.3901
2.37181
2.37161
2.37575
2.38997
2.42096
2.48568
2.58449
2.7176
2.87823
3.05525
3.20407
3.30863
3.30483
3.28978
3.26038
3.20255
3.15527
3.11419
3.08318
3.05998
3.04127
3.02366
3.00532
2.98379
2.95962
2.93119
2.90078
2.8676
2.83351
2.79849
2.76365
2.72863
2.69422
2.65983
2.62612
2.59244
2.55939
2.52632
2.49396
2.46141
2.43008
2.39795
2.36958
2.33988
6.22059
6.09897
5.82398
5.45853
5.14245
4.8628
4.60449
4.35926
4.12562
3.90487
3.69701
3.50079
3.31624
3.14382
2.98276
2.83306
2.69397
2.56542
2.44725
2.34225
2.25177
2.20418
2.2116
2.25025
2.3613
2.63368
3.20527
3.96378
4.26498
4.26077
4.22406
4.12026
3.93853
3.77463
3.63783
3.52092
3.41774
3.32423
3.23826
3.15823
3.08345
3.01299
2.94715
2.88553
2.82356
2.76396
2.70674
2.65279
2.6026
2.55568
2.51128
2.46913
2.42915
2.39141
2.35643
2.32398
2.29592
2.27221
2.2544
2.24842
2.2514
2.26219
2.28676
2.33919
2.42785
2.55072
2.71262
2.90015
3.07388
3.19182
3.20128
3.19086
3.16481
3.11281
3.06831
3.03013
2.99877
2.973
2.9513
2.93071
2.9104
2.88737
2.86283
2.83451
2.8047
2.77256
2.73968
2.70598
2.67248
2.63882
2.60573
2.57271
2.54031
2.50799
2.47637
2.44457
2.41401
2.38254
2.35486
2.32555
6.11639
6.06172
5.89569
5.56038
5.23387
4.94869
4.69076
4.44927
4.22006
4.00184
3.79566
3.60149
3.41827
3.24589
3.08447
2.9336
2.79355
2.66389
2.54729
2.44613
2.37946
2.38413
2.41719
2.5186
2.78044
3.33108
4.19263
4.55062
4.54663
4.50559
4.38567
4.17916
3.99274
3.8363
3.70205
3.58242
3.47335
3.37223
3.27796
3.18952
3.10649
3.02831
2.95493
2.88544
2.82108
2.75907
2.69829
2.63978
2.58394
2.53182
2.48342
2.43754
2.39414
2.3531
2.31423
2.27768
2.24357
2.21199
2.18445
2.16005
2.14279
2.13236
2.13441
2.1427
2.16227
2.20561
2.28389
2.39864
2.56227
2.75983
2.95331
3.07619
3.1017
3.0931
3.06946
3.02336
2.98235
2.94588
2.91367
2.88562
2.86173
2.83907
2.81737
2.79347
2.76861
2.7408
2.71156
2.6806
2.64901
2.61676
2.58464
2.55242
2.52069
2.48903
2.45808
2.42698
2.39716
2.36639
2.33942
2.31061
5.9156
5.95652
5.88158
5.68752
5.34697
5.04451
4.77997
4.53844
4.31212
4.09687
3.89207
3.69895
3.51718
3.34561
3.18405
3.03286
2.89255
2.76402
2.65397
2.56765
2.56962
2.59661
2.69078
2.93163
3.44928
4.42461
4.85862
4.85544
4.81137
4.67994
4.44754
4.23768
4.06197
3.91065
3.77546
3.65128
3.53582
3.42737
3.32546
3.22928
3.13871
3.05326
2.97276
2.89685
2.82545
2.7582
2.69552
2.63411
2.57495
2.5182
2.46442
2.41427
2.36746
2.32322
2.28132
2.24167
2.20411
2.16885
2.13576
2.1053
2.0782
2.05392
2.03685
2.02337
2.02485
2.03128
2.04753
2.08331
2.15254
2.26315
2.42732
2.63164
2.84554
2.96646
3.0036
2.99593
2.9749
2.93397
2.89645
2.86068
2.82767
2.79832
2.77315
2.74929
2.72659
2.70248
2.6773
2.65017
2.62178
2.59209
2.56184
2.53105
2.50036
2.46955
2.43932
2.40891
2.37977
2.3497
2.3234
2.29517
5.42851
5.83991
5.82016
5.71281
5.47257
5.1542
4.87548
4.62921
4.40287
4.19019
3.98862
3.79641
3.61414
3.44282
3.2818
3.13119
2.99218
2.87206
2.77152
2.76588
2.78984
2.87981
3.11875
3.63401
4.66642
5.17686
5.1879
5.14314
4.99905
4.74002
4.50643
4.31099
4.14285
3.99212
3.85343
3.72371
3.60175
3.48642
3.37756
3.27448
3.17721
3.08518
2.99835
2.91633
2.83891
2.76597
2.69708
2.63259
2.5717
2.51195
2.4547
2.40009
2.349
2.30125
2.25614
2.21348
2.17311
2.13493
2.09884
2.06496
2.03308
2.00383
1.9773
1.95371
1.9365
1.92149
1.9224
1.92751
1.94081
1.97189
2.03474
2.14441
2.30562
2.51332
2.74433
2.86015
2.90462
2.89837
2.88079
2.84622
2.81039
2.77504
2.74197
2.71231
2.68637
2.66208
2.63855
2.61442
2.5894
2.56304
2.53566
2.50727
2.4784
2.44903
2.41989
2.39038
2.36202
2.33265
2.30703
2.27939
4.37171
5.56495
5.7353
5.6891
5.55305
5.27183
4.97912
4.72442
4.49563
4.28302
4.08218
3.89157
3.71071
3.53954
3.37909
3.23012
3.09947
2.98985
2.97039
2.99345
3.08333
3.32573
3.86069
4.9448
5.53072
5.55629
5.50608
5.34408
5.05643
4.7975
4.58161
4.39608
4.22988
4.0765
3.93288
3.79725
3.66898
3.5473
3.43218
3.32298
3.21978
3.12195
3.02949
2.94195
2.85919
2.78096
2.70702
2.63736
2.57143
2.50994
2.45059
2.39333
2.33849
2.28653
2.23809
2.19241
2.14924
2.1084
2.06977
2.03322
1.99869
1.96622
1.93564
1.90759
1.88181
1.8591
1.84171
1.82666
1.82656
1.83006
1.84248
1.87031
1.92939
2.04049
2.20365
2.40783
2.64801
2.75888
2.80747
2.80279
2.78848
2.75934
2.72481
2.69037
2.65774
2.62826
2.60204
2.57753
2.5538
2.52985
2.50532
2.47981
2.45357
2.42641
2.39907
2.37097
2.34376
2.31531
2.29046
2.26351
2.75735
4.93572
5.57611
5.61587
5.55085
5.39072
5.10062
4.83071
4.59232
4.37667
4.17543
3.98546
3.80539
3.6356
3.47711
3.33674
3.21866
3.18704
3.20927
3.30026
3.54875
4.10997
5.25146
5.91739
5.95905
5.90207
5.71778
5.39804
5.11145
4.87342
4.66976
4.48744
4.3192
4.16126
4.01199
3.87039
3.73611
3.60861
3.48785
3.3732
3.26472
3.16173
3.06429
2.97183
2.88431
2.80137
2.72288
2.64862
2.57842
2.51213
2.44964
2.39098
2.33364
2.27881
2.22661
2.17773
2.13173
2.08823
2.04706
2.0081
1.97123
1.93635
1.90339
1.87243
1.84321
1.81643
1.79163
1.7698
1.75269
1.7379
1.73709
1.74038
1.75197
1.77907
1.83713
1.9493
2.1123
2.3233
2.55875
2.66363
2.71432
2.71096
2.69884
2.67399
2.64079
2.60742
2.57564
2.54667
2.52062
2.49623
2.47272
2.44919
2.42541
2.4008
2.37586
2.34983
2.32435
2.29733
2.27355
2.24759
2.10202
3.51975
5.14105
5.50901
5.50176
5.42278
5.23809
4.95308
4.6988
4.47429
4.26974
4.07798
3.89928
3.73189
3.58214
3.45584
3.41487
3.43669
3.52925
3.78509
4.36567
5.55387
6.32183
6.38215
6.31893
6.11489
5.76274
5.44753
5.18648
4.96359
4.76449
4.58061
4.40796
4.24446
4.08934
3.94192
3.80205
3.6692
3.54333
3.4238
3.31061
3.20307
3.1012
3.00439
2.91265
2.82552
2.74293
2.66461
2.59043
2.52018
2.45383
2.39093
2.33205
2.27546
2.22093
2.16886
2.11993
2.0738
2.03013
1.98878
1.94964
1.91257
1.87751
1.84435
1.813
1.78358
1.75578
1.73029
1.70667
1.68571
1.66932
1.65497
1.65422
1.65753
1.66883
1.69658
1.7546
1.86807
2.02674
2.24831
2.47733
2.57395
2.62503
2.62273
2.61255
2.59069
2.5591
2.52702
2.49641
2.46825
2.44278
2.41881
2.39585
2.37289
2.3501
2.32635
2.30304
2.27801
2.25573
2.23137
1.62574
2.32885
4.18695
5.2387
5.42209
5.39542
5.2959
5.0804
4.81112
4.57364
4.36303
4.172
3.99451
3.83593
3.70135
3.65261
3.67468
3.77103
4.03946
4.65316
5.91888
6.76042
6.82998
6.75909
6.53323
6.14752
5.80342
5.51888
5.27644
5.05986
4.85993
4.67189
4.4938
4.32453
4.16372
4.01088
3.86589
3.72821
3.59774
3.47382
3.35639
3.24475
3.13891
3.03819
2.94266
2.85179
2.76556
2.68364
2.60593
2.53223
2.46238
2.39625
2.33366
2.27463
2.21866
2.16458
2.11288
2.06412
2.01805
1.9744
1.93304
1.89388
1.8568
1.82171
1.78849
1.75712
1.72743
1.69961
1.6733
1.64911
1.62682
1.6067
1.59142
1.57756
1.57769
1.58129
1.59247
1.6221
1.68241
1.79954
1.95458
2.1783
2.40128
2.48996
2.53975
2.53854
2.53022
2.5107
2.48079
2.45017
2.4209
2.39375
2.36913
2.34576
2.32363
2.30131
2.27989
2.25693
2.23652
2.21436
1.27937
1.73791
2.62695
4.6072
5.25103
5.33194
5.28742
5.16998
4.92991
4.68127
4.46295
4.26932
4.09935
3.95762
3.90041
3.92309
4.02467
4.30916
4.96298
6.31525
7.24709
7.31379
7.23048
6.97531
6.55365
6.17913
5.87048
5.60785
5.37339
5.15662
4.95268
4.75918
4.57531
4.40039
4.23427
4.07645
3.9268
3.78475
3.6501
3.52222
3.40096
3.28564
3.17621
3.07202
2.97309
2.87888
2.78941
2.70429
2.62347
2.5467
2.47383
2.40472
2.33917
2.27714
2.21832
2.16302
2.10947
2.05831
2.01003
1.96425
1.92085
1.8797
1.84071
1.80376
1.76878
1.73566
1.70432
1.67474
1.64674
1.6205
1.59574
1.57281
1.55202
1.5327
1.5188
1.50582
1.50654
1.51162
1.52223
1.55615
1.61638
1.73856
1.90274
2.12166
2.33053
2.41315
2.46002
2.45953
2.45223
2.43449
2.40641
2.37746
2.34981
2.32381
2.30025
2.27758
2.25668
2.23508
2.21621
2.19628
1.17403
1.36797
1.96806
3.1972
4.79344
5.20832
5.23419
5.17937
5.04649
4.80254
4.57526
4.38192
4.22299
4.1583
4.18215
4.29087
4.59771
5.30531
6.77197
7.78195
7.83099
7.73057
7.44122
6.9826
6.5771
6.24342
5.95971
5.7061
5.47145
5.25029
5.04055
4.84102
4.65145
4.47123
4.30026
4.13795
3.9841
3.83809
3.69967
3.56819
3.44344
3.32478
3.21208
3.10476
3.00278
2.90561
2.81327
2.72534
2.6418
2.56233
2.48685
2.41514
2.34705
2.28243
2.22116
2.16298
2.10825
2.05548
2.00504
1.9574
1.91215
1.8692
1.82843
1.78977
1.75313
1.7184
1.68554
1.65442
1.62498
1.5972
1.5709
1.54621
1.52304
1.50133
1.48206
1.46375
1.45096
1.44008
1.44111
1.44617
1.46082
1.49315
1.56039
1.68353
1.85395
2.07327
2.26524
2.34155
2.38518
2.38583
2.37956
2.36288
2.33679
2.30967
2.28374
2.25896
2.23681
2.21512
2.19641
2.17802
1.08128
1.22119
1.48537
2.21406
3.74755
4.87798
5.14116
5.13609
5.0764
4.9347
4.70758
4.51319
4.4274
4.45206
4.56962
4.90246
5.67384
7.271
8.34133
8.3688
8.24902
7.92537
7.43278
6.99661
6.63821
6.33324
6.05994
5.80612
5.5665
5.33884
5.12253
4.91691
4.72187
4.53672
4.36131
4.1949
4.03724
3.88761
3.74577
3.61099
3.48309
3.36141
3.24579
3.13565
3.03094
2.93114
2.83627
2.74586
2.65994
2.57813
2.50039
2.42643
2.35614
2.28933
2.22586
2.16562
2.10836
2.05443
2.00248
1.95306
1.90617
1.86161
1.81928
1.77908
1.74095
1.70476
1.67048
1.63797
1.6072
1.57807
1.55048
1.52445
1.49985
1.47663
1.4551
1.4346
1.41685
1.39989
1.38793
1.3799
1.38115
1.38766
1.4026
1.43986
1.51209
1.64421
1.81758
2.03131
2.20564
2.27714
2.3166
2.3179
2.31211
2.29682
2.2727
2.2475
2.22357
2.20028
2.18063
2.16192
1.04144
1.11583
1.23588
1.64001
2.38321
4.14029
4.91749
5.07121
5.05697
4.99524
4.85514
4.72189
4.74374
4.86793
5.22851
6.07995
7.83482
8.96492
8.95101
8.79365
8.41158
7.89511
7.43541
7.05462
6.72875
6.43517
6.16131
5.90178
5.65493
5.42016
5.1974
4.98614
4.78612
4.59657
4.41715
4.24703
4.0859
3.93295
3.78796
3.65021
3.51942
3.39498
3.27672
3.16406
3.05691
2.9548
2.85768
2.76513
2.67713
2.5933
2.5136
2.43771
2.36554
2.29688
2.23158
2.16949
2.1105
2.05441
2.00144
1.95052
1.90219
1.85623
1.81254
1.77101
1.73156
1.6941
1.65854
1.6248
1.59281
1.56248
1.53374
1.50654
1.48079
1.45643
1.43354
1.4118
1.39186
1.37281
1.35628
1.34136
1.32969
1.32532
1.32699
1.33457
1.35185
1.39285
1.47022
1.60807
1.78838
1.99755
2.15226
2.21902
2.25458
2.25654
2.2512
2.23711
2.21505
2.19202
2.17151
2.15124
1.02509
1.04977
1.13848
1.28674
1.73873
2.6045
4.3636
4.91689
5.02659
5.02276
5.00912
5.03378
5.1754
5.58067
6.53904
8.48373
9.59865
9.56755
9.36604
8.91324
8.37034
7.89149
7.49047
7.1443
6.83007
6.53524
6.25488
5.98763
5.73348
5.4923
5.264
5.0479
4.8436
4.65017
4.46718
4.29373
4.12946
3.97356
3.82573
3.68525
3.55185
3.42491
3.30425
3.18933
3.08006
2.97594
2.87692
2.78255
2.69281
2.60729
2.52593
2.4484
2.37467
2.30444
2.23764
2.17403
2.11354
2.05598
2.00132
1.94934
1.8998
1.85263
1.80777
1.76508
1.72449
1.68591
1.64924
1.61441
1.58134
1.54994
1.52016
1.49192
1.46517
1.43981
1.41589
1.39321
1.37201
1.35189
1.33338
1.31617
1.30052
1.28813
1.27708
1.27614
1.27832
1.28815
1.30709
1.35415
1.44012
1.58316
1.76685
1.96946
2.10626
2.16871
2.20024
2.20257
2.19769
2.18493
2.16618
2.14691
1.01148
1.03104
1.06364
1.17128
1.37185
1.93333
3.11002
4.49065
4.92739
5.05579
5.16484
5.41678
5.95457
7.10027
9.31232
10.3352
10.2699
10.0019
9.4401
8.86536
8.3728
7.95701
7.59057
7.25302
6.9339
6.62955
6.3395
6.06392
5.80297
5.55622
5.32324
5.10306
4.89507
4.69822
4.51203
4.33554
4.16837
4.00974
3.85929
3.71635
3.58054
3.45135
3.3285
3.21157
3.10035
2.99442
2.89365
2.79767
2.70638
2.6194
2.53669
2.45789
2.38288
2.3114
2.24334
2.1785
2.11678
2.05802
2.00207
1.94899
1.89835
1.85015
1.80427
1.76063
1.7191
1.6796
1.64202
1.60629
1.57231
1.54002
1.50933
1.48018
1.45253
1.42629
1.40149
1.37798
1.35588
1.33495
1.31537
1.29707
1.27988
1.26468
1.25018
1.23987
1.23115
1.23195
1.23539
1.24843
1.27054
1.32484
1.41818
1.56366
1.75263
1.94849
2.06805
2.12678
2.15412
2.15804
2.1542
2.14484
1.00705
1.01422
1.03836
1.07948
1.2116
1.45962
2.12405
3.48914
4.62684
5.04176
5.43204
6.21083
7.73717
10.2543
11.1473
11.0407
10.696
10.0009
9.37139
8.8631
8.43713
8.05521
7.69564
7.35101
7.02073
6.70582
6.40718
6.12496
5.85882
5.60783
5.37118
5.14769
4.93665
4.73698
4.54809
4.3691
4.19954
4.03864
3.88601
3.741
3.60334
3.47245
3.34802
3.22956
3.11684
3.00954
2.90744
2.81024
2.71776
2.62967
2.54584
2.46595
2.3899
2.3174
2.24836
2.18253
2.11985
2.06011
2.00324
1.94912
1.89758
1.84849
1.8018
1.75734
1.71504
1.67477
1.63643
1.59994
1.5652
1.53215
1.50071
1.47083
1.44245
1.41553
1.39002
1.36582
1.34298
1.32138
1.30106
1.28202
1.26405
1.24762
1.23202
1.21846
1.20618
1.19665
1.19252
1.19367
1.19964
1.21135
1.24341
1.30258
1.40758
1.55457
1.74628
1.93662
2.03774
2.09626
2.11802
2.13312
1.0032
1.00859
1.01725
1.04663
1.09615
1.25576
1.55424
2.32896
3.90283
4.97357
6.0358
8.15695
11.3369
12.1259
11.9598
11.4761
10.6048
9.91347
9.38042
8.94304
8.54575
8.16434
7.79371
7.43609
7.09469
6.7713
6.46638
6.17932
5.90919
5.65467
5.41475
5.18822
4.97428
4.77189
4.58046
4.39908
4.22727
4.06427
3.90966
3.76281
3.62333
3.49074
3.36466
3.24477
3.1307
3.0222
2.91895
2.82071
2.7272
2.63816
2.5534
2.47262
2.3957
2.32235
2.2525
2.18587
2.12242
2.06191
2.00431
1.94938
1.89712
1.84732
1.79998
1.7549
1.71201
1.67115
1.63224
1.59517
1.55986
1.52623
1.49422
1.46376
1.43479
1.40728
1.38116
1.3564
1.33298
1.31084
1.28997
1.27036
1.25188
1.23473
1.21861
1.20384
1.19038
1.17806
1.16866
1.16026
1.16046
1.1626
1.16955
1.18606
1.22174
1.29184
1.40479
1.55837
1.7438
1.93671
2.01552
2.0951
1.00177
1.0047
1.00947
1.02537
1.05164
1.13829
1.29292
1.75184
2.64821
4.72568
7.58472
12.3334
13.1163
12.8485
12.1583
11.243
10.5404
9.99029
9.52568
9.08618
8.6637
8.25683
7.86715
7.49662
7.14653
6.81696
6.50727
6.21624
5.94261
5.68494
5.44221
5.21318
4.99703
4.79269
4.59949
4.41653
4.24325
4.07893
3.92307
3.77511
3.63459
3.50111
3.3742
3.2536
3.13886
3.02977
2.92594
2.82717
2.73312
2.64358
2.55829
2.47699
2.39954
2.32565
2.25526
2.18808
2.1241
2.06303
2.00491
1.94943
1.8967
1.84642
1.79856
1.75295
1.70953
1.66816
1.62878
1.59127
1.55554
1.52152
1.4891
1.45825
1.42889
1.40099
1.37447
1.34932
1.3255
1.30297
1.28169
1.26168
1.24284
1.22523
1.20878
1.19347
1.17944
1.1664
1.15503
1.14478
1.13692
1.13314
1.13394
1.13758
1.14689
1.16815
1.21151
1.29857
1.39745
1.58923
1.74749
1.9791
1.00132
1.00266
1.00731
1.01446
1.04179
1.08009
1.24659
1.52243
2.51114
4.83199
10.749
13.7803
13.5015
12.7607
11.8999
11.2192
10.6552
10.1533
9.66926
9.19585
8.74191
8.31437
7.91348
7.53731
7.18413
6.8523
6.54041
6.24697
5.9709
5.71089
5.46598
5.23496
5.01699
4.81101
4.61631
4.43198
4.25743
4.09194
3.93498
3.78602
3.64454
3.5102
3.38246
3.26111
3.14566
3.03593
2.93148
2.83215
2.73757
2.64754
2.56179
2.48009
2.40226
2.32802
2.2573
2.18979
2.1255
2.06412
2.00569
1.94992
1.89685
1.84623
1.79804
1.7521
1.70836
1.66669
1.62698
1.58919
1.55314
1.51885
1.48614
1.45502
1.42538
1.39719
1.3704
1.34496
1.32085
1.29804
1.27648
1.25618
1.23708
1.21919
1.20248
1.18692
1.17256
1.15928
1.14724
1.13639
1.12674
1.11937
1.1133
1.11368
1.11552
1.12143
1.13334
1.16169
1.21296
1.31778
1.4409
1.69985
1.00111
1.00224
1.00623
1.01242
1.03663
1.06843
1.22875
1.46098
2.52394
4.9767
11.6
13.0408
12.8232
12.3769
11.9084
11.4106
10.8746
10.3178
9.77562
9.26627
8.79294
8.3532
7.94425
7.56295
7.20615
6.87136
6.55682
6.26104
5.98289
5.72111
5.4747
5.24245
5.02344
4.81659
4.62113
4.43615
4.26102
4.09503
3.93762
3.78827
3.64645
3.51181
3.3838
3.26223
3.14657
3.03667
2.93205
2.83259
2.73786
2.6477
2.56181
2.47998
2.402
2.32762
2.25675
2.1891
2.12466
2.06313
2.00456
1.94864
1.89543
1.84467
1.79637
1.75033
1.70648
1.66473
1.62492
1.58704
1.55089
1.51653
1.48371
1.45253
1.42279
1.39454
1.36766
1.34214
1.31795
1.29504
1.2734
1.253
1.2338
1.21582
1.19901
1.18336
1.1689
1.1555
1.14337
1.13218
1.12245
1.11353
1.10688
1.10116
1.10152
1.10323
1.10841
1.11831
1.14265
1.18767
1.27847
1.46997
3.06392
1.55572
1.04738
0.94249
0.968239
1.047
1.21278
1.34496
1.38604
1.3844
1.37913
1.37929
1.38126
1.38658
1.39739
1.40524
1.40782
1.40764
1.40702
1.40564
1.40382
1.40227
1.40089
1.3992
1.3971
1.39489
1.39411
1.39456
1.39658
1.40281
1.41917
1.45922
1.55344
1.77079
2.27362
3.29725
3.69945
3.67796
3.70176
3.72287
3.79133
3.90604
4.0529
4.19832
4.32313
4.41649
4.50341
4.55909
4.59386
4.6121
4.61785
4.61527
4.60545
4.58435
4.55623
4.52463
4.49094
4.45445
4.41538
4.37375
4.32967
4.28363
4.23575
4.18634
4.13581
4.08394
4.03159
3.97875
3.9256
3.87198
3.81857
3.76514
3.71177
3.65854
3.60548
3.55278
3.50036
3.44853
3.39716
3.3464
3.29627
3.24684
3.19802
3.14991
3.10236
3.05561
3.00944
2.96405
2.91927
2.87547
2.83225
2.78991
2.74817
2.70743
2.66752
2.629
2.592
2.55784
2.52788
2.50681
3.71843
2.31611
1.71693
1.46598
1.34999
1.27844
1.26402
1.27193
1.29406
1.33967
1.38503
1.4038
1.40351
1.4022
1.4001
1.40043
1.40156
1.40405
1.4068
1.40678
1.40646
1.40549
1.40342
1.40019
1.39707
1.39438
1.39272
1.39309
1.39489
1.40035
1.4142
1.44762
1.52649
1.71048
2.13815
3.09231
3.71967
3.70315
3.69908
3.726
3.79485
3.89533
4.02273
4.16683
4.29381
4.39646
4.47936
4.53676
4.57362
4.5934
4.60069
4.59935
4.59318
4.57747
4.54877
4.51615
4.4826
4.44661
4.40836
4.36714
4.32368
4.27791
4.23051
4.18142
4.13122
4.07982
4.02775
3.97511
3.92219
3.86894
3.81565
3.76236
3.70911
3.656
3.60304
3.55043
3.49813
3.44636
3.39505
3.34438
3.29426
3.24484
3.19606
3.14796
3.10052
3.0539
3.00805
2.96286
2.91839
2.87441
2.83126
2.78877
2.7472
2.70635
2.66656
2.6278
2.59074
2.55604
2.52546
2.50373
4.54542
3.24224
2.42437
1.9081
1.57868
1.37482
1.25762
1.24501
1.2524
1.27385
1.31851
1.36075
1.3879
1.40075
1.40314
1.40283
1.402
1.40143
1.40151
1.40151
1.4014
1.40106
1.40023
1.3985
1.39579
1.39289
1.39003
1.38991
1.39067
1.39386
1.40257
1.42607
1.47866
1.6094
1.89811
2.56399
3.61145
3.7748
3.79958
3.84114
3.9029
3.98074
4.06964
4.16964
4.2664
4.36227
4.44294
4.50229
4.54169
4.56329
4.57166
4.57092
4.5672
4.55689
4.53487
4.5024
4.46864
4.43324
4.39562
4.35526
4.31255
4.26753
4.22072
4.17228
4.12261
4.07188
4.02034
3.96822
3.9157
3.8629
3.80992
3.75689
3.70389
3.65098
3.59828
3.54581
3.49377
3.44212
3.39108
3.34058
3.2907
3.24145
3.193
3.1452
3.09818
3.0516
3.00576
2.96053
2.9161
2.87224
2.82923
2.78682
2.74535
2.70451
2.66476
2.62587
2.5886
2.55334
2.52197
2.49845
4.99809
3.82353
2.95369
2.34794
1.94206
1.66924
1.49828
1.39167
1.32999
1.31426
1.31767
1.32906
1.35327
1.38141
1.40082
1.41087
1.4108
1.41009
1.40834
1.40524
1.40331
1.40216
1.40128
1.40028
1.39852
1.39597
1.39276
1.39011
1.39042
1.39194
1.39792
1.41093
1.44868
1.52948
1.73237
2.18644
3.20624
3.79431
4.03504
4.12457
4.16764
4.19625
4.20541
4.21621
4.24323
4.29868
4.3683
4.43237
4.48393
4.51572
4.53039
4.53192
4.52989
4.52345
4.50885
4.48062
4.44757
4.41247
4.37555
4.33642
4.29502
4.25132
4.20564
4.15825
4.10952
4.05966
4.00897
3.95758
3.90573
3.85348
3.80104
3.74843
3.69586
3.6433
3.59098
3.53883
3.48716
3.43583
3.38508
3.33488
3.28549
3.2366
3.18841
3.14075
3.09385
3.04744
3.00182
2.95674
2.91252
2.86882
2.82602
2.78371
2.74238
2.70157
2.66188
2.6229
2.58546
2.54969
2.51737
2.49204
5.27096
4.2438
3.40834
2.77522
2.31291
1.97671
1.73297
1.55883
1.4372
1.36078
1.32043
1.32044
1.32386
1.33372
1.35409
1.37434
1.38908
1.39825
1.40087
1.40054
1.39948
1.39724
1.39456
1.39226
1.39029
1.38848
1.38709
1.38523
1.38537
1.38646
1.38895
1.39947
1.41798
1.47799
1.59386
1.88938
2.50743
3.68456
4.37392
4.59503
4.59023
4.54688
4.43776
4.30842
4.24875
4.2525
4.27375
4.32372
4.38798
4.43743
4.46834
4.48239
4.48219
4.4794
4.4711
4.45267
4.4219
4.38683
4.35013
4.31194
4.27195
4.22988
4.18583
4.13998
4.09259
4.04391
3.99427
3.9438
3.89276
3.84121
3.78941
3.73737
3.68534
3.63323
3.58143
3.52972
3.47853
3.42775
3.37767
3.32799
3.27901
3.23042
3.18253
3.13508
3.08844
3.04225
2.99692
2.95202
2.90806
2.86452
2.82195
2.7798
2.73866
2.69799
2.65841
2.61947
2.58193
2.54584
2.51296
2.48608
5.45694
4.56565
3.79002
3.16119
2.6702
2.29315
2.00588
1.78922
1.62705
1.5101
1.42543
1.37172
1.34284
1.34037
1.34279
1.35001
1.36509
1.38179
1.39464
1.40286
1.40425
1.40384
1.4026
1.3999
1.39592
1.39225
1.38918
1.38641
1.3852
1.38566
1.38738
1.39349
1.40699
1.44366
1.52382
1.71986
2.16316
3.18023
4.68712
5.20034
5.14496
4.98554
4.69393
4.45084
4.29457
4.22908
4.22116
4.22827
4.25391
4.3069
4.35728
4.39483
4.41429
4.41818
4.41578
4.40742
4.38852
4.3565
4.32016
4.28218
4.24293
4.20231
4.16022
4.11646
4.07102
4.02406
3.97588
3.92663
3.87663
3.82596
3.77496
3.72361
3.67225
3.6207
3.56953
3.51867
3.46828
3.41817
3.36863
3.31936
3.27075
3.22245
3.17491
3.12773
3.08142
3.03548
2.99047
2.94583
2.90216
2.85887
2.81656
2.77467
2.73374
2.69329
2.65384
2.61502
2.57747
2.54118
2.50797
2.47994
5.58462
4.8101
4.10287
3.49784
2.99978
2.59866
2.27955
2.02734
1.82855
1.67353
1.55326
1.46482
1.39991
1.36188
1.34197
1.34205
1.34413
1.34993
1.36188
1.3744
1.38372
1.39015
1.3907
1.39038
1.3894
1.38731
1.3842
1.38124
1.37965
1.38002
1.38162
1.38636
1.39808
1.4269
1.49253
1.64905
2.0111
2.86557
4.72905
5.84275
5.75838
5.50585
5.07225
4.7066
4.44701
4.28685
4.20559
4.17941
4.17689
4.18552
4.21158
4.26226
4.30341
4.33326
4.34418
4.34281
4.33631
4.32042
4.28871
4.25207
4.21263
4.1723
4.13135
4.08935
4.04596
4.00105
3.95477
3.9071
3.8584
3.80878
3.75866
3.70808
3.65747
3.60692
3.55664
3.50649
3.45682
3.40725
3.35824
3.30939
3.26124
3.21332
3.16622
3.1194
3.07347
3.02787
2.9832
2.9389
2.89553
2.85257
2.81052
2.76894
2.72824
2.68807
2.64879
2.61016
2.57268
2.53633
2.50298
2.47417
5.6777
4.9957
4.35235
3.77991
3.28965
2.87959
2.54174
2.26558
2.04107
1.85971
1.71378
1.59808
1.50782
1.44057
1.39123
1.36296
1.3473
1.34738
1.34911
1.35398
1.36404
1.37527
1.38408
1.39068
1.39093
1.3904
1.38889
1.38577
1.38232
1.38248
1.3836
1.3892
1.39934
1.43144
1.49069
1.64489
1.95502
2.66514
4.13898
5.9055
5.98415
5.8498
5.51921
5.11692
4.74788
4.48613
4.30451
4.19273
4.14257
4.12418
4.12492
4.13449
4.15987
4.20732
4.23854
4.25928
4.26017
4.25654
4.2448
4.21933
4.18252
4.14223
4.10102
4.05916
4.01677
3.97354
3.9293
3.88355
3.8366
3.7884
3.73937
3.68988
3.64043
3.59083
3.5415
3.49207
3.44308
3.39408
3.34567
3.29736
3.24974
3.20234
3.15571
3.10938
3.06387
3.01873
2.97444
2.93057
2.88754
2.84498
2.80325
2.76203
2.72162
2.68177
2.64273
2.60433
2.567
2.53068
2.49731
2.46801
5.74508
5.13907
4.55375
4.0171
3.54292
3.13408
2.78718
2.49591
2.2527
2.05079
1.88342
1.74564
1.633
1.54205
1.4706
1.41679
1.37792
1.3565
1.34565
1.34583
1.34734
1.35139
1.3596
1.36789
1.37381
1.37783
1.37974
1.3797
1.37974
1.3805
1.38276
1.39095
1.40781
1.45171
1.54133
1.74109
2.14147
2.94162
3.70304
4.69577
5.52071
5.67662
5.6165
5.42999
5.08878
4.8
4.52426
4.32922
4.19605
4.11379
4.08125
4.06549
4.06734
4.07815
4.10374
4.14084
4.16252
4.1723
4.17054
4.16313
4.14563
4.11125
4.07219
4.02962
3.98672
3.94383
3.90078
3.85668
3.81165
3.76519
3.71811
3.67004
3.62184
3.57321
3.52473
3.47604
3.42773
3.37941
3.33163
3.28398
3.23696
3.19017
3.14408
3.09832
3.05329
3.00867
2.96481
2.9214
2.87879
2.83665
2.79529
2.75445
2.71438
2.67485
2.63612
2.59796
2.56088
2.52462
2.49136
2.46174
5.79763
5.25188
4.717
4.21581
3.76183
3.36071
3.012
2.71253
2.45694
2.24014
2.05659
1.90192
1.77194
1.66362
1.57429
1.50165
1.44515
1.40175
1.37075
1.35342
1.34462
1.34481
1.34617
1.34976
1.35708
1.36503
1.37167
1.37601
1.37849
1.38195
1.38946
1.4051
1.44051
1.51498
1.67451
1.99858
2.64816
3.19897
3.52438
3.92008
4.43971
5.01689
5.35028
5.32979
5.24008
5.04631
4.78995
4.57222
4.36217
4.21132
4.10997
4.04669
4.02093
4.00416
4.00606
4.01508
4.03526
4.06187
4.07674
4.0776
4.07425
4.06318
4.03919
4.00053
3.95828
3.91462
3.87098
3.82719
3.78336
3.73869
3.69349
3.64725
3.60055
3.55313
3.50563
3.4578
3.41025
3.36267
3.31558
3.26865
3.22231
3.17622
3.13076
3.08563
3.04119
2.99713
2.95381
2.91092
2.86879
2.82712
2.78623
2.7458
2.70616
2.66698
2.62864
2.59075
2.55397
2.51785
2.48476
2.4549
5.83729
5.34166
4.85081
4.38343
3.95188
3.56273
3.21752
2.91517
2.65226
2.42516
2.22945
2.0615
1.91748
1.79461
1.69012
1.60202
1.52882
1.46888
1.42186
1.38615
1.36122
1.34713
1.34064
1.34087
1.34221
1.34551
1.35219
1.36007
1.36868
1.37832
1.39409
1.42585
1.49302
1.63104
1.91567
2.48976
3.08037
3.3393
3.45793
3.6
3.81347
4.11453
4.53551
4.86237
5.02044
5.00012
4.92295
4.75339
4.56595
4.40179
4.24
4.1157
4.03318
3.97916
3.95415
3.93512
3.9368
3.94331
3.9572
3.97566
3.98291
3.98139
3.97503
3.95924
3.92742
3.88674
3.84234
3.79764
3.75385
3.71012
3.66628
3.62167
3.57658
3.53063
3.48442
3.43769
3.39111
3.34441
3.29814
3.25199
3.2064
3.16103
3.11629
3.07182
3.02803
2.98458
2.94185
2.8995
2.85792
2.81673
2.77634
2.73635
2.69717
2.65838
2.62044
2.58288
2.54645
2.51052
2.47767
2.44765
5.87021
5.41434
4.96143
4.52552
4.11685
3.74216
3.4039
3.10257
2.83615
2.60237
2.39775
2.2195
2.06426
1.9296
1.81292
1.71235
1.6262
1.55316
1.49224
1.44239
1.40334
1.37371
1.35331
1.34152
1.33797
1.3387
1.34136
1.34743
1.35979
1.37847
1.40855
1.46956
1.59292
1.84553
2.35427
3.00887
3.30935
3.40166
3.43284
3.47049
3.53342
3.64198
3.81531
4.05055
4.37114
4.61701
4.74571
4.73019
4.67254
4.54545
4.39061
4.25971
4.13406
4.02395
3.94984
3.904
3.87672
3.85744
3.85862
3.86329
3.87306
3.88556
3.88531
3.8823
3.87292
3.85188
3.81319
3.77012
3.72581
3.68145
3.63766
3.59373
3.5498
3.5052
3.46041
3.41507
3.36978
3.32424
3.27901
3.2338
3.18908
3.14451
3.10053
3.05678
3.01367
2.97086
2.92876
2.88699
2.84599
2.80535
2.76549
2.726
2.6873
2.64895
2.61144
2.57426
2.53818
2.50251
2.46993
2.43976
5.89539
5.47315
5.05501
4.64881
4.26268
3.90345
3.57432
3.27656
3.00953
2.77171
2.56089
2.37462
2.21051
2.06608
1.93939
1.82833
1.73151
1.64732
1.57493
1.51311
1.46157
1.41936
1.38631
1.36207
1.34496
1.34079
1.34217
1.34685
1.35972
1.38447
1.43864
1.54485
1.76553
2.20647
2.88285
3.28029
3.40117
3.4208
3.42002
3.41533
3.40714
3.41557
3.44997
3.53055
3.68861
3.90457
4.18272
4.3896
4.51073
4.49998
4.45999
4.37501
4.23872
4.12877
4.02749
3.92956
3.86339
3.8224
3.79412
3.77408
3.77505
3.77862
3.78494
3.78927
3.7878
3.78197
3.76771
3.73832
3.69845
3.65435
3.61012
3.5659
3.52211
3.47813
3.4344
3.39039
3.34651
3.30236
3.25839
3.21432
3.17057
3.12691
3.08371
3.04074
2.99833
2.95622
2.91476
2.87364
2.83321
2.79315
2.75382
2.71487
2.67665
2.63879
2.60171
2.56496
2.52928
2.4939
2.46164
2.43135
5.92499
5.531
5.14072
4.75906
4.39348
4.04917
3.7298
3.43706
3.17123
2.93152
2.71654
2.52442
2.35327
2.20109
2.06605
1.94636
1.84063
1.74726
1.66549
1.59393
1.53221
1.47953
1.43546
1.40021
1.373
1.35819
1.35948
1.36504
1.3841
1.42089
1.51019
1.68541
2.0494
2.71482
3.20995
3.39186
3.42416
3.42188
3.40981
3.38001
3.32382
3.27794
3.27734
3.28813
3.3247
3.40619
3.56017
3.75212
3.98275
4.16397
4.29101
4.29028
4.27024
4.2166
4.10801
4.00588
3.91666
3.83789
3.77578
3.73462
3.70712
3.68859
3.68794
3.68926
3.69238
3.69188
3.68872
3.67957
3.6596
3.62268
3.58125
3.53759
3.49361
3.44964
3.40638
3.36337
3.32075
3.27809
3.23554
3.19288
3.15036
3.10784
3.0656
3.02353
2.98189
2.94053
2.89973
2.85927
2.81945
2.78001
2.74124
2.70284
2.66515
2.62779
2.5912
2.55487
2.51964
2.48455
2.45267
2.42232
5.96348
5.5895
5.22183
4.8609
4.51285
4.18239
3.87236
3.58526
3.32167
3.08162
2.864
2.66788
2.49128
2.33305
2.19121
2.06439
1.95129
1.85022
1.76067
1.68099
1.61095
1.54965
1.4964
1.45247
1.41569
1.39558
1.39756
1.40791
1.434
1.50374
1.64232
1.94253
2.53735
3.10072
3.36256
3.42305
3.42196
3.41136
3.38209
3.32223
3.2592
3.20645
3.16876
3.14633
3.14963
3.16382
3.20042
3.27595
3.40768
3.5736
3.76886
3.94307
4.07004
4.10696
4.09581
4.06166
3.98648
3.89041
3.8121
3.74355
3.68444
3.64446
3.61732
3.60009
3.59658
3.59697
3.59683
3.5951
3.58902
3.57418
3.54394
3.50515
3.46339
3.42037
3.37762
3.33526
3.29352
3.25201
3.21077
3.16951
3.12835
3.08712
3.04606
3.00503
2.96433
2.9238
2.88376
2.84398
2.80482
2.76597
2.72781
2.68995
2.65282
2.61595
2.57989
2.54399
2.50925
2.47447
2.44302
2.41264
6.02194
5.65397
5.30101
4.95758
4.62379
4.30418
4.00285
3.72149
3.46096
3.22188
3.00299
2.80436
2.62392
2.46095
2.3139
2.18113
2.06202
1.95443
1.85836
1.77184
1.69482
1.62652
1.56561
1.51584
1.47078
1.45638
1.46051
1.48053
1.52426
1.64902
1.88648
2.40006
3.0067
3.33274
3.42769
3.42666
3.41568
3.38543
3.32344
3.25768
3.20117
3.15187
3.1082
3.0701
3.04206
3.02229
3.02504
3.03683
3.0663
3.12721
3.23776
3.38322
3.55264
3.72451
3.85132
3.93573
3.93039
3.91093
3.87169
3.79439
3.71333
3.64552
3.5924
3.55237
3.5234
3.50883
3.50673
3.50638
3.50476
3.4997
3.48767
3.46257
3.42875
3.39011
3.34936
3.30782
3.26647
3.22539
3.18483
3.14451
3.10454
3.06457
3.02482
2.98498
2.94542
2.90585
2.86671
2.82769
2.78926
2.75103
2.71349
2.67617
2.63962
2.60325
2.56772
2.53227
2.49804
2.46361
2.43261
2.40224
6.10634
5.72373
5.37719
5.04501
4.72375
4.41545
4.12205
3.84688
3.58972
3.35266
3.13381
2.93372
2.75101
2.58435
2.43343
2.29579
2.17175
2.05876
1.95707
1.86487
1.78191
1.70779
1.64136
1.58701
1.54124
1.542
1.55319
1.58442
1.68486
1.8789
2.31406
2.96009
3.33266
3.45624
3.45506
3.44247
3.40548
3.33086
3.25841
3.19801
3.14762
3.10129
3.0577
3.01622
2.97725
2.94243
2.91569
2.89402
2.89577
2.90375
2.92519
2.97135
3.06338
3.18892
3.34162
3.50507
3.6473
3.74947
3.78684
3.77877
3.7523
3.6941
3.61912
3.55088
3.49555
3.45332
3.42784
3.41715
3.41356
3.41156
3.40722
3.39771
3.37875
3.35044
3.3164
3.27873
3.23936
3.19917
3.15911
3.11923
3.07991
3.04079
3.00211
2.96339
2.92501
2.88652
2.84843
2.8103
2.77271
2.73517
2.69831
2.66157
2.62559
2.58974
2.55474
2.51977
2.48603
2.45198
2.42144
2.39111
6.19149
5.79935
5.45036
5.12565
4.81424
4.51615
4.23136
3.96255
3.70976
3.47486
3.25743
3.05663
2.87268
2.70354
2.54937
2.40821
2.27969
2.16251
2.05579
1.95893
1.87102
1.79196
1.72342
1.6643
1.64084
1.64679
1.67474
1.74461
1.9234
2.28272
2.95796
3.38056
3.52326
3.5211
3.50402
3.45468
3.36813
3.28975
3.21998
3.15869
3.1038
3.05468
3.01047
2.96739
2.92576
2.88594
2.84815
2.81462
2.78708
2.76535
2.76213
2.76693
2.78286
2.81828
2.89144
2.9992
3.13623
3.29132
3.44774
3.56552
3.64839
3.64591
3.63151
3.60047
3.53676
3.46498
3.40703
3.36485
3.33867
3.32475
3.31767
3.31281
3.30551
3.29084
3.26887
3.24031
3.20718
3.1708
3.13286
3.09404
3.05533
3.01669
2.97863
2.94068
2.90324
2.86574
2.82869
2.79152
2.75487
2.71816
2.68207
2.646
2.61065
2.57537
2.54092
2.50644
2.47323
2.43958
2.40953
2.37928
6.31796
5.89299
5.52644
5.20177
4.89771
4.60823
4.33171
4.07008
3.82265
3.59045
3.37466
3.17434
2.9894
2.81894
2.66201
2.51814
2.38592
2.26508
2.15427
2.05339
1.96147
1.88
1.80963
1.76224
1.765
1.78336
1.84806
1.99526
2.32384
2.97724
3.46821
3.63758
3.63445
3.61185
3.54927
3.44733
3.35356
3.27371
3.20364
3.14072
3.08206
3.02666
2.97447
2.92621
2.88175
2.83876
2.79732
2.75782
2.7206
2.68764
2.6589
2.63781
2.62785
2.63089
2.64218
2.66891
2.72573
2.81759
2.93892
3.08894
3.24779
3.39
3.49501
3.5355
3.52618
3.49861
3.44127
3.37446
3.32288
3.28109
3.2521
3.23488
3.2241
3.21452
3.20246
3.18497
3.16201
3.13364
3.10151
3.06638
3.02987
2.9924
2.95502
2.91758
2.88074
2.84391
2.80768
2.77139
2.73566
2.69984
2.66461
2.62932
2.5947
2.56007
2.52624
2.49231
2.45966
2.42644
2.3969
2.36677
6.34676
5.98755
5.60779
5.27785
4.97685
4.69438
4.42536
4.16981
3.92857
3.70055
3.48666
3.28731
3.10197
2.93046
2.7717
2.62534
2.49038
2.36622
2.25216
2.14814
2.05338
1.97328
1.90435
1.89956
1.91335
1.9595
2.10751
2.39652
3.03011
3.59795
3.80233
3.79854
3.77111
3.69623
3.56414
3.44684
3.35114
3.2704
3.19945
3.13536
3.07371
3.01417
2.95653
2.90116
2.84938
2.80143
2.75597
2.71265
2.67135
2.63209
2.59549
2.56262
2.53344
2.51249
2.49672
2.49874
2.50685
2.52658
2.56716
2.64497
2.75424
2.89682
3.05644
3.22055
3.34582
3.42332
3.41586
3.39328
3.35018
3.29042
3.24085
3.19857
3.16774
3.1471
3.13202
3.11804
3.10238
3.08276
3.05907
3.03079
2.99954
2.96546
2.93022
2.89398
2.85788
2.82161
2.78595
2.75029
2.71529
2.68026
2.64587
2.61142
2.5776
2.54372
2.5106
2.4773
2.44528
2.41255
2.38357
2.35361
6.31297
6.1011
5.70748
5.36036
5.05773
4.77991
4.51588
4.26552
4.02872
3.80531
3.59429
3.3961
3.21101
3.03871
2.87864
2.73029
2.59301
2.46624
2.3497
2.24337
2.1502
2.0711
2.04342
2.05407
2.09726
2.22682
2.50733
3.11056
3.76818
4.01478
4.01036
3.97774
3.88842
3.73122
3.59006
3.47283
3.37411
3.28783
3.21019
3.13852
3.07211
3.0104
2.94907
2.88951
2.83161
2.77635
2.72498
2.67745
2.63219
2.58917
2.5484
2.50974
2.47395
2.44107
2.41232
2.3901
2.37182
2.37161
2.37576
2.38998
2.42097
2.48569
2.5845
2.71761
2.87824
3.05527
3.20408
3.30864
3.30482
3.28978
3.26037
3.20254
3.15527
3.11419
3.08318
3.05998
3.04127
3.02366
3.00533
2.98379
2.95963
2.93119
2.90078
2.8676
2.83351
2.79849
2.76366
2.72863
2.69422
2.65984
2.62612
2.59244
2.55939
2.52632
2.49397
2.46141
2.43009
2.39795
2.36958
2.33988
6.2206
6.09897
5.82398
5.45853
5.14245
4.86281
4.60449
4.35928
4.12561
3.90488
3.697
3.50079
3.31624
3.14382
2.98277
2.83306
2.69397
2.56542
2.44725
2.34225
2.25177
2.20418
2.2116
2.25027
2.36129
2.63372
3.20531
3.96384
4.26496
4.26076
4.22404
4.12024
3.9385
3.77461
3.63782
3.52093
3.41776
3.32427
3.23831
3.15828
3.0835
3.01304
2.94718
2.88557
2.8236
2.76399
2.70677
2.65281
2.60261
2.55569
2.51129
2.46913
2.42915
2.39141
2.35642
2.32397
2.29591
2.27221
2.2544
2.24841
2.2514
2.26219
2.28676
2.33919
2.42786
2.55074
2.71264
2.90016
3.07389
3.19183
3.20127
3.19085
3.16481
3.1128
3.0683
3.03013
2.99877
2.973
2.9513
2.93071
2.9104
2.88737
2.86283
2.83452
2.80471
2.77256
2.73968
2.70599
2.67248
2.63882
2.60573
2.57271
2.54032
2.50799
2.47637
2.44457
2.41401
2.38254
2.35486
2.32555
6.11639
6.06172
5.89569
5.56038
5.23387
4.9487
4.69075
4.44929
4.22005
4.00185
3.79565
3.6015
3.41827
3.24589
3.08447
2.9336
2.79355
2.66389
2.54729
2.44613
2.37946
2.38413
2.41719
2.51862
2.78045
3.33112
4.19267
4.55064
4.54665
4.50561
4.38567
4.17917
3.99275
3.83631
3.70206
3.58245
3.47338
3.37227
3.27801
3.18957
3.10655
3.02836
2.95498
2.88548
2.82113
2.7591
2.69832
2.6398
2.58395
2.53183
2.48343
2.43754
2.39414
2.3531
2.31422
2.27767
2.24356
2.21198
2.18444
2.16004
2.14278
2.13236
2.13441
2.14269
2.16227
2.20561
2.2839
2.39866
2.56228
2.75985
2.95333
3.07619
3.1017
3.0931
3.06945
3.02336
2.98235
2.94588
2.91367
2.88562
2.86173
2.83907
2.81737
2.79348
2.76861
2.7408
2.71157
2.6806
2.64902
2.61676
2.58464
2.55243
2.52069
2.48904
2.45808
2.42699
2.39716
2.3664
2.33942
2.31061
5.91561
5.95652
5.88158
5.68752
5.34697
5.04452
4.77996
4.53845
4.31211
4.09688
3.89207
3.69895
3.51718
3.34561
3.18405
3.03286
2.89255
2.76402
2.65397
2.56765
2.56963
2.59661
2.6908
2.93165
3.44933
4.42465
4.85864
4.85545
4.81138
4.67996
4.44756
4.2377
4.06199
3.91067
3.77548
3.6513
3.53585
3.4274
3.32549
3.22932
3.13876
3.0533
2.9728
2.89689
2.82548
2.75822
2.69554
2.63412
2.57496
2.51821
2.46442
2.41426
2.36745
2.32322
2.28131
2.24166
2.20409
2.16884
2.13575
2.10529
2.07819
2.05391
2.03684
2.02336
2.02485
2.03128
2.04753
2.08332
2.15255
2.26317
2.42734
2.63166
2.84555
2.96646
3.0036
2.99593
2.9749
2.93397
2.89645
2.86068
2.82767
2.79832
2.77315
2.74929
2.72659
2.70248
2.67731
2.65017
2.62178
2.59209
2.56184
2.53106
2.50036
2.46955
2.43932
2.40891
2.37978
2.3497
2.3234
2.29517
5.42852
5.83991
5.82016
5.71281
5.47257
5.1542
4.87547
4.62921
4.40287
4.1902
3.98862
3.79641
3.61414
3.44282
3.2818
3.13119
2.99219
2.87206
2.77153
2.76589
2.78984
2.87982
3.11877
3.63404
4.66648
5.17689
5.18791
5.14315
4.99905
4.74003
4.50644
4.311
4.14286
3.99213
3.85344
3.72372
3.60176
3.48643
3.37757
3.27448
3.17722
3.0852
2.99837
2.91635
2.83893
2.76599
2.6971
2.63261
2.5717
2.51195
2.4547
2.40008
2.34899
2.30124
2.25614
2.21347
2.17309
2.13492
2.09883
2.06495
2.03307
2.00383
1.97729
1.9537
1.9365
1.92148
1.9224
1.92751
1.94081
1.97189
2.03475
2.14443
2.30564
2.51335
2.74435
2.86016
2.90462
2.89837
2.88079
2.84621
2.81039
2.77505
2.74197
2.71231
2.68637
2.66209
2.63855
2.61442
2.5894
2.56305
2.53567
2.50727
2.4784
2.44903
2.4199
2.39038
2.36202
2.33265
2.30703
2.27939
4.37173
5.56496
5.7353
5.6891
5.55305
5.27183
4.97912
4.72442
4.49562
4.28302
4.08218
3.89157
3.71071
3.53954
3.37909
3.23012
3.09947
2.98985
2.97039
2.99346
3.08335
3.32575
3.86072
4.94486
5.53074
5.55629
5.50608
5.34408
5.05644
4.7975
4.58161
4.39608
4.22988
4.0765
3.93288
3.79724
3.66897
3.54728
3.43217
3.32297
3.21977
3.12195
3.02949
2.94195
2.85919
2.78096
2.70702
2.63736
2.57143
2.50994
2.45059
2.39333
2.33849
2.28653
2.23808
2.1924
2.14923
2.10839
2.06976
2.03322
1.99868
1.96622
1.93563
1.90759
1.8818
1.8591
1.84171
1.82666
1.82656
1.83006
1.84248
1.87031
1.9294
2.04051
2.20367
2.40786
2.64803
2.75889
2.80747
2.80279
2.78848
2.75934
2.72481
2.69037
2.65774
2.62826
2.60204
2.57753
2.55381
2.52985
2.50532
2.47982
2.45357
2.42641
2.39907
2.37097
2.34376
2.31532
2.29046
2.26351
2.75736
4.93573
5.57611
5.61588
5.55085
5.39072
5.10062
4.83071
4.59232
4.37667
4.17543
3.98546
3.80539
3.6356
3.47711
3.33674
3.21866
3.18705
3.20928
3.30028
3.54877
4.11
5.25153
5.91742
5.95906
5.90206
5.71778
5.39804
5.11145
4.87342
4.66976
4.48744
4.31919
4.16125
4.01198
3.87037
3.73609
3.60859
3.48782
3.37318
3.2647
3.16172
3.06427
2.97182
2.8843
2.80137
2.72288
2.64862
2.57842
2.51213
2.44964
2.39098
2.33363
2.2788
2.22661
2.17773
2.13173
2.08823
2.04706
2.00809
1.97122
1.93634
1.90339
1.87242
1.84321
1.81643
1.79163
1.7698
1.75269
1.7379
1.73709
1.74039
1.75197
1.77908
1.83714
1.94931
2.11233
2.32333
2.55877
2.66365
2.71433
2.71096
2.69885
2.67399
2.64079
2.60742
2.57564
2.54667
2.52062
2.49623
2.47273
2.44919
2.42541
2.4008
2.37586
2.34983
2.32436
2.29733
2.27355
2.24759
2.10203
3.51977
5.14106
5.50901
5.50176
5.42278
5.23809
4.95308
4.69881
4.4743
4.26974
4.07799
3.89928
3.73189
3.58214
3.45584
3.41488
3.43669
3.52927
3.78511
4.36571
5.55394
6.32186
6.38215
6.31893
6.11489
5.76274
5.44752
5.18648
4.96358
4.76448
4.5806
4.40795
4.24445
4.08932
3.9419
3.80203
3.66918
3.54331
3.42377
3.31059
3.20305
3.10119
3.00438
2.91264
2.82552
2.74293
2.66461
2.59043
2.52018
2.45383
2.39093
2.33205
2.27546
2.22093
2.16886
2.11993
2.0738
2.03013
1.98878
1.94963
1.91257
1.8775
1.84434
1.813
1.78357
1.75578
1.73029
1.70667
1.68571
1.66933
1.65497
1.65423
1.65754
1.66882
1.69662
1.7546
1.86809
2.02675
2.24833
2.47735
2.57396
2.62503
2.62274
2.61256
2.59069
2.5591
2.52703
2.49641
2.46825
2.44278
2.41881
2.39585
2.37289
2.3501
2.32635
2.30304
2.27801
2.25573
2.23137
1.62574
2.32886
4.18697
5.23871
5.42209
5.39542
5.2959
5.0804
4.81112
4.57364
4.36304
4.172
3.99451
3.83593
3.70135
3.65262
3.67469
3.77105
4.03948
4.65321
5.91896
6.76045
6.82998
6.75909
6.53323
6.14752
5.80342
5.51888
5.27643
5.05985
4.85992
4.67189
4.4938
4.32452
4.16371
4.01087
3.86587
3.72819
3.59772
3.4738
3.35637
3.24473
3.13889
3.03818
2.94266
2.85178
2.76556
2.68364
2.60593
2.53223
2.46238
2.39625
2.33365
2.27463
2.21866
2.16458
2.11287
2.06412
2.01805
1.9744
1.93304
1.89388
1.8568
1.8217
1.78849
1.75711
1.72743
1.69961
1.6733
1.64911
1.62682
1.6067
1.59142
1.57756
1.5777
1.58129
1.59248
1.6221
1.68242
1.79955
1.9546
2.17831
2.40129
2.48997
2.53975
2.53855
2.53022
2.51071
2.4808
2.45017
2.4209
2.39375
2.36913
2.34576
2.32363
2.30132
2.2799
2.25694
2.23652
2.21437
1.27937
1.73792
2.62696
4.60721
5.25104
5.33194
5.28742
5.16998
4.92991
4.68127
4.46295
4.26932
4.09935
3.95762
3.90041
3.92311
4.02469
4.30919
4.96303
6.31534
7.24712
7.3138
7.23048
6.9753
6.55365
6.17912
5.87047
5.60784
5.37339
5.15661
4.95268
4.75918
4.57531
4.40039
4.23426
4.07645
3.92679
3.78474
3.65008
3.52221
3.40095
3.28563
3.1762
3.07201
2.97308
2.87887
2.78941
2.70429
2.62347
2.5467
2.47383
2.40472
2.33917
2.27713
2.21832
2.16301
2.10947
2.05831
2.01002
1.96425
1.92085
1.8797
1.84071
1.80376
1.76877
1.73566
1.70432
1.67474
1.64674
1.6205
1.59574
1.57281
1.55202
1.5327
1.5188
1.50582
1.50654
1.51163
1.52223
1.55615
1.61639
1.73857
1.90276
2.12168
2.33055
2.41316
2.46002
2.45954
2.45224
2.43449
2.40641
2.37746
2.34981
2.32382
2.30026
2.27758
2.25668
2.23508
2.21621
2.19628
1.17403
1.36797
1.96808
3.19723
4.79345
5.20833
5.23419
5.17937
5.04649
4.80254
4.57526
4.38193
4.223
4.15831
4.18216
4.29088
4.59774
5.30536
6.77206
7.78197
7.83099
7.73056
7.44121
6.98259
6.5771
6.24342
5.95971
5.70609
5.47145
5.25029
5.04055
4.84102
4.65145
4.47123
4.30026
4.13794
3.98409
3.83809
3.69966
3.56818
3.44343
3.32478
3.21208
3.10476
3.00277
2.90561
2.81327
2.72534
2.6418
2.56233
2.48685
2.41514
2.34705
2.28243
2.22116
2.16298
2.10825
2.05548
2.00504
1.9574
1.91215
1.86919
1.82843
1.78977
1.75313
1.7184
1.68553
1.65442
1.62498
1.5972
1.5709
1.54621
1.52304
1.50132
1.48206
1.46375
1.45096
1.44008
1.44112
1.44617
1.46084
1.49314
1.5604
1.68355
1.85397
2.07329
2.26525
2.34156
2.38518
2.38583
2.37957
2.36288
2.33679
2.30967
2.28374
2.25896
2.23681
2.21512
2.19641
2.17803
1.08128
1.2212
1.48537
2.21407
3.74757
4.87798
5.14116
5.1361
5.0764
4.9347
4.70758
4.5132
4.42741
4.45207
4.56963
4.90249
5.6739
7.2711
8.34137
8.3688
8.24901
7.92535
7.43277
6.9966
6.6382
6.33324
6.05994
5.80612
5.56649
5.33883
5.12253
4.91691
4.72187
4.53672
4.36131
4.19489
4.03723
3.88761
3.74577
3.61098
3.48309
3.36141
3.24579
3.13565
3.03094
2.93114
2.83627
2.74586
2.65994
2.57813
2.50039
2.42643
2.35614
2.28933
2.22586
2.16562
2.10836
2.05443
2.00248
1.95306
1.90617
1.86161
1.81928
1.77907
1.74094
1.70476
1.67048
1.63797
1.60719
1.57807
1.55048
1.52445
1.49985
1.47663
1.4551
1.4346
1.41685
1.39989
1.38793
1.37991
1.38115
1.38767
1.4026
1.43987
1.5121
1.64422
1.81761
2.03133
2.20566
2.27715
2.31661
2.3179
2.31212
2.29682
2.2727
2.2475
2.22357
2.20028
2.18063
2.16192
1.04144
1.11583
1.23589
1.64001
2.38322
4.14031
4.9175
5.07122
5.05697
4.99524
4.85515
4.7219
4.74375
4.86795
5.22855
6.08001
7.83492
8.96493
8.95102
8.79365
8.41156
7.89509
7.4354
7.05461
6.72875
6.43517
6.16131
5.90177
5.65493
5.42016
5.1974
4.98614
4.78612
4.59657
4.41715
4.24702
4.0859
3.93295
3.78795
3.65021
3.51942
3.39498
3.27672
3.16406
3.05691
2.9548
2.85768
2.76513
2.67714
2.5933
2.5136
2.43771
2.36554
2.29688
2.23158
2.16949
2.1105
2.05441
2.00144
1.95052
1.90219
1.85623
1.81254
1.77101
1.73156
1.6941
1.65854
1.6248
1.59281
1.56248
1.53374
1.50654
1.48079
1.45643
1.43354
1.4118
1.39186
1.37281
1.35628
1.34136
1.32969
1.32533
1.32699
1.33458
1.35186
1.39285
1.47023
1.60809
1.7884
1.99758
2.15227
2.21903
2.25458
2.25655
2.2512
2.23712
2.21505
2.19202
2.17152
2.15124
1.02509
1.04977
1.13848
1.28674
1.73874
2.60452
4.36361
4.9169
5.02659
5.02276
5.00913
5.0338
5.17542
5.5807
6.5391
8.48383
9.59867
9.56756
9.36603
8.91322
8.37032
7.89148
7.49047
7.14429
6.83007
6.53524
6.25488
5.98763
5.73348
5.4923
5.26399
5.0479
4.84359
4.65017
4.46718
4.29373
4.12946
3.97356
3.82573
3.68525
3.55185
3.42491
3.30425
3.18933
3.08006
2.97594
2.87692
2.78255
2.69281
2.60729
2.52593
2.4484
2.37467
2.30444
2.23764
2.17403
2.11354
2.05598
2.00132
1.94934
1.8998
1.85263
1.80777
1.76508
1.72449
1.6859
1.64924
1.61441
1.58134
1.54994
1.52016
1.49192
1.46517
1.43981
1.41589
1.39321
1.37201
1.35189
1.33338
1.31617
1.30053
1.28813
1.27708
1.27614
1.27832
1.28816
1.30709
1.35416
1.44013
1.58318
1.76687
1.96948
2.10628
2.16872
2.20025
2.20257
2.1977
2.18493
2.16618
2.14691
1.01148
1.03104
1.06364
1.17129
1.37185
1.93334
3.11004
4.49066
4.9274
5.0558
5.16485
5.41681
5.95462
7.10035
9.31242
10.3352
10.2699
10.0019
9.44007
8.86535
8.37279
7.957
7.59057
7.25302
6.9339
6.62955
6.3395
6.06392
5.80297
5.55622
5.32324
5.10306
4.89507
4.69822
4.51202
4.33554
4.16837
4.00974
3.85929
3.71635
3.58054
3.45135
3.3285
3.21157
3.10036
2.99442
2.89365
2.79767
2.70638
2.6194
2.53669
2.45789
2.38288
2.3114
2.24335
2.1785
2.11678
2.05802
2.00207
1.94899
1.89835
1.85015
1.80427
1.76063
1.7191
1.6796
1.64202
1.60629
1.57231
1.54002
1.50933
1.48018
1.45253
1.4263
1.40149
1.37798
1.35588
1.33495
1.31537
1.29707
1.27988
1.26468
1.25018
1.23987
1.23115
1.23195
1.2354
1.24843
1.27054
1.32485
1.4182
1.56368
1.75265
1.94851
2.06807
2.12678
2.15413
2.15805
2.1542
2.14484
1.00705
1.01422
1.03836
1.07948
1.2116
1.45963
2.12406
3.48916
4.62685
5.04177
5.43207
6.21089
7.73728
10.2544
11.1474
11.0407
10.696
10.0008
9.37138
8.86309
8.43712
8.05521
7.69564
7.35101
7.02073
6.70582
6.40718
6.12496
5.85882
5.60783
5.37118
5.14769
4.93665
4.73697
4.54809
4.36909
4.19954
4.03864
3.88601
3.741
3.60334
3.47246
3.34802
3.22956
3.11684
3.00954
2.90744
2.81024
2.71776
2.62967
2.54584
2.46595
2.3899
2.3174
2.24836
2.18253
2.11985
2.06011
2.00324
1.94912
1.89758
1.84849
1.8018
1.75734
1.71504
1.67477
1.63643
1.59994
1.5652
1.53215
1.50071
1.47083
1.44245
1.41553
1.39002
1.36582
1.34298
1.32138
1.30106
1.28202
1.26405
1.24762
1.23202
1.21846
1.20618
1.19665
1.19253
1.19367
1.19965
1.21136
1.24341
1.30259
1.40759
1.55459
1.74631
1.93664
2.03776
2.09627
2.11802
2.13312
1.0032
1.00859
1.01725
1.04663
1.09615
1.25576
1.55425
2.32897
3.90286
4.9736
6.03588
8.15711
11.337
12.1259
11.9598
11.476
10.6048
9.91345
9.38041
8.94303
8.54574
8.16434
7.7937
7.43609
7.09469
6.7713
6.46638
6.17932
5.90919
5.65467
5.41475
5.18822
4.97428
4.77189
4.58046
4.39908
4.22727
4.06427
3.90966
3.76281
3.62333
3.49074
3.36466
3.24477
3.13071
3.0222
2.91896
2.82071
2.7272
2.63817
2.5534
2.47263
2.3957
2.32235
2.2525
2.18587
2.12242
2.06191
2.00432
1.94938
1.89712
1.84732
1.79998
1.7549
1.71201
1.67115
1.63224
1.59517
1.55986
1.52623
1.49422
1.46376
1.4348
1.40728
1.38116
1.3564
1.33298
1.31084
1.28997
1.27036
1.25188
1.23473
1.21861
1.20384
1.19038
1.17806
1.16867
1.16026
1.16046
1.1626
1.16955
1.18607
1.22175
1.29185
1.40481
1.55839
1.74382
1.93673
2.01554
2.09511
1.00177
1.0047
1.00947
1.02537
1.05164
1.13829
1.29292
1.75185
2.64823
4.72574
7.58494
12.3336
13.1163
12.8485
12.1582
11.2429
10.5404
9.99028
9.52567
9.08617
8.6637
8.25683
7.86715
7.49662
7.14653
6.81696
6.50727
6.21624
5.94261
5.68494
5.44221
5.21318
4.99703
4.79269
4.59949
4.41653
4.24325
4.07893
3.92307
3.77511
3.63459
3.50111
3.3742
3.2536
3.13886
3.02977
2.92594
2.82717
2.73312
2.64358
2.55829
2.47699
2.39954
2.32565
2.25526
2.18808
2.1241
2.06303
2.00491
1.94943
1.8967
1.84642
1.79856
1.75295
1.70953
1.66816
1.62878
1.59127
1.55554
1.52152
1.4891
1.45825
1.42889
1.40099
1.37447
1.34933
1.3255
1.30297
1.28169
1.26168
1.24284
1.22523
1.20878
1.19348
1.17945
1.1664
1.15503
1.14478
1.13692
1.13314
1.13394
1.13759
1.14689
1.16816
1.21151
1.29858
1.39747
1.58925
1.74752
1.97912
1.00132
1.00266
1.00732
1.01446
1.0418
1.08009
1.2466
1.52243
2.5112
4.83211
10.7493
13.7802
13.5014
12.7606
11.8999
11.2191
10.6552
10.1533
9.66926
9.19585
8.74191
8.31436
7.91347
7.53731
7.18413
6.8523
6.54041
6.24697
5.9709
5.71089
5.46598
5.23496
5.01699
4.81101
4.61631
4.43198
4.25742
4.09194
3.93498
3.78602
3.64455
3.5102
3.38246
3.26111
3.14566
3.03593
2.93148
2.83215
2.73757
2.64755
2.56179
2.48009
2.40226
2.32802
2.2573
2.18979
2.1255
2.06412
2.00569
1.94992
1.89685
1.84623
1.79804
1.7521
1.70836
1.66669
1.62698
1.58919
1.55314
1.51885
1.48614
1.45502
1.42538
1.39719
1.3704
1.34496
1.32085
1.29804
1.27648
1.25618
1.23708
1.21919
1.20248
1.18692
1.17256
1.15928
1.14724
1.13639
1.12675
1.11937
1.11331
1.11368
1.11552
1.12144
1.13334
1.1617
1.21297
1.3178
1.44092
1.69988
1.00111
1.00224
1.00623
1.01242
1.03663
1.06843
1.22876
1.461
2.52398
4.97683
11.6002
13.0408
12.8231
12.3769
11.9084
11.4106
10.8746
10.3178
9.77562
9.26627
8.79294
8.3532
7.94425
7.56295
7.20615
6.87136
6.55682
6.26104
5.98289
5.72111
5.4747
5.24244
5.02344
4.81659
4.62113
4.43615
4.26102
4.09503
3.93762
3.78827
3.64645
3.51181
3.38381
3.26223
3.14657
3.03667
2.93206
2.83259
2.73786
2.64771
2.56181
2.47998
2.402
2.32762
2.25675
2.1891
2.12466
2.06313
2.00456
1.94864
1.89543
1.84467
1.79637
1.75033
1.70648
1.66473
1.62492
1.58704
1.55089
1.51653
1.48371
1.45253
1.4228
1.39454
1.36766
1.34214
1.31795
1.29504
1.2734
1.253
1.2338
1.21582
1.19901
1.18336
1.1689
1.1555
1.14337
1.13219
1.12245
1.11353
1.10688
1.10116
1.10152
1.10323
1.10841
1.11831
1.14266
1.18768
1.27849
1.46999
3.06392
1.55572
1.04738
0.942491
0.96824
1.047
1.21278
1.34496
1.38604
1.3844
1.37913
1.37929
1.38126
1.38658
1.39739
1.40524
1.40782
1.40764
1.40702
1.40564
1.40382
1.40227
1.40089
1.3992
1.3971
1.39489
1.39411
1.39456
1.39658
1.40281
1.41917
1.45922
1.55344
1.7708
2.27363
3.29727
3.69946
3.67798
3.70178
3.7229
3.79137
3.90608
4.05294
4.19836
4.32318
4.41654
4.50346
4.55913
4.5939
4.61213
4.61788
4.6153
4.60548
4.58436
4.55624
4.52464
4.49095
4.45446
4.41538
4.37375
4.32967
4.28363
4.23575
4.18634
4.13581
4.08394
4.03159
3.97875
3.9256
3.87198
3.81857
3.76514
3.71177
3.65854
3.60548
3.55278
3.50036
3.44853
3.39716
3.3464
3.29627
3.24684
3.19802
3.1499
3.10236
3.05561
3.00944
2.96405
2.91927
2.87547
2.83225
2.78991
2.74817
2.70743
2.66752
2.62899
2.592
2.55784
2.52788
2.50681
3.71843
2.31611
1.71693
1.46598
1.34999
1.27844
1.26402
1.27193
1.29406
1.33967
1.38503
1.4038
1.40351
1.4022
1.4001
1.40043
1.40156
1.40405
1.4068
1.40678
1.40646
1.40549
1.40342
1.40019
1.39707
1.39438
1.39272
1.39309
1.39489
1.40035
1.4142
1.44762
1.52649
1.71048
2.13816
3.09233
3.71968
3.70316
3.6991
3.72602
3.79488
3.89536
4.02276
4.16686
4.29384
4.39648
4.47939
4.53679
4.57365
4.59343
4.60072
4.59937
4.59321
4.57749
4.54878
4.51617
4.48261
4.44661
4.40837
4.36715
4.32368
4.27791
4.23051
4.18142
4.13122
4.07982
4.02774
3.97511
3.92219
3.86894
3.81565
3.76236
3.70911
3.65599
3.60304
3.55043
3.49813
3.44635
3.39505
3.34438
3.29425
3.24484
3.19606
3.14796
3.10052
3.0539
3.00805
2.96286
2.91839
2.87441
2.83126
2.78877
2.7472
2.70635
2.66656
2.6278
2.59074
2.55604
2.52546
2.50373
4.54542
3.24224
2.42437
1.9081
1.57868
1.37482
1.25762
1.24501
1.2524
1.27385
1.31851
1.36075
1.3879
1.40075
1.40314
1.40283
1.402
1.40143
1.40151
1.40151
1.4014
1.40106
1.40023
1.3985
1.39579
1.39289
1.39003
1.38991
1.39067
1.39386
1.40257
1.42608
1.47864
1.60943
1.8981
2.56402
3.61147
3.77481
3.79959
3.84115
3.90291
3.98075
4.06965
4.16965
4.2664
4.36227
4.44294
4.5023
4.5417
4.5633
4.57168
4.57093
4.56721
4.55691
4.53488
4.50241
4.46865
4.43325
4.39563
4.35526
4.31255
4.26753
4.22072
4.17228
4.12261
4.07188
4.02034
3.96822
3.9157
3.8629
3.80992
3.75689
3.70389
3.65098
3.59827
3.54581
3.49377
3.44212
3.39108
3.34057
3.2907
3.24145
3.193
3.1452
3.09818
3.0516
3.00576
2.96053
2.9161
2.87223
2.82923
2.78682
2.74535
2.70451
2.66476
2.62587
2.5886
2.55334
2.52197
2.49845
4.99809
3.82353
2.9537
2.34794
1.94206
1.66924
1.49828
1.39167
1.32999
1.31426
1.31767
1.32906
1.35327
1.38141
1.40082
1.41087
1.4108
1.41009
1.40834
1.40524
1.40331
1.40216
1.40128
1.40028
1.39852
1.39597
1.39276
1.39011
1.39042
1.39195
1.3979
1.411
1.44855
1.52973
1.73207
2.18667
3.2062
3.79431
4.03505
4.12457
4.16763
4.19623
4.20538
4.21619
4.24321
4.29866
4.36829
4.43237
4.48393
4.51572
4.53039
4.53193
4.52989
4.52346
4.50886
4.48062
4.44758
4.41248
4.37555
4.33642
4.29503
4.25132
4.20564
4.15825
4.10952
4.05966
4.00897
3.95758
3.90573
3.85348
3.80104
3.74843
3.69586
3.64329
3.59097
3.53883
3.48716
3.43583
3.38508
3.33488
3.28549
3.2366
3.18841
3.14074
3.09385
3.04744
3.00182
2.95674
2.91252
2.86882
2.82602
2.78371
2.74237
2.70157
2.66188
2.6229
2.58546
2.54969
2.51737
2.49204
5.27096
4.2438
3.40834
2.77522
2.31291
1.97671
1.73297
1.55883
1.4372
1.36078
1.32043
1.32044
1.32386
1.33372
1.35409
1.37434
1.38908
1.39825
1.40087
1.40054
1.39948
1.39724
1.39456
1.39226
1.39029
1.38848
1.38709
1.38523
1.38537
1.38646
1.38895
1.39948
1.41799
1.47799
1.59385
1.88941
2.50742
3.68457
4.37392
4.59499
4.59017
4.54682
4.43769
4.30837
4.24871
4.25246
4.27372
4.3237
4.38797
4.43742
4.46833
4.48239
4.48219
4.4794
4.47111
4.45268
4.4219
4.38684
4.35013
4.31194
4.27195
4.22988
4.18584
4.13998
4.09259
4.04391
3.99427
3.9438
3.89276
3.84121
3.78941
3.73737
3.68534
3.63323
3.58143
3.52972
3.47852
3.42775
3.37767
3.32799
3.27901
3.23042
3.18253
3.13508
3.08844
3.04225
2.99691
2.95202
2.90806
2.86452
2.82195
2.7798
2.73866
2.69799
2.65841
2.61947
2.58193
2.54584
2.51296
2.48608
5.45694
4.56565
3.79002
3.16119
2.6702
2.29315
2.00588
1.78922
1.62705
1.5101
1.42543
1.37172
1.34284
1.34037
1.34279
1.35001
1.36509
1.38179
1.39464
1.40286
1.40425
1.40384
1.4026
1.3999
1.39592
1.39225
1.38918
1.38641
1.3852
1.38566
1.38738
1.3935
1.40698
1.44367
1.52381
1.71988
2.16315
3.18024
4.68707
5.20023
5.14484
4.98543
4.69385
4.45077
4.29452
4.22904
4.22114
4.22825
4.2539
4.30689
4.35727
4.39482
4.41429
4.41818
4.41579
4.40742
4.38853
4.3565
4.32016
4.28218
4.24293
4.20231
4.16022
4.11646
4.07102
4.02406
3.97588
3.92663
3.87663
3.82596
3.77496
3.72361
3.67225
3.6207
3.56953
3.51867
3.46828
3.41817
3.36863
3.31936
3.27075
3.22245
3.17491
3.12773
3.08142
3.03548
2.99047
2.94583
2.90216
2.85887
2.81656
2.77466
2.73374
2.69329
2.65384
2.61502
2.57747
2.54118
2.50797
2.47994
5.58462
4.8101
4.10288
3.49784
2.99978
2.59866
2.27955
2.02734
1.82856
1.67353
1.55326
1.46483
1.39991
1.36188
1.34197
1.34205
1.34413
1.34993
1.36188
1.3744
1.38372
1.39015
1.3907
1.39039
1.3894
1.38731
1.3842
1.38124
1.37965
1.38002
1.38162
1.38636
1.39808
1.4269
1.49252
1.64904
2.01108
2.86553
4.72893
5.84256
5.75821
5.50571
5.07215
4.70654
4.44697
4.28682
4.20557
4.17939
4.17688
4.18551
4.21157
4.26226
4.3034
4.33326
4.34419
4.34281
4.33631
4.32042
4.28872
4.25207
4.21263
4.1723
4.13136
4.08935
4.04596
4.00105
3.95477
3.9071
3.8584
3.80878
3.75866
3.70808
3.65747
3.60692
3.55664
3.50649
3.45682
3.40725
3.35824
3.30939
3.26124
3.21332
3.16621
3.1194
3.07347
3.02787
2.9832
2.9389
2.89552
2.85257
2.81052
2.76894
2.72824
2.68807
2.64879
2.61016
2.57268
2.53633
2.50298
2.47417
5.6777
4.9957
4.35235
3.77991
3.28965
2.87959
2.54174
2.26558
2.04107
1.85971
1.71378
1.59808
1.50782
1.44057
1.39123
1.36296
1.3473
1.34738
1.34911
1.35398
1.36404
1.37527
1.38408
1.39068
1.39093
1.3904
1.38889
1.38577
1.38232
1.38248
1.3836
1.3892
1.39934
1.43143
1.49068
1.64487
1.95497
2.66504
4.13882
5.90539
5.98406
5.84972
5.51914
5.11687
4.74785
4.48611
4.3045
4.19272
4.14256
4.12418
4.12492
4.13449
4.15987
4.20732
4.23854
4.25928
4.26018
4.25654
4.2448
4.21934
4.18253
4.14223
4.10103
4.05916
4.01677
3.97354
3.9293
3.88355
3.8366
3.7884
3.73937
3.68988
3.64043
3.59083
3.5415
3.49207
3.44308
3.39408
3.34567
3.29736
3.24974
3.20233
3.15571
3.10938
3.06387
3.01873
2.97443
2.93056
2.88754
2.84498
2.80325
2.76203
2.72162
2.68176
2.64273
2.60433
2.567
2.53068
2.49731
2.46801
5.74508
5.13907
4.55375
4.0171
3.54292
3.13408
2.78718
2.49591
2.2527
2.05079
1.88342
1.74564
1.633
1.54205
1.4706
1.41679
1.37792
1.3565
1.34565
1.34583
1.34735
1.35139
1.3596
1.36789
1.37381
1.37783
1.37974
1.3797
1.37974
1.3805
1.38275
1.39095
1.4078
1.45169
1.5413
1.74103
2.14135
2.94144
3.70295
4.69577
5.52072
5.67658
5.61646
5.42995
5.08875
4.79998
4.52426
4.32922
4.19605
4.1138
4.08125
4.0655
4.06734
4.07815
4.10374
4.14084
4.16252
4.1723
4.17054
4.16313
4.14564
4.11125
4.07219
4.02962
3.98672
3.94383
3.90078
3.85668
3.81165
3.76519
3.71811
3.67003
3.62183
3.57321
3.52473
3.47604
3.42773
3.37941
3.33163
3.28398
3.23696
3.19017
3.14408
3.09832
3.05329
3.00866
2.96481
2.9214
2.87878
2.83665
2.79529
2.75445
2.71438
2.67485
2.63612
2.59796
2.56087
2.52462
2.49136
2.46174
5.79763
5.25188
4.717
4.21581
3.76183
3.36071
3.012
2.71253
2.45694
2.24014
2.05659
1.90192
1.77194
1.66362
1.57429
1.50165
1.44515
1.40175
1.37075
1.35342
1.34462
1.34481
1.34617
1.34976
1.35708
1.36503
1.37167
1.37601
1.37849
1.38194
1.38946
1.40509
1.4405
1.51494
1.67445
1.99847
2.64795
3.19884
3.52435
3.92009
4.43972
5.01688
5.35026
5.32976
5.24005
5.04628
4.78993
4.57223
4.36217
4.21133
4.10998
4.0467
4.02093
4.00416
4.00606
4.01508
4.03526
4.06187
4.07674
4.0776
4.07425
4.06318
4.03919
4.00053
3.95828
3.91462
3.87098
3.82719
3.78336
3.73869
3.69349
3.64725
3.60055
3.55313
3.50563
3.4578
3.41025
3.36267
3.31558
3.26865
3.22231
3.17622
3.13076
3.08563
3.04119
2.99713
2.95381
2.91092
2.86879
2.82712
2.78623
2.7458
2.70616
2.66698
2.62864
2.59075
2.55397
2.51785
2.48476
2.4549
5.83729
5.34166
4.85081
4.38343
3.95188
3.56273
3.21752
2.91517
2.65226
2.42516
2.22945
2.0615
1.91748
1.79461
1.69012
1.60202
1.52882
1.46888
1.42186
1.38615
1.36122
1.34713
1.34064
1.34087
1.34221
1.34551
1.35219
1.36007
1.36867
1.37832
1.39409
1.42582
1.49301
1.63097
1.91557
2.48955
3.08025
3.33927
3.45794
3.60001
3.81347
4.11451
4.53549
4.86234
5.02041
5.0001
4.92293
4.75339
4.56596
4.40181
4.24001
4.11571
4.03319
3.97917
3.95416
3.93512
3.9368
3.94331
3.9572
3.97566
3.98291
3.98139
3.97503
3.95924
3.92742
3.88674
3.84234
3.79763
3.75385
3.71012
3.66628
3.62167
3.57658
3.53063
3.48442
3.43769
3.39111
3.34441
3.29814
3.25199
3.2064
3.16103
3.11629
3.07182
3.02803
2.98458
2.94185
2.8995
2.85792
2.81673
2.77634
2.73635
2.69717
2.65837
2.62044
2.58288
2.54644
2.51052
2.47767
2.44765
5.87021
5.41434
4.96143
4.52552
4.11685
3.74216
3.4039
3.10257
2.83615
2.60237
2.39775
2.2195
2.06426
1.9296
1.81292
1.71235
1.6262
1.55316
1.49224
1.44239
1.40334
1.37371
1.35331
1.34152
1.33797
1.3387
1.34135
1.34742
1.35978
1.37846
1.40854
1.46953
1.59287
1.84543
2.35409
3.00879
3.30934
3.40168
3.43287
3.47052
3.53343
3.64197
3.81529
4.05053
4.37112
4.61699
4.7457
4.73018
4.67254
4.54548
4.39063
4.25973
4.13407
4.02396
3.94985
3.904
3.87672
3.85744
3.85862
3.86329
3.87306
3.88556
3.88531
3.8823
3.87292
3.85188
3.81319
3.77012
3.72581
3.68145
3.63766
3.59373
3.5498
3.5052
3.46041
3.41507
3.36978
3.32423
3.27901
3.2338
3.18908
3.14451
3.10053
3.05677
3.01367
2.97086
2.92876
2.88699
2.84599
2.80535
2.76549
2.726
2.68729
2.64895
2.61143
2.57426
2.53818
2.50251
2.46993
2.43976
5.89539
5.47315
5.05501
4.64881
4.26268
3.90345
3.57432
3.27656
3.00953
2.77171
2.56089
2.37462
2.21051
2.06608
1.93939
1.82833
1.73151
1.64732
1.57493
1.51311
1.46157
1.41936
1.38631
1.36207
1.34496
1.34079
1.34217
1.34685
1.35971
1.38446
1.43861
1.54481
1.76546
2.20634
2.8828
3.28028
3.40121
3.42085
3.42006
3.41537
3.40715
3.41556
3.44995
3.53053
3.68862
3.90457
4.18272
4.3896
4.51074
4.49999
4.46001
4.37503
4.23873
4.12878
4.02749
3.92956
3.86339
3.8224
3.79412
3.77408
3.77505
3.77862
3.78494
3.78927
3.7878
3.78197
3.76771
3.73832
3.69845
3.65435
3.61012
3.5659
3.5221
3.47813
3.4344
3.39039
3.34651
3.30236
3.25839
3.21432
3.17057
3.12691
3.08371
3.04074
2.99833
2.95622
2.91476
2.87363
2.83321
2.79315
2.75382
2.71486
2.67664
2.63879
2.60171
2.56496
2.52928
2.4939
2.46164
2.43135
5.92499
5.531
5.14072
4.75905
4.39348
4.04917
3.7298
3.43706
3.17123
2.93152
2.71654
2.52442
2.35327
2.20109
2.06605
1.94636
1.84063
1.74726
1.66549
1.59393
1.53221
1.47953
1.43546
1.40021
1.373
1.35818
1.35947
1.36503
1.38409
1.42087
1.51017
1.68535
2.04923
2.71486
3.20996
3.39189
3.42422
3.42193
3.40986
3.38004
3.32383
3.27794
3.27732
3.28811
3.32471
3.40619
3.56019
3.75214
3.98276
4.16399
4.29102
4.2903
4.27025
4.21661
4.10802
4.00588
3.91666
3.83789
3.77577
3.73462
3.70712
3.68859
3.68794
3.68926
3.69238
3.69188
3.68872
3.67957
3.6596
3.62268
3.58125
3.53759
3.49361
3.44964
3.40638
3.36337
3.32075
3.27809
3.23554
3.19288
3.15036
3.10784
3.0656
3.02353
2.98189
2.94053
2.89973
2.85927
2.81945
2.78001
2.74124
2.70284
2.66515
2.62779
2.5912
2.55487
2.51964
2.48455
2.45267
2.42232
5.96348
5.5895
5.22183
4.8609
4.51285
4.18239
3.87236
3.58527
3.32167
3.08162
2.864
2.66788
2.49128
2.33305
2.19121
2.06439
1.95129
1.85022
1.76067
1.68099
1.61095
1.54965
1.4964
1.45247
1.41569
1.39557
1.39755
1.40786
1.43409
1.50356
1.64248
1.94244
2.5373
3.10073
3.36259
3.42308
3.42199
3.41139
3.38212
3.32226
3.2592
3.20645
3.16875
3.14633
3.14964
3.16383
3.20044
3.27598
3.4077
3.57362
3.76887
3.94308
4.07005
4.10697
4.09582
4.06166
3.98647
3.8904
3.8121
3.74355
3.68444
3.64446
3.61732
3.60009
3.59658
3.59697
3.59683
3.5951
3.58902
3.57418
3.54394
3.50515
3.46339
3.42037
3.37762
3.33526
3.29352
3.25201
3.21077
3.16951
3.12835
3.08712
3.04606
3.00503
2.96433
2.9238
2.88376
2.84398
2.80482
2.76597
2.72781
2.68995
2.65282
2.61595
2.57989
2.54399
2.50925
2.47447
2.44302
2.41264
6.02194
5.65397
5.30101
4.95758
4.6238
4.30418
4.00285
3.72149
3.46096
3.22188
3.00299
2.80436
2.62392
2.46095
2.3139
2.18113
2.06202
1.95443
1.85836
1.77184
1.69482
1.62652
1.56561
1.51583
1.47078
1.45637
1.4605
1.48052
1.52424
1.64902
1.88648
2.40008
3.0068
3.33281
3.42771
3.42667
3.41567
3.38541
3.32343
3.25766
3.20115
3.15185
3.10819
3.0701
3.04207
3.02231
3.02506
3.03685
3.06632
3.12724
3.23777
3.38324
3.55264
3.72451
3.85132
3.93573
3.93039
3.91093
3.87169
3.79438
3.71333
3.64552
3.5924
3.55237
3.5234
3.50883
3.50673
3.50638
3.50476
3.4997
3.48767
3.46257
3.42875
3.39011
3.34936
3.30782
3.26647
3.22539
3.18483
3.14451
3.10453
3.06457
3.02482
2.98498
2.94542
2.90585
2.86671
2.82769
2.78926
2.75102
2.71349
2.67617
2.63962
2.60324
2.56772
2.53227
2.49804
2.46361
2.4326
2.40224
6.10634
5.72373
5.37719
5.04501
4.72375
4.41545
4.12205
3.84688
3.58972
3.35266
3.13381
2.93372
2.75101
2.58435
2.43343
2.29579
2.17175
2.05876
1.95707
1.86487
1.78191
1.70779
1.64136
1.58701
1.54124
1.542
1.55317
1.58442
1.68483
1.87891
2.31414
2.9603
3.3328
3.45623
3.45505
3.44244
3.40542
3.33078
3.25836
3.19798
3.14758
3.10127
3.05769
3.01622
2.97726
2.94245
2.91571
2.89404
2.89579
2.90377
2.92521
2.97137
3.06339
3.18892
3.34162
3.50507
3.6473
3.74946
3.78684
3.77877
3.7523
3.69409
3.61912
3.55088
3.49555
3.45332
3.42784
3.41715
3.41356
3.41156
3.40722
3.39771
3.37875
3.35044
3.3164
3.27873
3.23936
3.19917
3.15911
3.11923
3.07991
3.04079
3.0021
2.96339
2.92501
2.88652
2.84843
2.8103
2.7727
2.73517
2.69831
2.66157
2.62559
2.58974
2.55474
2.51977
2.48603
2.45198
2.42144
2.39111
6.19149
5.79935
5.45036
5.12565
4.81424
4.51615
4.23136
3.96255
3.70976
3.47486
3.25743
3.05663
2.87268
2.70354
2.54937
2.40821
2.27969
2.16251
2.05579
1.95893
1.87102
1.79196
1.72343
1.66429
1.64083
1.64678
1.67473
1.74448
1.9234
2.28268
2.95824
3.38054
3.52317
3.52103
3.50396
3.45464
3.36812
3.28975
3.21999
3.1587
3.10381
3.05469
3.01047
2.9674
2.92578
2.88597
2.84818
2.81465
2.78711
2.76538
2.76215
2.76695
2.78287
2.81829
2.89144
2.9992
3.13623
3.29132
3.44774
3.56552
3.64839
3.64591
3.63151
3.60047
3.53676
3.46498
3.40703
3.36485
3.33867
3.32475
3.31767
3.31281
3.30551
3.29084
3.26887
3.24031
3.20718
3.17079
3.13286
3.09404
3.05533
3.01669
2.97863
2.94068
2.90324
2.86574
2.82869
2.79152
2.75487
2.71816
2.68207
2.646
2.61065
2.57537
2.54092
2.50644
2.47323
2.43958
2.40953
2.37928
6.31796
5.89299
5.52645
5.20177
4.89771
4.60823
4.33171
4.07008
3.82265
3.59045
3.37466
3.17433
2.9894
2.81894
2.66201
2.51814
2.38592
2.26508
2.15427
2.05338
1.96148
1.87998
1.80965
1.76217
1.76492
1.78401
1.84594
1.99697
2.32221
2.97777
3.46839
3.63753
3.6344
3.61182
3.54929
3.44735
3.35359
3.27375
3.20367
3.14076
3.0821
3.0267
2.97451
2.92625
2.88179
2.8388
2.79737
2.75786
2.72063
2.68767
2.65892
2.63783
2.62786
2.63089
2.64219
2.66891
2.72573
2.81758
2.93891
3.08893
3.24778
3.39
3.49501
3.53549
3.52618
3.49861
3.44127
3.37446
3.32288
3.28109
3.2521
3.23488
3.2241
3.21452
3.20246
3.18497
3.16201
3.13364
3.1015
3.06638
3.02987
2.9924
2.95502
2.91758
2.88074
2.84391
2.80768
2.77139
2.73566
2.69984
2.6646
2.62932
2.5947
2.56007
2.52624
2.49231
2.45966
2.42644
2.3969
2.36677
6.34676
5.98755
5.60779
5.27785
4.97685
4.69438
4.42536
4.16981
3.92857
3.70056
3.48666
3.28731
3.10197
2.93047
2.7717
2.62534
2.49038
2.36622
2.25217
2.14813
2.05339
1.97326
1.90439
1.89947
1.91328
1.95936
2.10775
2.39647
3.03023
3.59824
3.80246
3.79865
3.7712
3.69628
3.56422
3.4469
3.35119
3.27045
3.1995
3.13541
3.07377
3.01423
2.95658
2.90122
2.84943
2.80149
2.75602
2.71269
2.67138
2.63211
2.59551
2.56263
2.53345
2.5125
2.49672
2.49873
2.50685
2.52658
2.56716
2.64497
2.75424
2.89682
3.05644
3.22055
3.34582
3.42332
3.41586
3.39328
3.35018
3.29042
3.24085
3.19857
3.16774
3.1471
3.13202
3.11804
3.10238
3.08276
3.05907
3.03079
2.99954
2.96546
2.93022
2.89398
2.85788
2.8216
2.78595
2.75029
2.71529
2.68026
2.64587
2.61141
2.5776
2.54372
2.5106
2.4773
2.44528
2.41255
2.38357
2.35361
6.31297
6.1011
5.70748
5.36036
5.05773
4.77991
4.51588
4.26552
4.02871
3.80531
3.59428
3.39611
3.211
3.03872
2.87864
2.73029
2.59301
2.46624
2.3497
2.24337
2.1502
2.0711
2.04341
2.05405
2.09735
2.22658
2.5075
3.11043
3.76808
4.01478
4.01038
3.97778
3.88848
3.73128
3.59013
3.47291
3.37419
3.28791
3.21027
3.1386
3.07218
3.01046
2.94914
2.88957
2.83166
2.77639
2.72502
2.67749
2.63222
2.58919
2.54841
2.50975
2.47395
2.44106
2.41232
2.3901
2.37181
2.37161
2.37575
2.38997
2.42096
2.48568
2.5845
2.71761
2.87824
3.05527
3.20408
3.30863
3.30482
3.28978
3.26037
3.20254
3.15527
3.11419
3.08318
3.05998
3.04127
3.02366
3.00533
2.98379
2.95962
2.93119
2.90078
2.8676
2.83351
2.79849
2.76365
2.72863
2.69422
2.65984
2.62612
2.59244
2.55939
2.52632
2.49396
2.46141
2.43008
2.39795
2.36958
2.33988
6.2206
6.09897
5.82398
5.45853
5.14245
4.86281
4.60449
4.35928
4.1256
3.90489
3.69699
3.5008
3.31624
3.14382
2.98277
2.83306
2.69397
2.56542
2.44725
2.34225
2.25177
2.20418
2.2116
2.25026
2.36129
2.63372
3.20531
3.96381
4.26495
4.26075
4.22404
4.12024
3.93851
3.77464
3.63786
3.52099
3.41783
3.32435
3.2384
3.15837
3.08359
3.01312
2.94726
2.88563
2.82365
2.76404
2.7068
2.65283
2.60263
2.5557
2.5113
2.46913
2.42915
2.39141
2.35642
2.32397
2.29591
2.2722
2.25439
2.24841
2.2514
2.26218
2.28676
2.33919
2.42786
2.55073
2.71264
2.90016
3.07389
3.19183
3.20127
3.19085
3.16481
3.1128
3.0683
3.03013
2.99877
2.973
2.9513
2.93071
2.9104
2.88737
2.86283
2.83452
2.8047
2.77256
2.73968
2.70598
2.67248
2.63882
2.60573
2.57271
2.54031
2.50799
2.47637
2.44457
2.41401
2.38254
2.35486
2.32555
6.11639
6.06172
5.89569
5.56038
5.23386
4.9487
4.69075
4.44929
4.22005
4.00185
3.79564
3.6015
3.41827
3.24589
3.08447
2.9336
2.79355
2.66389
2.54729
2.44613
2.37947
2.38413
2.41719
2.51862
2.78045
3.33112
4.19265
4.55061
4.54661
4.50557
4.38564
4.17914
3.99273
3.83631
3.70207
3.58248
3.47343
3.37234
3.27808
3.18965
3.10662
3.02844
2.95505
2.88554
2.82118
2.75914
2.69834
2.63982
2.58396
2.53184
2.48343
2.43754
2.39414
2.35309
2.31422
2.27767
2.24356
2.21198
2.18444
2.16004
2.14278
2.13236
2.1344
2.14269
2.16227
2.20561
2.2839
2.39865
2.56228
2.75985
2.95333
3.07619
3.1017
3.0931
3.06945
3.02336
2.98235
2.94588
2.91367
2.88562
2.86173
2.83907
2.81737
2.79347
2.76861
2.7408
2.71156
2.6806
2.64902
2.61676
2.58464
2.55242
2.52069
2.48904
2.45808
2.42698
2.39716
2.3664
2.33942
2.31061
5.91561
5.95652
5.88158
5.68753
5.34697
5.04452
4.77996
4.53846
4.31211
4.09688
3.89207
3.69895
3.51718
3.34561
3.18405
3.03286
2.89255
2.76402
2.65397
2.56765
2.56963
2.59661
2.6908
2.93166
3.44933
4.42465
4.85862
4.85543
4.81135
4.67992
4.44752
4.23767
4.06196
3.91064
3.77547
3.65131
3.53587
3.42743
3.32554
3.22937
3.13881
3.05336
2.97285
2.89693
2.82551
2.75825
2.69556
2.63414
2.57497
2.51821
2.46442
2.41426
2.36745
2.32321
2.28131
2.24165
2.20409
2.16884
2.13575
2.10529
2.07818
2.05391
2.03684
2.02336
2.02485
2.03128
2.04753
2.08331
2.15254
2.26316
2.42733
2.63166
2.84555
2.96646
3.0036
2.99593
2.9749
2.93397
2.89645
2.86068
2.82767
2.79832
2.77315
2.74929
2.72659
2.70248
2.6773
2.65017
2.62178
2.59209
2.56184
2.53106
2.50036
2.46955
2.43932
2.40891
2.37978
2.3497
2.3234
2.29517
5.42852
5.83991
5.82016
5.71281
5.47256
5.1542
4.87547
4.62921
4.40286
4.1902
3.98862
3.79641
3.61414
3.44282
3.2818
3.1312
2.99219
2.87206
2.77153
2.76589
2.78985
2.87983
3.11877
3.63405
4.66649
5.17689
5.1879
5.14313
4.99903
4.74
4.50641
4.31097
4.14283
3.9921
3.85342
3.7237
3.60176
3.48643
3.37759
3.27451
3.17724
3.08522
2.9984
2.91638
2.83896
2.76601
2.69711
2.63262
2.57171
2.51195
2.4547
2.40008
2.34899
2.30124
2.25613
2.21346
2.17309
2.13492
2.09882
2.06495
2.03307
2.00382
1.97729
1.9537
1.93649
1.92148
1.9224
1.92751
1.94081
1.97189
2.03474
2.14443
2.30564
2.51335
2.74435
2.86016
2.90462
2.89837
2.88079
2.84621
2.81039
2.77504
2.74197
2.71231
2.68637
2.66209
2.63855
2.61442
2.5894
2.56305
2.53566
2.50727
2.4784
2.44903
2.4199
2.39038
2.36202
2.33265
2.30703
2.27939
4.37173
5.56496
5.7353
5.6891
5.55305
5.27183
4.97912
4.72442
4.49562
4.28302
4.08217
3.89157
3.71071
3.53954
3.37909
3.23012
3.09947
2.98985
2.97039
2.99346
3.08335
3.32576
3.86073
4.94487
5.53074
5.55629
5.50607
5.34406
5.05642
4.79748
4.58158
4.39605
4.22985
4.07647
3.93285
3.79722
3.66895
3.54727
3.43217
3.32297
3.21978
3.12196
3.02951
2.94196
2.8592
2.78097
2.70703
2.63736
2.57144
2.50994
2.45059
2.39332
2.33849
2.28652
2.23808
2.1924
2.14923
2.10839
2.06976
2.03321
1.99868
1.96621
1.93563
1.90759
1.8818
1.85909
1.84171
1.82666
1.82656
1.83006
1.84248
1.87031
1.9294
2.04051
2.20367
2.40785
2.64803
2.75889
2.80747
2.80279
2.78848
2.75934
2.72481
2.69037
2.65774
2.62826
2.60204
2.57753
2.55381
2.52985
2.50532
2.47981
2.45357
2.42641
2.39907
2.37097
2.34376
2.31531
2.29046
2.26351
2.75736
4.93573
5.57611
5.61588
5.55085
5.39072
5.10062
4.83071
4.59232
4.37667
4.17543
3.98546
3.80539
3.6356
3.47711
3.33674
3.21866
3.18705
3.20928
3.30028
3.54878
4.11001
5.25155
5.91742
5.95905
5.90206
5.71777
5.39803
5.11144
4.8734
4.66974
4.48742
4.31917
4.16122
4.01196
3.87035
3.73607
3.60857
3.48781
3.37317
3.26469
3.16172
3.06427
2.97182
2.88431
2.80138
2.72288
2.64863
2.57842
2.51214
2.44964
2.39097
2.33363
2.2788
2.22661
2.17773
2.13173
2.08823
2.04706
2.00809
1.97122
1.93634
1.90339
1.87242
1.84321
1.81642
1.79163
1.7698
1.75268
1.7379
1.73709
1.74038
1.75197
1.77908
1.83714
1.94931
2.11233
2.32333
2.55877
2.66365
2.71433
2.71096
2.69885
2.67399
2.64079
2.60742
2.57564
2.54667
2.52062
2.49623
2.47273
2.44919
2.42541
2.4008
2.37586
2.34983
2.32435
2.29733
2.27355
2.24759
2.10203
3.51977
5.14106
5.50901
5.50176
5.42278
5.23809
4.95308
4.69881
4.4743
4.26974
4.07799
3.89928
3.73189
3.58214
3.45584
3.41488
3.4367
3.52927
3.78512
4.36572
5.55396
6.32187
6.38215
6.31893
6.11488
5.76273
5.44752
5.18647
4.96358
4.76447
4.58059
4.40794
4.24443
4.0893
3.94188
3.80201
3.66916
3.54329
3.42376
3.31058
3.20304
3.10119
3.00438
2.91264
2.82552
2.74293
2.66461
2.59043
2.52018
2.45383
2.39092
2.33205
2.27546
2.22093
2.16886
2.11993
2.07379
2.03013
1.98878
1.94963
1.91257
1.8775
1.84434
1.813
1.78357
1.75578
1.73029
1.70667
1.68571
1.66932
1.65497
1.65423
1.65754
1.66882
1.69661
1.7546
1.86809
2.02676
2.24833
2.47735
2.57397
2.62503
2.62274
2.61256
2.59069
2.5591
2.52703
2.49641
2.46825
2.44278
2.41881
2.39585
2.37289
2.3501
2.32635
2.30304
2.27801
2.25573
2.23137
1.62575
2.32886
4.18698
5.23871
5.42209
5.39542
5.2959
5.0804
4.81112
4.57364
4.36304
4.172
3.99451
3.83593
3.70135
3.65262
3.67469
3.77105
4.03949
4.65322
5.91897
6.76045
6.82998
6.75909
6.53323
6.14751
5.80342
5.51887
5.27643
5.05985
4.85992
4.67188
4.49379
4.32451
4.1637
4.01086
3.86586
3.72818
3.5977
3.47379
3.35637
3.24472
3.13889
3.03818
2.94265
2.85178
2.76556
2.68364
2.60593
2.53223
2.46238
2.39625
2.33365
2.27463
2.21866
2.16457
2.11287
2.06412
2.01805
1.9744
1.93304
1.89388
1.8568
1.8217
1.78849
1.75711
1.72743
1.6996
1.6733
1.64911
1.62682
1.6067
1.59142
1.57756
1.5777
1.58129
1.59248
1.6221
1.68242
1.79955
1.9546
2.17831
2.40129
2.48997
2.53975
2.53855
2.53022
2.51071
2.4808
2.45017
2.4209
2.39375
2.36913
2.34576
2.32363
2.30132
2.2799
2.25693
2.23652
2.21437
1.27937
1.73792
2.62697
4.60722
5.25104
5.33194
5.28742
5.16998
4.92991
4.68127
4.46295
4.26932
4.09936
3.95762
3.90042
3.92311
4.02469
4.3092
4.96304
6.31536
7.24712
7.31379
7.23048
6.9753
6.55365
6.17912
5.87047
5.60784
5.37339
5.15661
4.95267
4.75917
4.5753
4.40038
4.23425
4.07644
3.92678
3.78473
3.65008
3.5222
3.40094
3.28563
3.17619
3.07201
2.97308
2.87887
2.78941
2.70429
2.62347
2.5467
2.47383
2.40472
2.33917
2.27713
2.21832
2.16301
2.10947
2.05831
2.01002
1.96425
1.92085
1.8797
1.84071
1.80376
1.76877
1.73566
1.70432
1.67474
1.64673
1.6205
1.59574
1.57281
1.55202
1.5327
1.5188
1.50582
1.50654
1.51162
1.52223
1.55615
1.61639
1.73857
1.90276
2.12168
2.33055
2.41316
2.46002
2.45954
2.45224
2.43449
2.40641
2.37746
2.34981
2.32381
2.30026
2.27758
2.25668
2.23508
2.21621
2.19628
1.17403
1.36797
1.96808
3.19723
4.79345
5.20833
5.23419
5.17937
5.04649
4.80254
4.57526
4.38193
4.223
4.15832
4.18216
4.29089
4.59775
5.30537
6.77208
7.78198
7.83099
7.73056
7.44121
6.98259
6.5771
6.24341
5.9597
5.70609
5.47144
5.25028
5.04054
4.84102
4.65145
4.47122
4.30025
4.13794
3.98409
3.83808
3.69966
3.56818
3.44343
3.32477
3.21208
3.10476
3.00277
2.90561
2.81327
2.72534
2.6418
2.56233
2.48685
2.41514
2.34705
2.28243
2.22116
2.16298
2.10825
2.05548
2.00504
1.9574
1.91215
1.86919
1.82843
1.78977
1.75313
1.7184
1.68553
1.65442
1.62498
1.5972
1.5709
1.54621
1.52304
1.50132
1.48206
1.46375
1.45096
1.44008
1.44112
1.44617
1.46083
1.49315
1.5604
1.68355
1.85397
2.07329
2.26525
2.34156
2.38518
2.38583
2.37957
2.36288
2.33679
2.30967
2.28374
2.25896
2.23681
2.21512
2.19641
2.17802
1.08128
1.2212
1.48537
2.21408
3.74757
4.87798
5.14116
5.1361
5.0764
4.9347
4.70758
4.5132
4.42741
4.45207
4.56964
4.9025
5.67391
7.27112
8.34138
8.3688
8.24901
7.92534
7.43277
6.99659
6.6382
6.33324
6.05994
5.80611
5.56649
5.33883
5.12252
4.91691
4.72187
4.53672
4.36131
4.19489
4.03723
3.88761
3.74577
3.61098
3.48308
3.3614
3.24578
3.13565
3.03094
2.93114
2.83627
2.74586
2.65994
2.57813
2.50039
2.42643
2.35614
2.28933
2.22586
2.16562
2.10836
2.05443
2.00248
1.95306
1.90617
1.86161
1.81928
1.77907
1.74094
1.70476
1.67048
1.63797
1.60719
1.57807
1.55048
1.52444
1.49985
1.47663
1.4551
1.4346
1.41685
1.39989
1.38793
1.37991
1.38115
1.38766
1.4026
1.43987
1.5121
1.64422
1.81761
2.03133
2.20566
2.27715
2.31661
2.3179
2.31212
2.29682
2.2727
2.2475
2.22357
2.20028
2.18063
2.16192
1.04144
1.11583
1.23589
1.64001
2.38322
4.14031
4.9175
5.07122
5.05697
4.99524
4.85515
4.72191
4.74376
4.86795
5.22855
6.08003
7.83495
8.96494
8.95103
8.79365
8.41155
7.89509
7.43539
7.05461
6.72875
6.43517
6.16131
5.90177
5.65493
5.42016
5.1974
4.98613
4.78612
4.59657
4.41715
4.24702
4.08589
3.93295
3.78795
3.65021
3.51942
3.39498
3.27671
3.16406
3.05691
2.9548
2.85768
2.76513
2.67714
2.5933
2.5136
2.43771
2.36554
2.29688
2.23158
2.16949
2.1105
2.05441
2.00144
1.95052
1.90219
1.85623
1.81254
1.77101
1.73156
1.6941
1.65854
1.6248
1.59281
1.56248
1.53374
1.50654
1.48079
1.45643
1.43354
1.4118
1.39186
1.37281
1.35628
1.34136
1.32969
1.32532
1.32699
1.33457
1.35186
1.39285
1.47023
1.60808
1.7884
1.99758
2.15227
2.21903
2.25458
2.25655
2.2512
2.23711
2.21505
2.19202
2.17152
2.15124
1.02509
1.04977
1.13848
1.28674
1.73874
2.60452
4.36361
4.9169
5.02659
5.02276
5.00913
5.0338
5.17542
5.58071
6.53911
8.48386
9.59867
9.56756
9.36603
8.91321
8.37031
7.89148
7.49046
7.14429
6.83007
6.53524
6.25488
5.98763
5.73348
5.4923
5.26399
5.0479
4.84359
4.65017
4.46717
4.29373
4.12946
3.97356
3.82573
3.68525
3.55185
3.42491
3.30425
3.18933
3.08006
2.97594
2.87692
2.78255
2.69281
2.60729
2.52593
2.4484
2.37467
2.30444
2.23764
2.17403
2.11354
2.05598
2.00132
1.94934
1.8998
1.85263
1.80777
1.76508
1.72449
1.6859
1.64924
1.61441
1.58134
1.54994
1.52016
1.49192
1.46517
1.43981
1.41589
1.39321
1.37201
1.35189
1.33338
1.31617
1.30052
1.28813
1.27708
1.27614
1.27832
1.28816
1.30709
1.35415
1.44013
1.58318
1.76687
1.96948
2.10628
2.16872
2.20025
2.20257
2.1977
2.18493
2.16618
2.14691
1.01148
1.03104
1.06364
1.17129
1.37185
1.93334
3.11005
4.49066
4.9274
5.0558
5.16485
5.41681
5.95463
7.10037
9.31244
10.3352
10.2699
10.0019
9.44007
8.86534
8.37279
7.957
7.59057
7.25302
6.9339
6.62955
6.3395
6.06392
5.80297
5.55622
5.32324
5.10306
4.89506
4.69822
4.51202
4.33554
4.16837
4.00974
3.85929
3.71635
3.58054
3.45135
3.3285
3.21157
3.10036
2.99442
2.89365
2.79767
2.70638
2.6194
2.53669
2.45789
2.38288
2.3114
2.24335
2.1785
2.11678
2.05802
2.00207
1.94899
1.89835
1.85015
1.80427
1.76063
1.7191
1.6796
1.64202
1.60629
1.57231
1.54002
1.50933
1.48018
1.45253
1.4263
1.40149
1.37798
1.35588
1.33495
1.31537
1.29707
1.27988
1.26468
1.25018
1.23987
1.23115
1.23195
1.2354
1.24843
1.27054
1.32485
1.41819
1.56368
1.75265
1.94851
2.06807
2.12678
2.15412
2.15805
2.1542
2.14484
1.00705
1.01422
1.03836
1.07948
1.2116
1.45963
2.12406
3.48916
4.62685
5.04178
5.43207
6.21091
7.7373
10.2544
11.1474
11.0407
10.696
10.0008
9.37137
8.86308
8.43712
8.05521
7.69564
7.35101
7.02073
6.70582
6.40718
6.12496
5.85882
5.60783
5.37118
5.14769
4.93665
4.73697
4.54809
4.36909
4.19954
4.03863
3.886
3.741
3.60334
3.47246
3.34802
3.22956
3.11684
3.00954
2.90744
2.81024
2.71776
2.62967
2.54584
2.46595
2.3899
2.3174
2.24836
2.18253
2.11985
2.06011
2.00324
1.94912
1.89758
1.84849
1.8018
1.75734
1.71504
1.67477
1.63643
1.59994
1.5652
1.53215
1.50071
1.47083
1.44245
1.41553
1.39002
1.36582
1.34298
1.32138
1.30106
1.28202
1.26405
1.24762
1.23202
1.21846
1.20618
1.19665
1.19252
1.19367
1.19964
1.21136
1.24341
1.30259
1.40759
1.55459
1.7463
1.93664
2.03776
2.09627
2.11802
2.13312
1.0032
1.00859
1.01725
1.04663
1.09615
1.25576
1.55425
2.32897
3.90286
4.97361
6.0359
8.15714
11.337
12.1259
11.9598
11.476
10.6048
9.91345
9.38041
8.94303
8.54574
8.16433
7.7937
7.43609
7.09469
6.7713
6.46638
6.17932
5.90919
5.65467
5.41475
5.18821
4.97428
4.77189
4.58046
4.39908
4.22727
4.06427
3.90966
3.76281
3.62333
3.49074
3.36466
3.24477
3.13071
3.0222
2.91896
2.82071
2.7272
2.63817
2.5534
2.47263
2.3957
2.32235
2.2525
2.18587
2.12242
2.06191
2.00432
1.94938
1.89712
1.84732
1.79998
1.7549
1.71201
1.67115
1.63224
1.59517
1.55986
1.52623
1.49422
1.46376
1.4348
1.40728
1.38116
1.3564
1.33298
1.31084
1.28997
1.27036
1.25188
1.23473
1.21861
1.20384
1.19038
1.17806
1.16867
1.16026
1.16046
1.1626
1.16955
1.18607
1.22175
1.29185
1.40481
1.55839
1.74382
1.93672
2.01554
2.09511
1.00177
1.0047
1.00947
1.02537
1.05164
1.13829
1.29292
1.75185
2.64824
4.72575
7.58499
12.3337
13.1163
12.8485
12.1582
11.2429
10.5404
9.99028
9.52567
9.08617
8.66369
8.25683
7.86715
7.49662
7.14653
6.81696
6.50727
6.21624
5.94261
5.68494
5.44221
5.21318
4.99703
4.79269
4.59949
4.41653
4.24325
4.07893
3.92307
3.77511
3.63459
3.50111
3.3742
3.2536
3.13886
3.02977
2.92594
2.82717
2.73312
2.64358
2.55829
2.47699
2.39954
2.32565
2.25526
2.18808
2.1241
2.06303
2.00491
1.94943
1.8967
1.84642
1.79856
1.75295
1.70953
1.66816
1.62878
1.59127
1.55554
1.52152
1.4891
1.45825
1.42889
1.40099
1.37447
1.34933
1.3255
1.30297
1.28169
1.26168
1.24284
1.22523
1.20878
1.19348
1.17944
1.1664
1.15503
1.14478
1.13692
1.13314
1.13394
1.13759
1.14689
1.16816
1.21151
1.29858
1.39747
1.58925
1.74751
1.97911
1.00132
1.00266
1.00732
1.01446
1.0418
1.08009
1.2466
1.52243
2.51121
4.83214
10.7494
13.7802
13.5014
12.7606
11.8999
11.2191
10.6552
10.1533
9.66925
9.19585
8.74191
8.31436
7.91347
7.53731
7.18413
6.8523
6.54041
6.24697
5.9709
5.71089
5.46598
5.23496
5.01699
4.81101
4.61631
4.43198
4.25742
4.09194
3.93498
3.78602
3.64455
3.5102
3.38246
3.26111
3.14566
3.03593
2.93148
2.83215
2.73757
2.64755
2.56179
2.48009
2.40226
2.32802
2.2573
2.18979
2.1255
2.06412
2.00569
1.94992
1.89685
1.84623
1.79804
1.7521
1.70836
1.66669
1.62698
1.58919
1.55314
1.51885
1.48614
1.45502
1.42538
1.39719
1.3704
1.34496
1.32085
1.29804
1.27648
1.25618
1.23708
1.21919
1.20248
1.18692
1.17256
1.15928
1.14724
1.13639
1.12675
1.11937
1.11331
1.11368
1.11552
1.12144
1.13334
1.1617
1.21297
1.3178
1.44092
1.69988
1.00111
1.00224
1.00623
1.01242
1.03663
1.06843
1.22876
1.461
2.52399
4.97686
11.6002
13.0407
12.8231
12.3769
11.9084
11.4106
10.8746
10.3178
9.77562
9.26627
8.79294
8.3532
7.94425
7.56295
7.20615
6.87136
6.55682
6.26104
5.98289
5.72111
5.4747
5.24244
5.02344
4.81659
4.62113
4.43615
4.26102
4.09503
3.93762
3.78827
3.64645
3.51181
3.38381
3.26223
3.14657
3.03667
2.93206
2.83259
2.73786
2.64771
2.56181
2.47998
2.402
2.32762
2.25675
2.1891
2.12466
2.06313
2.00456
1.94864
1.89543
1.84467
1.79637
1.75033
1.70648
1.66473
1.62492
1.58704
1.55089
1.51653
1.48371
1.45253
1.4228
1.39454
1.36766
1.34214
1.31795
1.29504
1.2734
1.253
1.2338
1.21582
1.19901
1.18336
1.1689
1.1555
1.14337
1.13219
1.12245
1.11353
1.10688
1.10116
1.10152
1.10323
1.10841
1.11831
1.14265
1.18768
1.27848
1.46999
3.06392
1.55572
1.04738
0.942491
0.96824
1.047
1.21278
1.34496
1.38604
1.3844
1.37913
1.37929
1.38126
1.38658
1.39739
1.40524
1.40782
1.40764
1.40702
1.40564
1.40382
1.40227
1.40089
1.3992
1.3971
1.39489
1.39411
1.39456
1.39658
1.40281
1.41917
1.45922
1.55345
1.77081
2.27366
3.29734
3.69948
3.67801
3.70183
3.72298
3.79147
3.9062
4.05307
4.1985
4.3233
4.41667
4.50357
4.55924
4.594
4.61221
4.61795
4.61537
4.60553
4.5844
4.55627
4.52466
4.49097
4.45447
4.41539
4.37375
4.32968
4.28363
4.23575
4.18634
4.13581
4.08394
4.03159
3.97875
3.9256
3.87198
3.81857
3.76514
3.71177
3.65854
3.60548
3.55278
3.50036
3.44853
3.39716
3.3464
3.29627
3.24684
3.19802
3.1499
3.10236
3.0556
3.00944
2.96405
2.91927
2.87547
2.83225
2.7899
2.74816
2.70743
2.66752
2.62899
2.592
2.55784
2.52788
2.50681
3.71843
2.31611
1.71693
1.46598
1.34999
1.27844
1.26402
1.27193
1.29406
1.33967
1.38503
1.4038
1.40351
1.4022
1.4001
1.40043
1.40156
1.40405
1.4068
1.40678
1.40646
1.40549
1.40342
1.40019
1.39707
1.39438
1.39272
1.39309
1.39489
1.40035
1.4142
1.44762
1.52649
1.7105
2.13819
3.0924
3.71972
3.7032
3.69916
3.7261
3.79497
3.89546
4.02288
4.16698
4.29394
4.39658
4.47949
4.53688
4.57373
4.5935
4.60078
4.59943
4.59326
4.57752
4.54881
4.51619
4.48262
4.44663
4.40838
4.36715
4.32368
4.27791
4.23051
4.18142
4.13122
4.07982
4.02774
3.97511
3.92219
3.86894
3.81565
3.76235
3.70911
3.65599
3.60304
3.55043
3.49812
3.44635
3.39505
3.34438
3.29425
3.24484
3.19606
3.14796
3.10052
3.0539
3.00805
2.96286
2.91838
2.87441
2.83125
2.78877
2.7472
2.70635
2.66656
2.6278
2.59073
2.55603
2.52546
2.50373
4.54542
3.24224
2.42437
1.9081
1.57868
1.37482
1.25762
1.24501
1.2524
1.27385
1.31851
1.36075
1.3879
1.40075
1.40314
1.40283
1.402
1.40143
1.40151
1.40151
1.4014
1.40106
1.40023
1.3985
1.39579
1.39289
1.39003
1.38991
1.39067
1.39386
1.40256
1.4261
1.47861
1.60948
1.8981
2.56409
3.61152
3.77486
3.79966
3.84124
3.90299
3.98085
4.06974
4.16973
4.26647
4.36233
4.443
4.50236
4.54176
4.56335
4.57173
4.57098
4.56726
4.55694
4.5349
4.50243
4.46867
4.43326
4.39564
4.35527
4.31255
4.26754
4.22072
4.17228
4.12261
4.07188
4.02034
3.96822
3.9157
3.8629
3.80992
3.75689
3.70389
3.65098
3.59827
3.54581
3.49377
3.44212
3.39108
3.34057
3.2907
3.24145
3.193
3.14519
3.09818
3.0516
3.00576
2.96053
2.9161
2.87223
2.82923
2.78681
2.74535
2.70451
2.66476
2.62587
2.5886
2.55334
2.52197
2.49845
4.99809
3.82353
2.9537
2.34794
1.94206
1.66924
1.49828
1.39167
1.32999
1.31426
1.31767
1.32906
1.35327
1.38141
1.40082
1.41087
1.4108
1.41009
1.40834
1.40524
1.40331
1.40216
1.40128
1.40028
1.39852
1.39597
1.39276
1.39011
1.39042
1.39196
1.39787
1.41108
1.4484
1.53002
1.73172
2.18696
3.20618
3.79437
4.03515
4.12467
4.16771
4.1963
4.20543
4.21623
4.24324
4.29868
4.36831
4.4324
4.48396
4.51575
4.53042
4.53196
4.52993
4.52349
4.50888
4.48064
4.44759
4.41249
4.37556
4.33643
4.29503
4.25133
4.20564
4.15825
4.10952
4.05966
4.00897
3.95758
3.90573
3.85348
3.80104
3.74843
3.69586
3.64329
3.59097
3.53883
3.48716
3.43583
3.38508
3.33488
3.28549
3.2366
3.1884
3.14074
3.09385
3.04744
3.00182
2.95673
2.91252
2.86882
2.82602
2.7837
2.74237
2.70157
2.66188
2.6229
2.58546
2.54969
2.51737
2.49204
5.27096
4.24381
3.40835
2.77522
2.31291
1.97671
1.73297
1.55883
1.4372
1.36078
1.32043
1.32044
1.32386
1.33372
1.35409
1.37434
1.38908
1.39825
1.40087
1.40054
1.39948
1.39724
1.39456
1.39226
1.39029
1.38848
1.38709
1.38523
1.38537
1.38646
1.38895
1.39948
1.41799
1.478
1.59385
1.88945
2.50746
3.68466
4.37408
4.59509
4.59026
4.54686
4.43767
4.30836
4.24871
4.25246
4.27372
4.32371
4.38798
4.43744
4.46835
4.48241
4.48221
4.47942
4.47113
4.45269
4.42192
4.38685
4.35014
4.31195
4.27195
4.22988
4.18584
4.13998
4.09259
4.04391
3.99427
3.9438
3.89276
3.84121
3.78941
3.73737
3.68534
3.63323
3.58143
3.52972
3.47852
3.42775
3.37767
3.32799
3.27901
3.23042
3.18253
3.13508
3.08843
3.04224
2.99691
2.95202
2.90805
2.86452
2.82195
2.7798
2.73866
2.69799
2.65841
2.61947
2.58193
2.54584
2.51296
2.48608
5.45694
4.56565
3.79002
3.16119
2.6702
2.29315
2.00588
1.78922
1.62705
1.5101
1.42543
1.37172
1.34284
1.34037
1.34279
1.35001
1.36509
1.38179
1.39464
1.40286
1.40425
1.40384
1.4026
1.3999
1.39592
1.39225
1.38918
1.38641
1.3852
1.38566
1.38738
1.3935
1.40698
1.44368
1.52382
1.71992
2.1632
3.18038
4.68735
5.20031
5.1449
4.98542
4.6938
4.45073
4.2945
4.22903
4.22113
4.22825
4.25389
4.30689
4.35728
4.39484
4.4143
4.4182
4.4158
4.40743
4.38854
4.35651
4.32017
4.28219
4.24293
4.20231
4.16022
4.11646
4.07102
4.02405
3.97588
3.92663
3.87663
3.82596
3.77496
3.72361
3.67225
3.6207
3.56953
3.51867
3.46828
3.41816
3.36863
3.31936
3.27075
3.22245
3.17491
3.12773
3.08142
3.03548
2.99047
2.94583
2.90216
2.85887
2.81656
2.77466
2.73374
2.69329
2.65384
2.61502
2.57746
2.54118
2.50797
2.47994
5.58462
4.8101
4.10288
3.49784
2.99978
2.59866
2.27955
2.02734
1.82856
1.67353
1.55326
1.46483
1.39991
1.36188
1.34197
1.34205
1.34413
1.34993
1.36188
1.3744
1.38372
1.39015
1.3907
1.39039
1.3894
1.38731
1.3842
1.38124
1.37966
1.38002
1.38162
1.38636
1.39808
1.4269
1.49253
1.64908
2.01114
2.86568
4.72924
5.84257
5.7582
5.50568
5.07212
4.7065
4.44695
4.2868
4.20556
4.17939
4.17688
4.18551
4.21157
4.26226
4.30341
4.33327
4.34419
4.34282
4.33632
4.32043
4.28872
4.25208
4.21264
4.1723
4.13136
4.08935
4.04596
4.00105
3.95477
3.9071
3.8584
3.80878
3.75866
3.70808
3.65747
3.60692
3.55664
3.50649
3.45682
3.40725
3.35824
3.30939
3.26124
3.21332
3.16621
3.1194
3.07346
3.02787
2.9832
2.9389
2.89552
2.85257
2.81052
2.76894
2.72824
2.68807
2.64879
2.61016
2.57268
2.53633
2.50298
2.47417
5.6777
4.9957
4.35235
3.77991
3.28965
2.87959
2.54174
2.26558
2.04107
1.85971
1.71378
1.59808
1.50782
1.44057
1.39123
1.36296
1.3473
1.34738
1.34911
1.35398
1.36404
1.37527
1.38408
1.39068
1.39093
1.3904
1.38889
1.38577
1.38232
1.38248
1.3836
1.3892
1.39934
1.43144
1.4907
1.6449
1.95504
2.66517
4.13905
5.90525
5.98395
5.84963
5.51909
5.11684
4.74783
4.4861
4.30449
4.19272
4.14257
4.12419
4.12493
4.13449
4.15988
4.20732
4.23854
4.25929
4.26018
4.25655
4.24481
4.21934
4.18253
4.14223
4.10103
4.05916
4.01677
3.97354
3.92929
3.88354
3.8366
3.78839
3.73936
3.68988
3.64043
3.59083
3.5415
3.49206
3.44307
3.39408
3.34567
3.29736
3.24974
3.20233
3.15571
3.10937
3.06387
3.01873
2.97443
2.93056
2.88754
2.84498
2.80325
2.76203
2.72162
2.68176
2.64273
2.60433
2.567
2.53067
2.49731
2.46801
5.74508
5.13907
4.55375
4.0171
3.54292
3.13408
2.78718
2.49591
2.2527
2.05079
1.88342
1.74564
1.633
1.54205
1.4706
1.41679
1.37792
1.3565
1.34565
1.34583
1.34735
1.35139
1.3596
1.36789
1.37381
1.37783
1.37974
1.3797
1.37974
1.3805
1.38276
1.39096
1.40781
1.45171
1.54133
1.74108
2.14146
2.94156
3.70302
4.69567
5.52058
5.6765
5.61639
5.4299
5.08872
4.79997
4.52426
4.32923
4.19606
4.11381
4.08126
4.0655
4.06735
4.07816
4.10374
4.14084
4.16252
4.1723
4.17054
4.16313
4.14564
4.11125
4.07219
4.02962
3.98672
3.94383
3.90077
3.85668
3.81165
3.76519
3.71811
3.67003
3.62183
3.5732
3.52473
3.47604
3.42773
3.37941
3.33163
3.28398
3.23696
3.19017
3.14408
3.09832
3.05329
3.00866
2.96481
2.9214
2.87878
2.83665
2.79529
2.75445
2.71438
2.67485
2.63612
2.59796
2.56087
2.52462
2.49136
2.46173
5.79763
5.25188
4.717
4.21581
3.76183
3.36071
3.012
2.71253
2.45694
2.24014
2.05659
1.90192
1.77194
1.66362
1.57429
1.50165
1.44515
1.40175
1.37075
1.35342
1.34462
1.34481
1.34617
1.34976
1.35708
1.36503
1.37167
1.37601
1.37849
1.38195
1.38946
1.4051
1.44051
1.51496
1.67449
1.99854
2.64809
3.19887
3.52437
3.92005
4.43964
5.01676
5.35016
5.32968
5.23999
5.04626
4.78992
4.57223
4.36218
4.21134
4.10999
4.04671
4.02094
4.00416
4.00606
4.01508
4.03527
4.06187
4.07674
4.0776
4.07425
4.06318
4.03919
4.00053
3.95828
3.91461
3.87098
3.82719
3.78335
3.73869
3.69348
3.64725
3.60055
3.55313
3.50563
3.4578
3.41025
3.36267
3.31558
3.26865
3.22231
3.17621
3.13076
3.08563
3.04119
2.99713
2.95381
2.91091
2.86879
2.82712
2.78623
2.7458
2.70616
2.66698
2.62864
2.59075
2.55397
2.51784
2.48476
2.4549
5.83728
5.34166
4.85081
4.38343
3.95188
3.56273
3.21752
2.91517
2.65226
2.42516
2.22945
2.0615
1.91748
1.79461
1.69012
1.60202
1.52882
1.46888
1.42186
1.38615
1.36122
1.34713
1.34064
1.34087
1.34221
1.34551
1.35219
1.36007
1.36868
1.37832
1.3941
1.42582
1.49304
1.63099
1.91564
2.48967
3.0803
3.33928
3.45795
3.6
3.81343
4.11444
4.5354
4.86226
5.02036
5.00004
4.92289
4.75339
4.56596
4.40182
4.24002
4.11571
4.03319
3.97917
3.95416
3.93512
3.9368
3.94331
3.95721
3.97566
3.98291
3.98139
3.97503
3.95924
3.92742
3.88673
3.84234
3.79763
3.75385
3.71011
3.66628
3.62167
3.57658
3.53063
3.48442
3.43769
3.39111
3.34441
3.29814
3.25199
3.2064
3.16103
3.11629
3.07182
3.02803
2.98457
2.94185
2.8995
2.85792
2.81673
2.77634
2.73635
2.69717
2.65837
2.62044
2.58288
2.54644
2.51052
2.47767
2.44764
5.87021
5.41434
4.96143
4.52552
4.11685
3.74216
3.4039
3.10257
2.83615
2.60237
2.39775
2.2195
2.06426
1.9296
1.81292
1.71235
1.6262
1.55316
1.49224
1.44239
1.40334
1.37371
1.35331
1.34152
1.33797
1.3387
1.34135
1.34742
1.35978
1.37846
1.40855
1.46953
1.59291
1.84546
2.35419
3.00886
3.30937
3.40169
3.43288
3.47052
3.53341
3.64193
3.81524
4.05048
4.37108
4.61696
4.74567
4.73016
4.67253
4.54549
4.39064
4.25974
4.13407
4.02396
3.94984
3.90399
3.87672
3.85744
3.85862
3.86329
3.87306
3.88556
3.88531
3.8823
3.87292
3.85188
3.81318
3.77012
3.7258
3.68145
3.63766
3.59373
3.5498
3.5052
3.46041
3.41507
3.36977
3.32423
3.27901
3.2338
3.18907
3.14451
3.10052
3.05677
3.01367
2.97086
2.92876
2.88699
2.84599
2.80535
2.76549
2.726
2.68729
2.64895
2.61143
2.57426
2.53818
2.50251
2.46993
2.43976
5.89539
5.47316
5.055
4.64881
4.26268
3.90345
3.57432
3.27656
3.00953
2.77171
2.56089
2.37462
2.21051
2.06608
1.93939
1.82833
1.73151
1.64732
1.57493
1.51311
1.46157
1.41936
1.38631
1.36207
1.34496
1.34079
1.34217
1.34685
1.35971
1.38446
1.43862
1.54483
1.76547
2.20636
2.88288
3.28033
3.40122
3.42086
3.42007
3.41537
3.40715
3.41555
3.44991
3.53051
3.68861
3.90457
4.1827
4.38959
4.51074
4.49999
4.46001
4.37504
4.23873
4.12878
4.02749
3.92955
3.86338
3.82239
3.79411
3.77408
3.77505
3.77862
3.78494
3.78927
3.7878
3.78197
3.7677
3.73831
3.69845
3.65435
3.61012
3.5659
3.5221
3.47813
3.43439
3.39038
3.3465
3.30236
3.25839
3.21432
3.17056
3.12691
3.08371
3.04074
2.99833
2.95622
2.91475
2.87363
2.83321
2.79315
2.75382
2.71486
2.67664
2.63879
2.60171
2.56496
2.52927
2.4939
2.46164
2.43135
5.92499
5.531
5.14072
4.75905
4.39348
4.04917
3.7298
3.43706
3.17123
2.93152
2.71654
2.52442
2.35327
2.20109
2.06605
1.94636
1.84063
1.74726
1.66549
1.59393
1.53221
1.47953
1.43546
1.40021
1.373
1.35818
1.35947
1.36503
1.38409
1.42087
1.51017
1.68536
2.04922
2.71487
3.21002
3.39192
3.42423
3.42194
3.40986
3.38005
3.32383
3.27792
3.27731
3.28809
3.32471
3.40621
3.56018
3.75213
3.98275
4.16398
4.29103
4.2903
4.27024
4.2166
4.10801
4.00587
3.91665
3.83787
3.77577
3.73462
3.70712
3.68859
3.68794
3.68926
3.69238
3.69188
3.68872
3.67957
3.6596
3.62268
3.58125
3.53759
3.49361
3.44964
3.40638
3.36336
3.32075
3.27809
3.23554
3.19288
3.15035
3.10783
3.0656
3.02353
2.98189
2.94053
2.89973
2.85927
2.81945
2.78001
2.74124
2.70284
2.66514
2.62779
2.5912
2.55487
2.51964
2.48455
2.45267
2.42232
5.96348
5.5895
5.22183
4.8609
4.51284
4.18239
3.87235
3.58527
3.32167
3.08162
2.864
2.66788
2.49128
2.33305
2.19121
2.06439
1.95129
1.85022
1.76067
1.68099
1.61095
1.54965
1.4964
1.45247
1.41569
1.39557
1.39756
1.40786
1.43409
1.50355
1.64249
1.94242
2.53727
3.10077
3.36264
3.4231
3.42201
3.41141
3.38213
3.32227
3.2592
3.20643
3.16874
3.14632
3.14963
3.16383
3.20045
3.27598
3.40769
3.57361
3.76885
3.94307
4.07004
4.10695
4.09581
4.06165
3.98646
3.89039
3.81209
3.74354
3.68444
3.64445
3.61732
3.60009
3.59657
3.59697
3.59683
3.5951
3.58902
3.57418
3.54394
3.50515
3.46339
3.42037
3.37762
3.33526
3.29352
3.25201
3.21077
3.16951
3.12835
3.08712
3.04606
3.00503
2.96433
2.9238
2.88376
2.84398
2.80482
2.76597
2.72781
2.68995
2.65282
2.61595
2.57989
2.54399
2.50924
2.47447
2.44302
2.41264
6.02194
5.65397
5.30101
4.95758
4.6238
4.30418
4.00285
3.72148
3.46096
3.22187
3.00299
2.80436
2.62392
2.46096
2.3139
2.18113
2.06202
1.95443
1.85836
1.77184
1.69482
1.62652
1.56561
1.51583
1.47078
1.45637
1.4605
1.48052
1.52425
1.64901
1.88649
2.40008
3.0068
3.33285
3.42773
3.4267
3.41569
3.38543
3.32344
3.25767
3.20114
3.15184
3.10818
3.07009
3.04206
3.02231
3.02506
3.03685
3.06632
3.12724
3.23776
3.38323
3.55263
3.7245
3.85131
3.93572
3.93038
3.91092
3.87168
3.79438
3.71332
3.64551
3.59239
3.55236
3.5234
3.50882
3.50673
3.50638
3.50475
3.4997
3.48767
3.46257
3.42875
3.39011
3.34936
3.30782
3.26647
3.22539
3.18483
3.14451
3.10453
3.06457
3.02481
2.98498
2.94542
2.90585
2.86671
2.82769
2.78926
2.75102
2.71349
2.67617
2.63961
2.60324
2.56772
2.53227
2.49803
2.46361
2.4326
2.40224
6.10634
5.72373
5.37719
5.04501
4.72375
4.41545
4.12205
3.84688
3.58972
3.35266
3.13381
2.93372
2.75101
2.58435
2.43343
2.29579
2.17175
2.05876
1.95708
1.86487
1.78191
1.70779
1.64136
1.58701
1.54123
1.54199
1.55317
1.58443
1.68483
1.87892
2.31415
2.96026
3.3328
3.45626
3.45508
3.44247
3.40545
3.33079
3.25836
3.19797
3.14757
3.10125
3.05768
3.01621
2.97726
2.94245
2.91571
2.89404
2.89579
2.90377
2.9252
2.97137
3.06338
3.18892
3.34162
3.50507
3.6473
3.74947
3.78683
3.77876
3.7523
3.69409
3.61911
3.55087
3.49555
3.45332
3.42784
3.41715
3.41356
3.41155
3.40722
3.39771
3.37875
3.35044
3.3164
3.27873
3.23936
3.19917
3.15911
3.11923
3.07991
3.04079
3.0021
2.96339
2.92501
2.88652
2.84843
2.8103
2.7727
2.73517
2.69831
2.66157
2.62559
2.58974
2.55474
2.51977
2.48603
2.45198
2.42144
2.39111
6.19149
5.79935
5.45036
5.12566
4.81424
4.51615
4.23136
3.96256
3.70976
3.47486
3.25743
3.05663
2.87268
2.70354
2.54937
2.40821
2.2797
2.16251
2.05579
1.95893
1.87102
1.79196
1.72342
1.6643
1.64082
1.64677
1.67475
1.74444
1.92346
2.28268
2.95821
3.38056
3.5232
3.52105
3.50398
3.45467
3.36814
3.28977
3.21999
3.1587
3.1038
3.05468
3.01046
2.96739
2.92577
2.88596
2.84818
2.81465
2.78711
2.76538
2.76214
2.76695
2.78287
2.81828
2.89143
2.9992
3.13623
3.29132
3.44774
3.56552
3.64839
3.64591
3.6315
3.60046
3.53675
3.46497
3.40702
3.36485
3.33867
3.32475
3.31767
3.3128
3.30551
3.29084
3.26887
3.24031
3.20718
3.17079
3.13285
3.09404
3.05533
3.01669
2.97863
2.94067
2.90324
2.86573
2.82869
2.79152
2.75487
2.71816
2.68207
2.646
2.61065
2.57537
2.54092
2.50644
2.47323
2.43958
2.40953
2.37928
6.31796
5.89299
5.52645
5.20177
4.89771
4.60823
4.33171
4.07008
3.82266
3.59045
3.37467
3.17433
2.9894
2.81894
2.66201
2.51814
2.38592
2.26508
2.15427
2.05338
1.96148
1.87998
1.80965
1.76218
1.76492
1.78394
1.84617
1.99677
2.32242
2.9777
3.46835
3.63754
3.63441
3.61184
3.54931
3.44738
3.35361
3.27376
3.20368
3.14075
3.08209
3.0267
2.9745
2.92625
2.88179
2.8388
2.79737
2.75786
2.72063
2.68766
2.65891
2.63782
2.62785
2.63088
2.64218
2.6689
2.72572
2.81758
2.93891
3.08894
3.24779
3.39
3.49501
3.53549
3.52617
3.49861
3.44127
3.37445
3.32288
3.28109
3.25209
3.23488
3.2241
3.21452
3.20245
3.18497
3.162
3.13364
3.1015
3.06638
3.02987
2.9924
2.95502
2.91758
2.88073
2.84391
2.80768
2.77139
2.73566
2.69984
2.6646
2.62932
2.5947
2.56006
2.52624
2.4923
2.45966
2.42644
2.3969
2.36677
6.34676
5.98755
5.60779
5.27785
4.97686
4.69437
4.42537
4.16981
3.92857
3.70056
3.48665
3.28731
3.10197
2.93047
2.7717
2.62534
2.49038
2.36622
2.25217
2.14813
2.05339
1.97325
1.90441
1.89943
1.91322
1.95944
2.10762
2.39654
3.03031
3.59821
3.80245
3.79865
3.77121
3.69629
3.56424
3.44692
3.35121
3.27046
3.19951
3.13541
3.07377
3.01423
2.95658
2.90121
2.84943
2.80149
2.75602
2.71269
2.67137
2.6321
2.59549
2.56262
2.53343
2.51248
2.4967
2.49872
2.50684
2.52657
2.56716
2.64497
2.75424
2.89682
3.05644
3.22056
3.34582
3.42332
3.41586
3.39328
3.35017
3.29041
3.24085
3.19856
3.16774
3.1471
3.13202
3.11804
3.10238
3.08276
3.05907
3.03079
2.99954
2.96546
2.93022
2.89398
2.85788
2.8216
2.78595
2.75029
2.71529
2.68026
2.64586
2.61141
2.57759
2.54372
2.5106
2.4773
2.44528
2.41255
2.38357
2.35361
6.31298
6.1011
5.70748
5.36036
5.05773
4.77991
4.51588
4.26552
4.02871
3.80531
3.59427
3.39611
3.211
3.03872
2.87864
2.73029
2.59301
2.46624
2.3497
2.24337
2.1502
2.0711
2.0434
2.05404
2.0974
2.22645
2.50762
3.1104
3.7681
4.01481
4.01041
3.9778
3.88849
3.73129
3.59014
3.47293
3.3742
3.28793
3.21028
3.13861
3.07218
3.01046
2.94914
2.88956
2.83166
2.77638
2.72501
2.67747
2.6322
2.58916
2.54839
2.50973
2.47393
2.44105
2.4123
2.39009
2.3718
2.3716
2.37574
2.38997
2.42096
2.48568
2.5845
2.71761
2.87825
3.05527
3.20408
3.30863
3.30482
3.28977
3.26036
3.20254
3.15526
3.11418
3.08317
3.05998
3.04127
3.02366
3.00532
2.98379
2.95962
2.93119
2.90078
2.8676
2.83351
2.79849
2.76365
2.72863
2.69422
2.65983
2.62612
2.59244
2.55939
2.52632
2.49396
2.46141
2.43008
2.39795
2.36958
2.33988
6.2206
6.09897
5.82398
5.45853
5.14245
4.86281
4.60448
4.35929
4.1256
3.9049
3.69699
3.5008
3.31623
3.14382
2.98277
2.83306
2.69397
2.56542
2.44725
2.34225
2.25177
2.20418
2.2116
2.25027
2.36129
2.63372
3.20531
3.96381
4.26497
4.26077
4.22405
4.12025
3.93852
3.77466
3.63788
3.52101
3.41785
3.32437
3.23841
3.15838
3.0836
3.01313
2.94725
2.88562
2.82364
2.76402
2.70678
2.65281
2.60261
2.55568
2.51127
2.46911
2.42913
2.39138
2.3564
2.32395
2.29589
2.27219
2.25438
2.2484
2.25139
2.26218
2.28676
2.33919
2.42786
2.55074
2.71264
2.90017
3.07389
3.19183
3.20127
3.19085
3.16481
3.1128
3.0683
3.03012
2.99877
2.973
2.95129
2.9307
2.9104
2.88737
2.86283
2.83451
2.8047
2.77256
2.73968
2.70598
2.67248
2.63882
2.60573
2.57271
2.54031
2.50799
2.47637
2.44457
2.41401
2.38254
2.35486
2.32555
6.11639
6.06172
5.89569
5.56038
5.23386
4.94871
4.69074
4.44929
4.22004
4.00185
3.79563
3.6015
3.41827
3.24589
3.08447
2.9336
2.79355
2.66389
2.54729
2.44613
2.37947
2.38414
2.41719
2.51862
2.78045
3.33113
4.19266
4.55061
4.54661
4.50557
4.38564
4.17914
3.99274
3.83632
3.70209
3.5825
3.47345
3.37235
3.2781
3.18966
3.10663
3.02844
2.95505
2.88554
2.82117
2.75912
2.69832
2.63979
2.58394
2.53181
2.4834
2.43751
2.39411
2.35307
2.3142
2.27765
2.24354
2.21196
2.18443
2.16003
2.14277
2.13235
2.1344
2.14269
2.16226
2.20561
2.2839
2.39866
2.56229
2.75986
2.95333
3.07619
3.10169
3.09309
3.06945
3.02336
2.98235
2.94588
2.91367
2.88562
2.86173
2.83907
2.81737
2.79347
2.76861
2.7408
2.71156
2.6806
2.64901
2.61676
2.58464
2.55242
2.52069
2.48903
2.45808
2.42698
2.39716
2.36639
2.33942
2.31061
5.91561
5.95653
5.88158
5.68753
5.34697
5.04452
4.77996
4.53846
4.3121
4.09688
3.89207
3.69895
3.51718
3.34561
3.18405
3.03286
2.89255
2.76402
2.65397
2.56765
2.56963
2.59661
2.6908
2.93166
3.44935
4.42466
4.85862
4.85543
4.81135
4.67991
4.44752
4.23767
4.06196
3.91065
3.77548
3.65132
3.53588
3.42744
3.32555
3.22938
3.13881
3.05335
2.97284
2.89691
2.82549
2.75823
2.69553
2.63411
2.57494
2.51818
2.46439
2.41423
2.36742
2.32319
2.28129
2.24163
2.20408
2.16883
2.13574
2.10528
2.07818
2.0539
2.03683
2.02336
2.02485
2.03127
2.04753
2.08332
2.15255
2.26317
2.42734
2.63167
2.84556
2.96647
3.0036
2.99593
2.9749
2.93397
2.89644
2.86068
2.82767
2.79832
2.77315
2.74929
2.72659
2.70248
2.6773
2.65017
2.62178
2.59209
2.56184
2.53105
2.50036
2.46955
2.43932
2.40891
2.37977
2.3497
2.3234
2.29517
5.42853
5.83991
5.82016
5.71281
5.47256
5.15421
4.87547
4.62922
4.40286
4.1902
3.98862
3.79641
3.61414
3.44282
3.2818
3.1312
2.99219
2.87206
2.77153
2.76589
2.78985
2.87983
3.11878
3.63406
4.6665
5.17689
5.1879
5.14313
4.99902
4.73999
4.50641
4.31096
4.14283
3.9921
3.85342
3.72371
3.60176
3.48644
3.37759
3.27451
3.17724
3.08522
2.99839
2.91636
2.83894
2.76599
2.69709
2.63259
2.57168
2.51193
2.45468
2.40006
2.34897
2.30122
2.25612
2.21345
2.17308
2.13491
2.09881
2.06494
2.03306
2.00382
1.97729
1.9537
1.93649
1.92148
1.9224
1.92751
1.94081
1.97189
2.03475
2.14443
2.30565
2.51336
2.74436
2.86016
2.90462
2.89837
2.88079
2.84621
2.81039
2.77504
2.74197
2.71231
2.68637
2.66208
2.63855
2.61442
2.5894
2.56304
2.53566
2.50727
2.4784
2.44903
2.41989
2.39038
2.36202
2.33265
2.30703
2.27939
4.37174
5.56496
5.7353
5.6891
5.55304
5.27183
4.97912
4.72442
4.49562
4.28302
4.08217
3.89157
3.71071
3.53954
3.37909
3.23012
3.09947
2.98985
2.9704
2.99346
3.08335
3.32576
3.86074
4.94489
5.53075
5.55628
5.50607
5.34406
5.05641
4.79748
4.58158
4.39605
4.22985
4.07647
3.93285
3.79722
3.66895
3.54727
3.43216
3.32297
3.21977
3.12194
3.02949
2.94194
2.85918
2.78095
2.707
2.63734
2.57141
2.50992
2.45057
2.39331
2.33847
2.28651
2.23807
2.19239
2.14922
2.10838
2.06975
2.03321
1.99867
1.96621
1.93562
1.90758
1.8818
1.85909
1.84171
1.82666
1.82656
1.83006
1.84248
1.87032
1.9294
2.04051
2.20367
2.40786
2.64804
2.7589
2.80747
2.80279
2.78848
2.75934
2.72481
2.69037
2.65774
2.62826
2.60204
2.57753
2.5538
2.52985
2.50532
2.47981
2.45357
2.42641
2.39907
2.37097
2.34376
2.31531
2.29046
2.26351
2.75736
4.93573
5.57611
5.61587
5.55085
5.39072
5.10061
4.83072
4.59232
4.37667
4.17543
3.98546
3.80539
3.6356
3.47711
3.33674
3.21866
3.18705
3.20928
3.30028
3.54879
4.11003
5.25157
5.91743
5.95905
5.90206
5.71777
5.39803
5.11143
4.8734
4.66974
4.48741
4.31916
4.16122
4.01195
3.87034
3.73607
3.60856
3.48781
3.37316
3.26468
3.1617
3.06426
2.97181
2.88429
2.80136
2.72287
2.64861
2.5784
2.51212
2.44962
2.39096
2.33362
2.27879
2.2266
2.17771
2.13172
2.08822
2.04705
2.00808
1.97122
1.93634
1.90338
1.87242
1.8432
1.81642
1.79163
1.7698
1.75268
1.7379
1.73709
1.74039
1.75197
1.77908
1.83714
1.94932
2.11234
2.32334
2.55877
2.66365
2.71433
2.71096
2.69885
2.67399
2.64079
2.60742
2.57564
2.54667
2.52062
2.49623
2.47272
2.44919
2.42541
2.4008
2.37586
2.34983
2.32435
2.29733
2.27355
2.24759
2.10203
3.51978
5.14106
5.50901
5.50176
5.42278
5.23809
4.95308
4.69881
4.4743
4.26974
4.07798
3.89928
3.73189
3.58214
3.45584
3.41488
3.4367
3.52928
3.78512
4.36573
5.55398
6.32187
6.38215
6.31893
6.11488
5.76273
5.44751
5.18647
4.96357
4.76447
4.58058
4.40793
4.24443
4.0893
3.94187
3.802
3.66915
3.54328
3.42375
3.31057
3.20303
3.10117
3.00437
2.91263
2.8255
2.74291
2.6646
2.59042
2.52017
2.45381
2.39091
2.33204
2.27545
2.22092
2.16885
2.11992
2.07379
2.03012
1.98877
1.94963
1.91257
1.8775
1.84434
1.81299
1.78357
1.75578
1.73029
1.70666
1.68571
1.66932
1.65497
1.65423
1.65754
1.66881
1.69664
1.75459
1.86809
2.02676
2.24834
2.47736
2.57397
2.62503
2.62274
2.61256
2.59069
2.5591
2.52703
2.49641
2.46825
2.44278
2.41881
2.39585
2.37289
2.3501
2.32635
2.30304
2.27801
2.25573
2.23137
1.62575
2.32887
4.18698
5.23871
5.42209
5.39542
5.2959
5.0804
4.81112
4.57364
4.36304
4.172
3.99451
3.83593
3.70135
3.65262
3.67469
3.77106
4.0395
4.65323
5.919
6.76046
6.82998
6.75909
6.53322
6.14751
5.80341
5.51887
5.27642
5.05984
4.85991
4.67188
4.49378
4.3245
4.16369
4.01085
3.86585
3.72817
3.5977
3.47378
3.35636
3.24472
3.13888
3.03817
2.94265
2.85177
2.76555
2.68363
2.60593
2.53222
2.46238
2.39624
2.33365
2.27463
2.21866
2.16457
2.11287
2.06412
2.01805
1.97439
1.93304
1.89388
1.8568
1.8217
1.78849
1.75711
1.72743
1.6996
1.6733
1.64911
1.62682
1.6067
1.59142
1.57756
1.5777
1.58129
1.59248
1.6221
1.68243
1.79956
1.95461
2.17832
2.4013
2.48998
2.53975
2.53855
2.53022
2.5107
2.4808
2.45017
2.4209
2.39375
2.36913
2.34576
2.32363
2.30131
2.27989
2.25693
2.23652
2.21437
1.27937
1.73792
2.62697
4.60722
5.25104
5.33194
5.28742
5.16998
4.9299
4.68127
4.46295
4.26932
4.09936
3.95762
3.90042
3.92311
4.0247
4.30921
4.96306
6.31538
7.24713
7.31379
7.23047
6.9753
6.55364
6.17912
5.87047
5.60784
5.37338
5.15661
4.95267
4.75917
4.5753
4.40038
4.23425
4.07643
3.92677
3.78472
3.65007
3.5222
3.40093
3.28562
3.17619
3.072
2.97307
2.87887
2.7894
2.70428
2.62347
2.54669
2.47383
2.40472
2.33917
2.27713
2.21831
2.16301
2.10947
2.0583
2.01002
1.96425
1.92084
1.8797
1.8407
1.80376
1.76877
1.73566
1.70432
1.67473
1.64673
1.6205
1.59574
1.57281
1.55202
1.5327
1.5188
1.50582
1.50654
1.51163
1.52223
1.55616
1.61639
1.73858
1.90277
2.12169
2.33055
2.41316
2.46002
2.45954
2.45223
2.43449
2.40641
2.37746
2.34981
2.32381
2.30026
2.27758
2.25668
2.23508
2.21621
2.19628
1.17403
1.36796
1.96808
3.19724
4.79345
5.20833
5.23419
5.17937
5.04649
4.80254
4.57526
4.38193
4.223
4.15832
4.18217
4.29089
4.59776
5.30539
6.77211
7.78199
7.83099
7.73056
7.4412
6.98259
6.57709
6.24341
5.9597
5.70609
5.47144
5.25028
5.04054
4.84101
4.65144
4.47122
4.30025
4.13793
3.98408
3.83808
3.69965
3.56817
3.44342
3.32477
3.21207
3.10475
3.00277
2.9056
2.81327
2.72534
2.6418
2.56233
2.48685
2.41514
2.34705
2.28242
2.22116
2.16297
2.10825
2.05548
2.00503
1.95739
1.91214
1.86919
1.82843
1.78976
1.75313
1.7184
1.68553
1.65442
1.62498
1.5972
1.5709
1.54621
1.52304
1.50132
1.48206
1.46375
1.45096
1.44008
1.44112
1.44617
1.46084
1.49314
1.56041
1.68355
1.85398
2.0733
2.26525
2.34156
2.38518
2.38583
2.37957
2.36288
2.33679
2.30967
2.28374
2.25896
2.23681
2.21512
2.19641
2.17802
1.08128
1.2212
1.48537
2.21408
3.74757
4.87799
5.14116
5.1361
5.0764
4.9347
4.70758
4.5132
4.42741
4.45208
4.56964
4.90251
5.67393
7.27115
8.34139
8.3688
8.24901
7.92533
7.43276
6.99659
6.6382
6.33323
6.05994
5.80611
5.56649
5.33883
5.12252
4.91691
4.72187
4.53672
4.36131
4.19489
4.03723
3.88761
3.74576
3.61098
3.48308
3.3614
3.24578
3.13565
3.03094
2.93114
2.83626
2.74586
2.65994
2.57813
2.50039
2.42643
2.35614
2.28933
2.22586
2.16562
2.10835
2.05443
2.00248
1.95306
1.90617
1.8616
1.81927
1.77907
1.74094
1.70476
1.67048
1.63797
1.60719
1.57807
1.55048
1.52444
1.49985
1.47663
1.4551
1.4346
1.41685
1.39989
1.38793
1.37991
1.38115
1.38767
1.4026
1.43987
1.5121
1.64422
1.81761
2.03134
2.20566
2.27715
2.31661
2.3179
2.31212
2.29682
2.2727
2.2475
2.22357
2.20028
2.18063
2.16192
1.04144
1.11583
1.23589
1.64001
2.38322
4.14032
4.9175
5.07122
5.05697
4.99524
4.85515
4.72191
4.74376
4.86796
5.22856
6.08004
7.83498
8.96494
8.95103
8.79365
8.41154
7.89508
7.43539
7.05461
6.72874
6.43517
6.1613
5.90177
5.65492
5.42015
5.1974
4.98613
4.78612
4.59657
4.41715
4.24702
4.08589
3.93295
3.78795
3.65021
3.51942
3.39498
3.27671
3.16406
3.05691
2.9548
2.85768
2.76513
2.67714
2.5933
2.5136
2.43771
2.36554
2.29688
2.23158
2.16949
2.1105
2.0544
2.00144
1.95052
1.90219
1.85623
1.81254
1.77101
1.73156
1.6941
1.65854
1.6248
1.59281
1.56248
1.53374
1.50654
1.48079
1.45643
1.43354
1.4118
1.39186
1.37281
1.35628
1.34136
1.32969
1.32533
1.32699
1.33458
1.35186
1.39286
1.47023
1.60809
1.78841
1.99758
2.15227
2.21903
2.25458
2.25654
2.2512
2.23711
2.21505
2.19202
2.17152
2.15124
1.02509
1.04977
1.13848
1.28674
1.73874
2.60452
4.36361
4.9169
5.02659
5.02276
5.00913
5.0338
5.17543
5.58072
6.53913
8.48389
9.59868
9.56756
9.36603
8.9132
8.37031
7.89147
7.49046
7.14429
6.83007
6.53524
6.25487
5.98763
5.73348
5.4923
5.26399
5.0479
4.84359
4.65016
4.46717
4.29373
4.12945
3.97356
3.82573
3.68525
3.55185
3.42491
3.30425
3.18933
3.08006
2.97594
2.87692
2.78255
2.69281
2.60729
2.52593
2.4484
2.37467
2.30444
2.23764
2.17403
2.11354
2.05598
2.00132
1.94934
1.8998
1.85263
1.80777
1.76508
1.72449
1.6859
1.64924
1.61441
1.58134
1.54994
1.52016
1.49192
1.46517
1.43981
1.41589
1.39321
1.37201
1.35189
1.33338
1.31617
1.30053
1.28813
1.27708
1.27614
1.27832
1.28816
1.30709
1.35416
1.44014
1.58318
1.76688
1.96949
2.10628
2.16872
2.20025
2.20257
2.1977
2.18493
2.16618
2.14691
1.01148
1.03104
1.06364
1.17129
1.37186
1.93334
3.11005
4.49066
4.9274
5.05581
5.16486
5.41682
5.95465
7.1004
9.31247
10.3352
10.2699
10.0019
9.44006
8.86533
8.37278
7.957
7.59056
7.25302
6.9339
6.62955
6.3395
6.06392
5.80296
5.55622
5.32323
5.10306
4.89506
4.69822
4.51202
4.33554
4.16837
4.00974
3.85929
3.71634
3.58054
3.45135
3.3285
3.21157
3.10036
2.99442
2.89365
2.79767
2.70638
2.6194
2.53669
2.45789
2.38288
2.3114
2.24335
2.1785
2.11678
2.05802
2.00207
1.94899
1.89835
1.85015
1.80427
1.76063
1.7191
1.6796
1.64202
1.60629
1.57231
1.54002
1.50933
1.48018
1.45253
1.4263
1.40149
1.37798
1.35588
1.33495
1.31537
1.29707
1.27988
1.26468
1.25018
1.23987
1.23115
1.23195
1.2354
1.24844
1.27054
1.32485
1.4182
1.56368
1.75266
1.94851
2.06807
2.12679
2.15413
2.15805
2.1542
2.14484
1.00705
1.01422
1.03836
1.07948
1.2116
1.45963
2.12406
3.48917
4.62686
5.04178
5.43208
6.21093
7.73733
10.2545
11.1474
11.0407
10.696
10.0008
9.37136
8.86308
8.43712
8.0552
7.69564
7.35101
7.02073
6.70582
6.40718
6.12495
5.85882
5.60783
5.37118
5.14769
4.93664
4.73697
4.54809
4.36909
4.19954
4.03863
3.886
3.741
3.60334
3.47246
3.34802
3.22956
3.11684
3.00954
2.90744
2.81024
2.71776
2.62967
2.54584
2.46595
2.3899
2.3174
2.24836
2.18253
2.11985
2.06011
2.00324
1.94912
1.89758
1.84849
1.8018
1.75734
1.71504
1.67477
1.63643
1.59994
1.5652
1.53215
1.50071
1.47083
1.44245
1.41553
1.39002
1.36582
1.34298
1.32138
1.30106
1.28202
1.26406
1.24762
1.23202
1.21846
1.20618
1.19665
1.19253
1.19367
1.19965
1.21136
1.24341
1.3026
1.4076
1.5546
1.74631
1.93664
2.03776
2.09627
2.11802
2.13312
1.0032
1.00859
1.01725
1.04663
1.09615
1.25576
1.55425
2.32898
3.90287
4.97361
6.03592
8.15719
11.3371
12.1259
11.9598
11.476
10.6048
9.91344
9.3804
8.94302
8.54574
8.16433
7.7937
7.43609
7.09469
6.7713
6.46638
6.17932
5.90919
5.65467
5.41475
5.18821
4.97428
4.77189
4.58046
4.39908
4.22727
4.06427
3.90966
3.76281
3.62333
3.49074
3.36466
3.24477
3.13071
3.0222
2.91896
2.82071
2.7272
2.63817
2.5534
2.47263
2.3957
2.32235
2.2525
2.18587
2.12242
2.06191
2.00432
1.94938
1.89712
1.84732
1.79998
1.7549
1.71201
1.67115
1.63224
1.59517
1.55986
1.52623
1.49422
1.46376
1.4348
1.40728
1.38116
1.3564
1.33298
1.31084
1.28997
1.27036
1.25188
1.23473
1.21861
1.20384
1.19038
1.17806
1.16867
1.16026
1.16046
1.1626
1.16955
1.18607
1.22175
1.29186
1.40481
1.5584
1.74383
1.93673
2.01554
2.09511
1.00177
1.0047
1.00947
1.02537
1.05164
1.13829
1.29292
1.75186
2.64824
4.72577
7.58505
12.3337
13.1163
12.8485
12.1582
11.2429
10.5404
9.99028
9.52567
9.08617
8.66369
8.25682
7.86715
7.49662
7.14653
6.81696
6.50727
6.21624
5.94261
5.68494
5.44221
5.21318
4.99703
4.79269
4.59949
4.41653
4.24325
4.07893
3.92306
3.77511
3.63459
3.50111
3.3742
3.2536
3.13886
3.02977
2.92594
2.82717
2.73312
2.64358
2.55829
2.47699
2.39954
2.32565
2.25526
2.18808
2.1241
2.06303
2.00491
1.94943
1.8967
1.84642
1.79856
1.75295
1.70953
1.66816
1.62878
1.59127
1.55554
1.52152
1.4891
1.45825
1.42889
1.40099
1.37447
1.34933
1.3255
1.30297
1.28169
1.26168
1.24284
1.22523
1.20878
1.19348
1.17945
1.1664
1.15503
1.14478
1.13692
1.13314
1.13394
1.13759
1.14689
1.16816
1.21151
1.29858
1.39748
1.58926
1.74752
1.97912
1.00132
1.00266
1.00732
1.01446
1.0418
1.08009
1.24661
1.52243
2.51123
4.83218
10.7495
13.7802
13.5014
12.7606
11.8999
11.2191
10.6552
10.1533
9.66925
9.19585
8.74191
8.31436
7.91347
7.53731
7.18413
6.85229
6.54041
6.24697
5.9709
5.71089
5.46598
5.23496
5.01699
4.81101
4.61631
4.43198
4.25742
4.09194
3.93498
3.78602
3.64455
3.5102
3.38246
3.26111
3.14566
3.03593
2.93148
2.83215
2.73757
2.64755
2.56179
2.48009
2.40226
2.32802
2.2573
2.18979
2.1255
2.06412
2.00569
1.94992
1.89685
1.84623
1.79804
1.7521
1.70836
1.66669
1.62698
1.58919
1.55314
1.51885
1.48614
1.45502
1.42538
1.39719
1.3704
1.34496
1.32085
1.29804
1.27648
1.25618
1.23708
1.21919
1.20248
1.18693
1.17256
1.15928
1.14724
1.13639
1.12675
1.11937
1.11331
1.11368
1.11552
1.12144
1.13334
1.1617
1.21297
1.3178
1.44093
1.69989
1.00111
1.00224
1.00623
1.01242
1.03663
1.06843
1.22876
1.461
2.524
4.9769
11.6003
13.0407
12.8231
12.3769
11.9084
11.4106
10.8746
10.3178
9.77562
9.26627
8.79293
8.3532
7.94425
7.56294
7.20615
6.87136
6.55682
6.26104
5.98288
5.72111
5.4747
5.24244
5.02344
4.81659
4.62113
4.43615
4.26102
4.09503
3.93762
3.78827
3.64645
3.51181
3.38381
3.26223
3.14657
3.03667
2.93206
2.83259
2.73786
2.64771
2.56181
2.47998
2.402
2.32762
2.25675
2.1891
2.12466
2.06313
2.00456
1.94864
1.89543
1.84467
1.79637
1.75033
1.70648
1.66473
1.62492
1.58704
1.55089
1.51653
1.48371
1.45253
1.4228
1.39454
1.36766
1.34214
1.31795
1.29504
1.2734
1.253
1.2338
1.21582
1.19901
1.18336
1.1689
1.1555
1.14337
1.13219
1.12245
1.11353
1.10688
1.10116
1.10152
1.10323
1.10841
1.11831
1.14266
1.18768
1.27849
1.47
3.06392
1.55572
1.04738
0.942491
0.96824
1.047
1.21278
1.34496
1.38604
1.3844
1.37913
1.37929
1.38126
1.38658
1.39739
1.40524
1.40782
1.40764
1.40702
1.40564
1.40382
1.40227
1.40089
1.3992
1.3971
1.39489
1.39411
1.39456
1.39658
1.40281
1.41917
1.45922
1.55344
1.7708
2.27365
3.2973
3.69948
3.67801
3.70183
3.72296
3.79145
3.90618
4.05305
4.19848
4.32329
4.41666
4.50355
4.55922
4.59399
4.6122
4.61794
4.61536
4.60552
4.5844
4.55627
4.52466
4.49097
4.45447
4.41539
4.37375
4.32967
4.28363
4.23575
4.18634
4.13581
4.08394
4.03159
3.97875
3.9256
3.87198
3.81857
3.76514
3.71177
3.65854
3.60548
3.55278
3.50036
3.44853
3.39716
3.3464
3.29627
3.24684
3.19802
3.1499
3.10236
3.05561
3.00944
2.96405
2.91927
2.87547
2.83225
2.7899
2.74817
2.70743
2.66752
2.62899
2.592
2.55784
2.52788
2.50681
3.71843
2.31611
1.71693
1.46598
1.34999
1.27844
1.26402
1.27193
1.29406
1.33967
1.38503
1.4038
1.40351
1.4022
1.4001
1.40043
1.40156
1.40405
1.4068
1.40678
1.40646
1.40549
1.40342
1.40019
1.39707
1.39438
1.39272
1.39309
1.39489
1.40035
1.4142
1.44762
1.52649
1.71049
2.13818
3.09236
3.71971
3.7032
3.69915
3.72609
3.79496
3.89544
4.02286
4.16696
4.29393
4.39657
4.47948
4.53687
4.57372
4.59349
4.60077
4.59942
4.59325
4.57752
4.5488
4.51619
4.48262
4.44662
4.40837
4.36715
4.32368
4.27791
4.23051
4.18142
4.13122
4.07982
4.02774
3.97511
3.92219
3.86894
3.81565
3.76235
3.70911
3.65599
3.60304
3.55043
3.49813
3.44635
3.39505
3.34438
3.29425
3.24484
3.19606
3.14796
3.10052
3.0539
3.00805
2.96286
2.91838
2.87441
2.83125
2.78877
2.7472
2.70635
2.66656
2.6278
2.59074
2.55604
2.52546
2.50373
4.54542
3.24224
2.42437
1.9081
1.57868
1.37482
1.25762
1.24501
1.2524
1.27385
1.31851
1.36075
1.3879
1.40075
1.40314
1.40283
1.402
1.40143
1.40151
1.40151
1.4014
1.40106
1.40023
1.3985
1.39579
1.39289
1.39003
1.38991
1.39067
1.39386
1.40257
1.42608
1.47864
1.60943
1.89811
2.56404
3.6115
3.77486
3.79965
3.84122
3.90298
3.98083
4.06973
4.16972
4.26646
4.36233
4.443
4.50236
4.54175
4.56335
4.57172
4.57097
4.56725
4.55694
4.5349
4.50243
4.46867
4.43326
4.39563
4.35527
4.31255
4.26754
4.22072
4.17228
4.12261
4.07188
4.02034
3.96822
3.9157
3.8629
3.80992
3.75689
3.70389
3.65098
3.59827
3.54581
3.49377
3.44212
3.39108
3.34057
3.2907
3.24145
3.193
3.1452
3.09818
3.0516
3.00576
2.96053
2.9161
2.87223
2.82923
2.78682
2.74535
2.70451
2.66476
2.62587
2.5886
2.55334
2.52197
2.49845
4.99809
3.82353
2.9537
2.34794
1.94206
1.66924
1.49828
1.39167
1.32999
1.31426
1.31767
1.32906
1.35327
1.38141
1.40082
1.41087
1.4108
1.41009
1.40834
1.40524
1.40331
1.40216
1.40128
1.40028
1.39852
1.39597
1.39276
1.39011
1.39042
1.39195
1.39791
1.41099
1.44858
1.52968
1.73214
2.18664
3.20625
3.79437
4.03514
4.12466
4.1677
4.19629
4.20542
4.21622
4.24324
4.29868
4.36831
4.4324
4.48396
4.51575
4.53042
4.53196
4.52992
4.52349
4.50888
4.48064
4.44759
4.41249
4.37556
4.33643
4.29503
4.25133
4.20564
4.15825
4.10952
4.05966
4.00897
3.95758
3.90573
3.85348
3.80104
3.74843
3.69586
3.64329
3.59097
3.53883
3.48716
3.43583
3.38508
3.33488
3.28549
3.2366
3.18841
3.14074
3.09385
3.04744
3.00182
2.95674
2.91252
2.86882
2.82602
2.7837
2.74237
2.70157
2.66188
2.6229
2.58546
2.54969
2.51737
2.49204
5.27096
4.2438
3.40835
2.77522
2.31291
1.97671
1.73297
1.55883
1.4372
1.36078
1.32043
1.32044
1.32386
1.33372
1.35409
1.37434
1.38908
1.39825
1.40087
1.40054
1.39948
1.39724
1.39456
1.39226
1.39029
1.38848
1.38709
1.38523
1.38537
1.38646
1.38895
1.39948
1.41799
1.478
1.59385
1.88942
2.50746
3.68464
4.37406
4.59508
4.59025
4.54686
4.43768
4.30836
4.24871
4.25246
4.27372
4.32371
4.38798
4.43743
4.46835
4.48241
4.48221
4.47942
4.47112
4.45269
4.42192
4.38685
4.35014
4.31195
4.27195
4.22988
4.18584
4.13998
4.09259
4.04391
3.99427
3.9438
3.89276
3.84121
3.78941
3.73737
3.68534
3.63323
3.58143
3.52972
3.47852
3.42775
3.37767
3.32799
3.27901
3.23042
3.18253
3.13508
3.08843
3.04225
2.99691
2.95202
2.90806
2.86452
2.82195
2.7798
2.73866
2.69799
2.65841
2.61947
2.58193
2.54584
2.51296
2.48608
5.45694
4.56565
3.79002
3.16119
2.6702
2.29315
2.00588
1.78922
1.62705
1.5101
1.42543
1.37172
1.34284
1.34037
1.34279
1.35001
1.36509
1.38179
1.39464
1.40286
1.40425
1.40384
1.4026
1.3999
1.39592
1.39225
1.38918
1.38641
1.3852
1.38566
1.38738
1.3935
1.40699
1.44367
1.52382
1.7199
2.16319
3.18033
4.68728
5.2003
5.14489
4.98543
4.69381
4.45074
4.29451
4.22903
4.22114
4.22825
4.2539
4.3069
4.35728
4.39483
4.4143
4.4182
4.4158
4.40743
4.38854
4.35651
4.32017
4.28219
4.24293
4.20231
4.16022
4.11646
4.07102
4.02406
3.97588
3.92663
3.87663
3.82596
3.77496
3.72361
3.67225
3.6207
3.56953
3.51867
3.46828
3.41816
3.36863
3.31936
3.27075
3.22245
3.17491
3.12773
3.08142
3.03548
2.99047
2.94583
2.90216
2.85887
2.81656
2.77466
2.73374
2.69329
2.65384
2.61502
2.57746
2.54118
2.50797
2.47994
5.58462
4.8101
4.10288
3.49784
2.99978
2.59866
2.27955
2.02734
1.82856
1.67353
1.55326
1.46483
1.39991
1.36188
1.34197
1.34205
1.34413
1.34993
1.36188
1.3744
1.38372
1.39015
1.3907
1.39039
1.3894
1.38731
1.3842
1.38124
1.37965
1.38002
1.38162
1.38636
1.39808
1.4269
1.49253
1.64906
2.01112
2.86563
4.72915
5.84257
5.7582
5.50569
5.07213
4.70651
4.44695
4.28681
4.20556
4.17939
4.17689
4.18552
4.21157
4.26226
4.30341
4.33327
4.34419
4.34282
4.33632
4.32043
4.28872
4.25208
4.21264
4.1723
4.13136
4.08935
4.04596
4.00105
3.95477
3.9071
3.8584
3.80878
3.75866
3.70808
3.65747
3.60692
3.55664
3.50649
3.45682
3.40725
3.35824
3.30939
3.26124
3.21332
3.16621
3.1194
3.07347
3.02787
2.9832
2.9389
2.89552
2.85257
2.81052
2.76894
2.72824
2.68807
2.64879
2.61016
2.57268
2.53633
2.50298
2.47417
5.6777
4.9957
4.35235
3.77991
3.28965
2.87959
2.54174
2.26558
2.04107
1.85971
1.71378
1.59808
1.50782
1.44057
1.39123
1.36296
1.3473
1.34738
1.34911
1.35398
1.36404
1.37527
1.38408
1.39068
1.39093
1.3904
1.38889
1.38577
1.38232
1.38248
1.3836
1.3892
1.39934
1.43144
1.49069
1.64489
1.95502
2.66513
4.13896
5.90526
5.98397
5.84964
5.5191
5.11685
4.74784
4.4861
4.3045
4.19272
4.14257
4.12419
4.12493
4.13449
4.15988
4.20732
4.23854
4.25929
4.26018
4.25655
4.24481
4.21934
4.18253
4.14223
4.10102
4.05916
4.01677
3.97354
3.92929
3.88354
3.8366
3.78839
3.73936
3.68988
3.64043
3.59083
3.5415
3.49206
3.44307
3.39408
3.34567
3.29736
3.24974
3.20233
3.15571
3.10937
3.06387
3.01873
2.97443
2.93056
2.88754
2.84498
2.80325
2.76203
2.72162
2.68176
2.64273
2.60433
2.567
2.53068
2.49731
2.46801
5.74508
5.13907
4.55375
4.0171
3.54292
3.13408
2.78718
2.49591
2.2527
2.05079
1.88342
1.74564
1.633
1.54205
1.4706
1.41679
1.37792
1.3565
1.34565
1.34583
1.34735
1.35139
1.3596
1.36789
1.37381
1.37783
1.37974
1.3797
1.37974
1.3805
1.38276
1.39095
1.4078
1.4517
1.54132
1.74107
2.14143
2.94152
3.70299
4.69566
5.52058
5.67651
5.6164
5.42991
5.08873
4.79998
4.52426
4.32923
4.19606
4.11381
4.08126
4.0655
4.06735
4.07816
4.10374
4.14084
4.16252
4.1723
4.17054
4.16313
4.14564
4.11125
4.07219
4.02962
3.98672
3.94383
3.90077
3.85668
3.81165
3.76519
3.71811
3.67003
3.62183
3.5732
3.52473
3.47604
3.42773
3.37941
3.33163
3.28398
3.23696
3.19017
3.14408
3.09832
3.05329
3.00866
2.96481
2.9214
2.87878
2.83665
2.79529
2.75445
2.71438
2.67485
2.63612
2.59796
2.56087
2.52462
2.49136
2.46173
5.79763
5.25188
4.717
4.21581
3.76183
3.36071
3.012
2.71253
2.45694
2.24014
2.05659
1.90192
1.77194
1.66362
1.57429
1.50165
1.44515
1.40175
1.37075
1.35342
1.34462
1.34481
1.34617
1.34976
1.35708
1.36503
1.37167
1.37601
1.37849
1.38195
1.38946
1.4051
1.44051
1.51496
1.67448
1.99853
2.64806
3.19885
3.52436
3.92004
4.43964
5.01676
5.35017
5.32969
5.24
5.04627
4.78992
4.57223
4.36218
4.21134
4.10999
4.04671
4.02094
4.00416
4.00606
4.01508
4.03526
4.06187
4.07674
4.0776
4.07425
4.06318
4.03919
4.00053
3.95828
3.91461
3.87098
3.82719
3.78335
3.73869
3.69348
3.64725
3.60055
3.55313
3.50563
3.4578
3.41025
3.36267
3.31558
3.26865
3.22231
3.17621
3.13076
3.08563
3.04119
2.99713
2.95381
2.91091
2.86879
2.82712
2.78623
2.7458
2.70616
2.66698
2.62864
2.59075
2.55397
2.51785
2.48476
2.4549
5.83728
5.34166
4.85081
4.38343
3.95188
3.56273
3.21752
2.91517
2.65226
2.42516
2.22945
2.0615
1.91748
1.79461
1.69012
1.60202
1.52882
1.46888
1.42186
1.38615
1.36122
1.34713
1.34064
1.34087
1.34221
1.34551
1.35219
1.36007
1.36868
1.37832
1.39409
1.42582
1.49303
1.63098
1.91563
2.48964
3.08028
3.33927
3.45794
3.6
3.81343
4.11444
4.5354
4.86226
5.02036
5.00005
4.9229
4.75339
4.56597
4.40182
4.24002
4.11572
4.03319
3.97917
3.95416
3.93512
3.9368
3.94331
3.9572
3.97566
3.98291
3.98139
3.97503
3.95924
3.92742
3.88674
3.84234
3.79763
3.75385
3.71011
3.66628
3.62167
3.57658
3.53063
3.48442
3.43769
3.39111
3.34441
3.29814
3.25199
3.2064
3.16103
3.11629
3.07182
3.02803
2.98458
2.94185
2.8995
2.85792
2.81673
2.77634
2.73635
2.69717
2.65837
2.62044
2.58288
2.54644
2.51052
2.47767
2.44764
5.87021
5.41434
4.96144
4.52552
4.11685
3.74216
3.4039
3.10257
2.83615
2.60237
2.39775
2.2195
2.06426
1.9296
1.81292
1.71235
1.6262
1.55316
1.49224
1.44239
1.40334
1.37371
1.35331
1.34152
1.33797
1.3387
1.34135
1.34742
1.35978
1.37846
1.40854
1.46953
1.5929
1.84545
2.35417
3.00884
3.30936
3.40168
3.43288
3.47051
3.53341
3.64193
3.81524
4.05048
4.37108
4.61695
4.74567
4.73016
4.67253
4.54549
4.39064
4.25974
4.13407
4.02396
3.94985
3.904
3.87672
3.85744
3.85862
3.86329
3.87306
3.88556
3.88531
3.8823
3.87292
3.85188
3.81318
3.77012
3.7258
3.68145
3.63766
3.59373
3.5498
3.5052
3.46041
3.41507
3.36978
3.32423
3.27901
3.2338
3.18907
3.14451
3.10052
3.05677
3.01367
2.97086
2.92876
2.88699
2.84599
2.80535
2.76549
2.726
2.68729
2.64895
2.61143
2.57426
2.53818
2.50251
2.46993
2.43976
5.89539
5.47316
5.055
4.64881
4.26268
3.90345
3.57432
3.27656
3.00953
2.77171
2.56089
2.37462
2.21051
2.06608
1.93939
1.82833
1.73151
1.64732
1.57493
1.51311
1.46157
1.41936
1.38631
1.36207
1.34496
1.34079
1.34217
1.34685
1.35971
1.38446
1.43862
1.54483
1.76547
2.20635
2.88287
3.28032
3.40122
3.42086
3.42007
3.41537
3.40714
3.41555
3.44992
3.5305
3.68861
3.90456
4.1827
4.38959
4.51074
4.49999
4.46001
4.37504
4.23874
4.12878
4.02749
3.92956
3.86338
3.82239
3.79412
3.77408
3.77505
3.77862
3.78494
3.78927
3.7878
3.78197
3.76771
3.73831
3.69845
3.65435
3.61012
3.5659
3.5221
3.47813
3.4344
3.39038
3.3465
3.30236
3.25839
3.21432
3.17056
3.12691
3.08371
3.04074
2.99833
2.95622
2.91476
2.87363
2.83321
2.79315
2.75382
2.71486
2.67664
2.63879
2.60171
2.56496
2.52928
2.4939
2.46164
2.43135
5.92499
5.531
5.14072
4.75905
4.39348
4.04917
3.7298
3.43706
3.17123
2.93152
2.71654
2.52442
2.35327
2.20109
2.06605
1.94636
1.84063
1.74726
1.66549
1.59393
1.53221
1.47953
1.43546
1.40021
1.373
1.35818
1.35947
1.36503
1.38409
1.42087
1.51017
1.68535
2.04921
2.71487
3.21001
3.39192
3.42423
3.42194
3.40986
3.38005
3.32382
3.27792
3.27731
3.28809
3.3247
3.4062
3.56018
3.75212
3.98275
4.16398
4.29103
4.2903
4.27024
4.2166
4.10802
4.00587
3.91665
3.83788
3.77577
3.73462
3.70712
3.68859
3.68794
3.68926
3.69238
3.69188
3.68872
3.67957
3.6596
3.62268
3.58125
3.53759
3.49361
3.44964
3.40638
3.36337
3.32075
3.27809
3.23554
3.19288
3.15036
3.10784
3.0656
3.02353
2.98189
2.94053
2.89973
2.85927
2.81945
2.78001
2.74124
2.70284
2.66515
2.62779
2.5912
2.55487
2.51964
2.48455
2.45267
2.42232
5.96348
5.5895
5.22183
4.8609
4.51284
4.18239
3.87235
3.58527
3.32167
3.08162
2.864
2.66788
2.49128
2.33305
2.19121
2.06439
1.95129
1.85022
1.76067
1.68099
1.61095
1.54965
1.4964
1.45247
1.41569
1.39557
1.39756
1.40786
1.43409
1.50354
1.6425
1.94242
2.53727
3.10077
3.36263
3.42309
3.42201
3.41141
3.38213
3.32227
3.2592
3.20643
3.16874
3.14633
3.14963
3.16383
3.20044
3.27598
3.40769
3.57361
3.76885
3.94307
4.07004
4.10695
4.09581
4.06165
3.98646
3.89039
3.81209
3.74354
3.68444
3.64445
3.61732
3.60009
3.59657
3.59697
3.59683
3.5951
3.58902
3.57418
3.54394
3.50515
3.46339
3.42037
3.37762
3.33526
3.29352
3.25201
3.21077
3.16951
3.12835
3.08712
3.04606
3.00503
2.96433
2.9238
2.88376
2.84398
2.80482
2.76597
2.72781
2.68995
2.65282
2.61595
2.57989
2.54399
2.50925
2.47447
2.44302
2.41264
6.02194
5.65397
5.30101
4.95758
4.6238
4.30418
4.00285
3.72148
3.46096
3.22187
3.00299
2.80436
2.62392
2.46095
2.3139
2.18113
2.06202
1.95443
1.85836
1.77184
1.69482
1.62652
1.56561
1.51583
1.47078
1.45637
1.4605
1.48052
1.52424
1.64901
1.88649
2.40008
3.00681
3.33285
3.42773
3.42669
3.41569
3.38542
3.32344
3.25766
3.20114
3.15184
3.10818
3.0701
3.04206
3.02231
3.02506
3.03685
3.06632
3.12724
3.23776
3.38322
3.55263
3.7245
3.85131
3.93572
3.93038
3.91092
3.87168
3.79438
3.71332
3.64551
3.59239
3.55236
3.5234
3.50882
3.50673
3.50638
3.50475
3.4997
3.48767
3.46257
3.42875
3.39011
3.34936
3.30782
3.26647
3.22539
3.18483
3.14451
3.10453
3.06457
3.02481
2.98498
2.94542
2.90585
2.86671
2.82769
2.78926
2.75102
2.71349
2.67617
2.63962
2.60324
2.56772
2.53227
2.49803
2.46361
2.4326
2.40224
6.10634
5.72373
5.37719
5.04501
4.72375
4.41545
4.12205
3.84688
3.58972
3.35266
3.13381
2.93372
2.75101
2.58435
2.43343
2.29579
2.17175
2.05876
1.95708
1.86487
1.78191
1.70779
1.64136
1.58701
1.54123
1.54199
1.55317
1.58443
1.68482
1.87892
2.31415
2.96028
3.33281
3.45626
3.45507
3.44246
3.40544
3.33079
3.25836
3.19797
3.14757
3.10125
3.05768
3.01621
2.97726
2.94245
2.91572
2.89405
2.89579
2.90377
2.9252
2.97137
3.06338
3.18891
3.34162
3.50507
3.6473
3.74946
3.78683
3.77876
3.7523
3.69409
3.61911
3.55087
3.49555
3.45332
3.42784
3.41715
3.41356
3.41155
3.40722
3.39771
3.37875
3.35044
3.3164
3.27873
3.23936
3.19917
3.15911
3.11923
3.07991
3.04079
3.0021
2.96339
2.92501
2.88652
2.84843
2.8103
2.7727
2.73517
2.69831
2.66157
2.62559
2.58974
2.55474
2.51977
2.48603
2.45198
2.42144
2.39111
6.19149
5.79935
5.45036
5.12566
4.81424
4.51615
4.23136
3.96256
3.70976
3.47486
3.25743
3.05663
2.87268
2.70354
2.54937
2.40821
2.27969
2.16251
2.05579
1.95893
1.87102
1.79196
1.72343
1.66429
1.64082
1.64677
1.67474
1.74444
1.92344
2.28267
2.95823
3.38055
3.52319
3.52104
3.50397
3.45466
3.36814
3.28976
3.21999
3.1587
3.1038
3.05468
3.01046
2.9674
2.92577
2.88597
2.84818
2.81466
2.78711
2.76538
2.76214
2.76695
2.78287
2.81828
2.89143
2.99919
3.13623
3.29132
3.44774
3.56552
3.64838
3.64591
3.6315
3.60046
3.53675
3.46497
3.40702
3.36485
3.33867
3.32475
3.31767
3.3128
3.30551
3.29084
3.26887
3.24031
3.20718
3.17079
3.13285
3.09404
3.05533
3.01669
2.97863
2.94068
2.90324
2.86574
2.82869
2.79152
2.75487
2.71816
2.68207
2.646
2.61065
2.57537
2.54092
2.50644
2.47323
2.43958
2.40953
2.37928
6.31796
5.89299
5.52644
5.20177
4.89771
4.60823
4.33171
4.07008
3.82266
3.59045
3.37467
3.17433
2.9894
2.81894
2.66201
2.51815
2.38592
2.26508
2.15427
2.05338
1.96148
1.87998
1.80965
1.76217
1.76492
1.78397
1.84604
1.99688
2.32229
2.97774
3.46837
3.63754
3.63441
3.61184
3.54931
3.44738
3.35361
3.27376
3.20368
3.14076
3.08209
3.0267
2.9745
2.92625
2.88179
2.83881
2.79737
2.75786
2.72063
2.68766
2.65891
2.63782
2.62785
2.63088
2.64218
2.6689
2.72572
2.81758
2.93891
3.08893
3.24778
3.38999
3.49501
3.53549
3.52617
3.49861
3.44127
3.37445
3.32288
3.28109
3.25209
3.23488
3.2241
3.21452
3.20246
3.18497
3.162
3.13364
3.1015
3.06638
3.02987
2.9924
2.95502
2.91758
2.88074
2.84391
2.80768
2.77139
2.73566
2.69984
2.6646
2.62932
2.5947
2.56006
2.52624
2.4923
2.45966
2.42644
2.3969
2.36677
6.34676
5.98755
5.60779
5.27785
4.97686
4.69437
4.42537
4.16981
3.92857
3.70056
3.48665
3.28731
3.10197
2.93047
2.7717
2.62534
2.49038
2.36622
2.25217
2.14813
2.05339
1.97325
1.90441
1.89942
1.91321
1.95945
2.10759
2.39654
3.03031
3.59821
3.80246
3.79865
3.77121
3.6963
3.56424
3.44692
3.35121
3.27046
3.19951
3.13541
3.07378
3.01423
2.95658
2.90121
2.84943
2.80149
2.75602
2.71269
2.67138
2.6321
2.59549
2.56262
2.53343
2.51248
2.49671
2.49872
2.50684
2.52657
2.56716
2.64496
2.75424
2.89681
3.05644
3.22055
3.34581
3.42332
3.41586
3.39328
3.35018
3.29041
3.24085
3.19856
3.16774
3.1471
3.13202
3.11804
3.10238
3.08276
3.05907
3.03079
2.99954
2.96546
2.93022
2.89398
2.85788
2.8216
2.78595
2.75029
2.71529
2.68026
2.64587
2.61141
2.5776
2.54372
2.5106
2.4773
2.44528
2.41255
2.38357
2.35361
6.31297
6.1011
5.70748
5.36036
5.05773
4.77991
4.51588
4.26552
4.02871
3.80531
3.59427
3.39611
3.211
3.03872
2.87864
2.73029
2.59301
2.46624
2.3497
2.24337
2.1502
2.0711
2.0434
2.05404
2.09739
2.22645
2.50761
3.11039
3.76809
4.01481
4.01041
3.9778
3.88849
3.73129
3.59014
3.47293
3.37421
3.28793
3.21029
3.13861
3.07219
3.01046
2.94914
2.88957
2.83166
2.77639
2.72501
2.67747
2.6322
2.58917
2.54839
2.50973
2.47393
2.44105
2.4123
2.39009
2.3718
2.3716
2.37574
2.38996
2.42096
2.48568
2.5845
2.71761
2.87824
3.05527
3.20408
3.30863
3.30482
3.28978
3.26036
3.20254
3.15527
3.11419
3.08317
3.05998
3.04127
3.02366
3.00533
2.98379
2.95962
2.93119
2.90078
2.8676
2.83351
2.79849
2.76365
2.72863
2.69422
2.65983
2.62612
2.59244
2.55939
2.52632
2.49396
2.46141
2.43008
2.39795
2.36958
2.33988
6.2206
6.09897
5.82398
5.45853
5.14245
4.86281
4.60448
4.35929
4.1256
3.9049
3.69699
3.5008
3.31623
3.14382
2.98277
2.83306
2.69397
2.56542
2.44725
2.34225
2.25177
2.20418
2.2116
2.25026
2.36129
2.63372
3.2053
3.9638
4.26497
4.26076
4.22405
4.12025
3.93853
3.77466
3.63788
3.52101
3.41785
3.32437
3.23841
3.15838
3.0836
3.01313
2.94726
2.88562
2.82364
2.76402
2.70678
2.65281
2.60261
2.55568
2.51127
2.46911
2.42913
2.39139
2.3564
2.32395
2.29589
2.27219
2.25438
2.2484
2.25139
2.26218
2.28675
2.33919
2.42786
2.55073
2.71264
2.90016
3.07389
3.19183
3.20127
3.19085
3.16481
3.1128
3.0683
3.03013
2.99877
2.973
2.9513
2.93071
2.9104
2.88737
2.86283
2.83451
2.8047
2.77256
2.73968
2.70598
2.67248
2.63882
2.60573
2.57271
2.54031
2.50799
2.47637
2.44457
2.41401
2.38254
2.35486
2.32555
6.11639
6.06172
5.89569
5.56038
5.23386
4.94871
4.69074
4.44929
4.22004
4.00185
3.79563
3.6015
3.41827
3.24589
3.08447
2.9336
2.79355
2.66389
2.54729
2.44613
2.37947
2.38413
2.41719
2.51862
2.78045
3.33112
4.19265
4.5506
4.54661
4.50556
4.38564
4.17914
3.99274
3.83632
3.70209
3.58249
3.47345
3.37235
3.2781
3.18966
3.10663
3.02844
2.95505
2.88554
2.82118
2.75912
2.69832
2.63979
2.58394
2.53181
2.4834
2.43751
2.39411
2.35307
2.3142
2.27765
2.24354
2.21197
2.18443
2.16003
2.14277
2.13235
2.1344
2.14269
2.16226
2.20561
2.2839
2.39865
2.56228
2.75985
2.95333
3.07619
3.10169
3.09309
3.06945
3.02336
2.98235
2.94588
2.91367
2.88562
2.86173
2.83907
2.81737
2.79347
2.76861
2.7408
2.71156
2.6806
2.64901
2.61676
2.58464
2.55242
2.52069
2.48903
2.45808
2.42698
2.39716
2.36639
2.33942
2.31061
5.91561
5.95653
5.88158
5.68753
5.34697
5.04452
4.77996
4.53846
4.3121
4.09688
3.89207
3.69895
3.51718
3.34561
3.18405
3.03286
2.89255
2.76402
2.65397
2.56765
2.56963
2.59661
2.6908
2.93166
3.44934
4.42465
4.85862
4.85543
4.81135
4.67991
4.44751
4.23766
4.06196
3.91065
3.77548
3.65132
3.53588
3.42744
3.32555
3.22938
3.13881
3.05336
2.97284
2.89691
2.82549
2.75823
2.69554
2.63412
2.57495
2.51819
2.46439
2.41424
2.36743
2.32319
2.28129
2.24164
2.20408
2.16883
2.13574
2.10528
2.07818
2.0539
2.03683
2.02336
2.02485
2.03127
2.04753
2.08331
2.15254
2.26316
2.42734
2.63166
2.84555
2.96646
3.0036
2.99593
2.9749
2.93397
2.89645
2.86068
2.82767
2.79832
2.77315
2.74929
2.72659
2.70248
2.6773
2.65017
2.62178
2.59209
2.56184
2.53106
2.50036
2.46955
2.43932
2.40891
2.37977
2.3497
2.3234
2.29517
5.42853
5.83991
5.82016
5.71281
5.47256
5.15421
4.87547
4.62922
4.40286
4.1902
3.98862
3.79641
3.61414
3.44282
3.2818
3.1312
2.99219
2.87206
2.77153
2.76589
2.78985
2.87983
3.11878
3.63405
4.66649
5.17689
5.18789
5.14312
4.99902
4.73999
4.5064
4.31096
4.14283
3.9921
3.85342
3.72371
3.60176
3.48644
3.37759
3.27451
3.17724
3.08522
2.99839
2.91637
2.83894
2.76599
2.69709
2.6326
2.57169
2.51193
2.45468
2.40006
2.34897
2.30123
2.25612
2.21345
2.17308
2.13491
2.09882
2.06494
2.03307
2.00382
1.97729
1.9537
1.93649
1.92148
1.9224
1.92751
1.94081
1.97189
2.03474
2.14443
2.30564
2.51335
2.74436
2.86016
2.90462
2.89837
2.88079
2.84621
2.81039
2.77504
2.74197
2.71231
2.68637
2.66209
2.63855
2.61442
2.5894
2.56305
2.53566
2.50727
2.4784
2.44903
2.41989
2.39038
2.36202
2.33265
2.30703
2.27939
4.37173
5.56496
5.7353
5.6891
5.55305
5.27183
4.97912
4.72442
4.49562
4.28302
4.08217
3.89157
3.71071
3.53954
3.37909
3.23012
3.09947
2.98985
2.9704
2.99346
3.08335
3.32576
3.86073
4.94488
5.53074
5.55628
5.50607
5.34406
5.05641
4.79748
4.58158
4.39605
4.22985
4.07647
3.93285
3.79722
3.66895
3.54727
3.43216
3.32297
3.21977
3.12195
3.02949
2.94194
2.85919
2.78095
2.70701
2.63734
2.57141
2.50992
2.45057
2.39331
2.33848
2.28651
2.23807
2.19239
2.14922
2.10838
2.06976
2.03321
1.99867
1.96621
1.93562
1.90758
1.8818
1.85909
1.84171
1.82666
1.82656
1.83006
1.84248
1.87031
1.9294
2.04051
2.20367
2.40786
2.64803
2.75889
2.80747
2.80279
2.78848
2.75934
2.72481
2.69037
2.65774
2.62826
2.60204
2.57753
2.5538
2.52985
2.50532
2.47981
2.45357
2.42641
2.39907
2.37097
2.34376
2.31531
2.29046
2.26351
2.75736
4.93573
5.57611
5.61587
5.55085
5.39072
5.10062
4.83072
4.59232
4.37667
4.17543
3.98546
3.80539
3.6356
3.47711
3.33674
3.21866
3.18705
3.20928
3.30028
3.54878
4.11002
5.25155
5.91742
5.95905
5.90206
5.71777
5.39803
5.11143
4.8734
4.66974
4.48741
4.31916
4.16122
4.01195
3.87034
3.73607
3.60856
3.48781
3.37316
3.26469
3.16171
3.06426
2.97181
2.88429
2.80136
2.72287
2.64861
2.5784
2.51212
2.44963
2.39096
2.33362
2.27879
2.2266
2.17772
2.13172
2.08822
2.04705
2.00808
1.97122
1.93634
1.90338
1.87242
1.84321
1.81642
1.79163
1.7698
1.75268
1.7379
1.73709
1.74038
1.75197
1.77908
1.83714
1.94931
2.11233
2.32333
2.55877
2.66365
2.71433
2.71096
2.69885
2.67399
2.64079
2.60742
2.57564
2.54667
2.52062
2.49623
2.47273
2.44919
2.42541
2.4008
2.37586
2.34983
2.32435
2.29733
2.27355
2.24759
2.10203
3.51977
5.14106
5.50901
5.50176
5.42278
5.23809
4.95308
4.69881
4.4743
4.26974
4.07799
3.89928
3.73189
3.58214
3.45584
3.41488
3.4367
3.52927
3.78512
4.36572
5.55397
6.32187
6.38215
6.31893
6.11488
5.76273
5.44752
5.18647
4.96357
4.76447
4.58058
4.40793
4.24443
4.0893
3.94187
3.802
3.66915
3.54329
3.42375
3.31057
3.20303
3.10118
3.00437
2.91263
2.8255
2.74291
2.6646
2.59042
2.52017
2.45382
2.39091
2.33204
2.27545
2.22092
2.16885
2.11992
2.07379
2.03012
1.98877
1.94963
1.91257
1.8775
1.84434
1.81299
1.78357
1.75578
1.73029
1.70666
1.68571
1.66932
1.65497
1.65423
1.65754
1.66882
1.69662
1.7546
1.86809
2.02676
2.24833
2.47735
2.57397
2.62503
2.62274
2.61256
2.59069
2.5591
2.52703
2.49641
2.46825
2.44278
2.41881
2.39585
2.37289
2.3501
2.32635
2.30304
2.27801
2.25573
2.23137
1.62575
2.32886
4.18698
5.23871
5.42209
5.39542
5.2959
5.0804
4.81112
4.57364
4.36304
4.172
3.99451
3.83593
3.70135
3.65262
3.67469
3.77105
4.03949
4.65323
5.91898
6.76046
6.82998
6.75909
6.53323
6.14751
5.80342
5.51887
5.27643
5.05984
4.85991
4.67188
4.49378
4.3245
4.16369
4.01085
3.86585
3.72817
3.5977
3.47378
3.35636
3.24472
3.13888
3.03817
2.94265
2.85177
2.76555
2.68363
2.60593
2.53222
2.46238
2.39624
2.33365
2.27463
2.21866
2.16457
2.11287
2.06412
2.01805
1.9744
1.93304
1.89388
1.8568
1.8217
1.78849
1.75711
1.72743
1.6996
1.6733
1.64911
1.62682
1.6067
1.59142
1.57756
1.5777
1.58129
1.59248
1.6221
1.68242
1.79955
1.9546
2.17831
2.4013
2.48998
2.53975
2.53855
2.53022
2.5107
2.4808
2.45017
2.4209
2.39375
2.36913
2.34576
2.32363
2.30131
2.2799
2.25693
2.23652
2.21437
1.27937
1.73792
2.62697
4.60722
5.25104
5.33194
5.28742
5.16998
4.9299
4.68127
4.46295
4.26932
4.09936
3.95762
3.90042
3.92311
4.0247
4.3092
4.96305
6.31537
7.24713
7.31379
7.23048
6.9753
6.55365
6.17912
5.87047
5.60784
5.37339
5.15661
4.95267
4.75917
4.5753
4.40038
4.23425
4.07643
3.92677
3.78472
3.65007
3.5222
3.40093
3.28562
3.17619
3.072
2.97307
2.87887
2.7894
2.70429
2.62347
2.5467
2.47383
2.40472
2.33917
2.27713
2.21832
2.16301
2.10947
2.0583
2.01002
1.96425
1.92084
1.8797
1.8407
1.80376
1.76877
1.73566
1.70432
1.67473
1.64673
1.6205
1.59574
1.57281
1.55202
1.5327
1.5188
1.50582
1.50654
1.51163
1.52223
1.55615
1.61639
1.73857
1.90276
2.12168
2.33055
2.41316
2.46002
2.45954
2.45224
2.43449
2.40641
2.37746
2.34981
2.32381
2.30026
2.27758
2.25668
2.23508
2.21621
2.19628
1.17403
1.36797
1.96808
3.19723
4.79345
5.20833
5.23419
5.17937
5.04649
4.80254
4.57526
4.38193
4.223
4.15832
4.18216
4.29089
4.59775
5.30538
6.77209
7.78198
7.83099
7.73056
7.44121
6.98259
6.5771
6.24341
5.9597
5.70609
5.47144
5.25028
5.04054
4.84102
4.65144
4.47122
4.30025
4.13793
3.98409
3.83808
3.69965
3.56817
3.44342
3.32477
3.21207
3.10475
3.00277
2.9056
2.81327
2.72534
2.6418
2.56233
2.48685
2.41514
2.34705
2.28242
2.22116
2.16298
2.10825
2.05548
2.00503
1.95739
1.91214
1.86919
1.82843
1.78976
1.75313
1.7184
1.68553
1.65442
1.62498
1.5972
1.5709
1.54621
1.52304
1.50132
1.48206
1.46375
1.45096
1.44008
1.44112
1.44617
1.46084
1.49315
1.5604
1.68355
1.85397
2.07329
2.26525
2.34156
2.38518
2.38583
2.37957
2.36288
2.33679
2.30967
2.28374
2.25896
2.23681
2.21512
2.19641
2.17802
1.08128
1.2212
1.48537
2.21408
3.74757
4.87799
5.14116
5.1361
5.0764
4.9347
4.70758
4.5132
4.42741
4.45207
4.56964
4.9025
5.67392
7.27113
8.34138
8.3688
8.24901
7.92534
7.43277
6.99659
6.6382
6.33324
6.05994
5.80611
5.56649
5.33883
5.12252
4.91691
4.72187
4.53672
4.36131
4.19489
4.03723
3.88761
3.74576
3.61098
3.48308
3.3614
3.24578
3.13565
3.03094
2.93114
2.83627
2.74586
2.65994
2.57813
2.50039
2.42643
2.35614
2.28933
2.22586
2.16562
2.10835
2.05443
2.00248
1.95306
1.90617
1.8616
1.81927
1.77907
1.74094
1.70476
1.67048
1.63797
1.60719
1.57807
1.55048
1.52444
1.49985
1.47663
1.4551
1.4346
1.41685
1.39989
1.38793
1.37991
1.38115
1.38767
1.4026
1.43987
1.5121
1.64422
1.81761
2.03133
2.20566
2.27715
2.31661
2.3179
2.31212
2.29682
2.2727
2.2475
2.22357
2.20028
2.18063
2.16192
1.04144
1.11583
1.23589
1.64001
2.38322
4.14031
4.9175
5.07122
5.05697
4.99524
4.85515
4.72191
4.74376
4.86795
5.22856
6.08003
7.83496
8.96494
8.95103
8.79365
8.41155
7.89509
7.43539
7.05461
6.72875
6.43517
6.1613
5.90177
5.65493
5.42016
5.1974
4.98613
4.78612
4.59657
4.41715
4.24702
4.08589
3.93295
3.78795
3.65021
3.51942
3.39498
3.27671
3.16406
3.05691
2.9548
2.85768
2.76513
2.67714
2.5933
2.5136
2.43771
2.36554
2.29688
2.23158
2.16949
2.1105
2.05441
2.00144
1.95052
1.90219
1.85623
1.81254
1.77101
1.73156
1.6941
1.65854
1.6248
1.59281
1.56248
1.53374
1.50654
1.48079
1.45643
1.43354
1.4118
1.39186
1.37281
1.35628
1.34136
1.32969
1.32532
1.32699
1.33458
1.35186
1.39285
1.47023
1.60809
1.7884
1.99758
2.15227
2.21903
2.25458
2.25655
2.2512
2.23711
2.21505
2.19202
2.17152
2.15124
1.02509
1.04977
1.13848
1.28674
1.73874
2.60452
4.36361
4.9169
5.02659
5.02276
5.00913
5.0338
5.17542
5.58072
6.53912
8.48387
9.59867
9.56756
9.36603
8.91321
8.37031
7.89147
7.49046
7.14429
6.83007
6.53524
6.25488
5.98763
5.73348
5.4923
5.26399
5.0479
4.84359
4.65017
4.46717
4.29373
4.12945
3.97356
3.82573
3.68525
3.55185
3.42491
3.30425
3.18933
3.08006
2.97594
2.87692
2.78255
2.69281
2.60729
2.52593
2.4484
2.37467
2.30444
2.23764
2.17403
2.11354
2.05598
2.00132
1.94934
1.8998
1.85263
1.80777
1.76508
1.72449
1.6859
1.64924
1.61441
1.58134
1.54994
1.52016
1.49192
1.46517
1.43981
1.41589
1.39321
1.37201
1.35189
1.33338
1.31617
1.30053
1.28813
1.27708
1.27614
1.27832
1.28816
1.30709
1.35416
1.44013
1.58318
1.76687
1.96948
2.10628
2.16872
2.20025
2.20257
2.1977
2.18493
2.16618
2.14691
1.01148
1.03104
1.06364
1.17129
1.37186
1.93334
3.11005
4.49066
4.9274
5.0558
5.16486
5.41682
5.95464
7.10038
9.31245
10.3352
10.2699
10.0019
9.44006
8.86534
8.37279
7.957
7.59057
7.25302
6.9339
6.62955
6.3395
6.06392
5.80297
5.55622
5.32323
5.10306
4.89506
4.69822
4.51202
4.33554
4.16837
4.00974
3.85929
3.71635
3.58054
3.45135
3.3285
3.21157
3.10036
2.99442
2.89365
2.79767
2.70638
2.6194
2.53669
2.45789
2.38288
2.3114
2.24335
2.1785
2.11678
2.05802
2.00207
1.94899
1.89835
1.85015
1.80427
1.76063
1.7191
1.6796
1.64202
1.60629
1.57231
1.54002
1.50933
1.48018
1.45253
1.4263
1.40149
1.37798
1.35588
1.33495
1.31537
1.29707
1.27988
1.26468
1.25018
1.23987
1.23115
1.23195
1.2354
1.24843
1.27054
1.32485
1.4182
1.56368
1.75265
1.94851
2.06807
2.12678
2.15412
2.15805
2.1542
2.14484
1.00705
1.01422
1.03836
1.07948
1.2116
1.45963
2.12406
3.48916
4.62686
5.04178
5.43208
6.21092
7.73731
10.2544
11.1474
11.0407
10.696
10.0008
9.37137
8.86308
8.43712
8.05521
7.69564
7.35101
7.02073
6.70582
6.40718
6.12495
5.85882
5.60783
5.37118
5.14769
4.93665
4.73697
4.54809
4.36909
4.19954
4.03863
3.886
3.741
3.60334
3.47246
3.34802
3.22956
3.11684
3.00954
2.90744
2.81024
2.71776
2.62967
2.54584
2.46595
2.3899
2.3174
2.24836
2.18253
2.11985
2.06011
2.00324
1.94912
1.89758
1.84849
1.8018
1.75734
1.71504
1.67477
1.63643
1.59994
1.5652
1.53215
1.50071
1.47083
1.44245
1.41553
1.39002
1.36582
1.34298
1.32138
1.30106
1.28202
1.26406
1.24762
1.23202
1.21846
1.20618
1.19665
1.19253
1.19367
1.19965
1.21136
1.24341
1.30259
1.40759
1.55459
1.74631
1.93664
2.03776
2.09627
2.11802
2.13312
1.0032
1.00859
1.01725
1.04663
1.09615
1.25576
1.55425
2.32897
3.90287
4.97361
6.03591
8.15716
11.3371
12.1259
11.9598
11.476
10.6048
9.91345
9.38041
8.94303
8.54574
8.16433
7.7937
7.43609
7.09469
6.7713
6.46638
6.17932
5.90919
5.65467
5.41475
5.18821
4.97428
4.77189
4.58046
4.39908
4.22727
4.06427
3.90966
3.76281
3.62333
3.49074
3.36466
3.24477
3.13071
3.0222
2.91896
2.82071
2.7272
2.63817
2.5534
2.47263
2.3957
2.32235
2.2525
2.18587
2.12242
2.06191
2.00432
1.94938
1.89712
1.84732
1.79998
1.7549
1.71201
1.67115
1.63224
1.59517
1.55986
1.52623
1.49422
1.46376
1.4348
1.40728
1.38116
1.3564
1.33298
1.31084
1.28997
1.27036
1.25188
1.23473
1.21861
1.20384
1.19038
1.17806
1.16867
1.16026
1.16046
1.1626
1.16955
1.18607
1.22175
1.29185
1.40481
1.55839
1.74382
1.93673
2.01554
2.09511
1.00177
1.0047
1.00947
1.02537
1.05164
1.13829
1.29292
1.75185
2.64824
4.72576
7.58501
12.3337
13.1163
12.8485
12.1582
11.2429
10.5404
9.99028
9.52567
9.08617
8.66369
8.25683
7.86715
7.49662
7.14653
6.81696
6.50727
6.21624
5.94261
5.68494
5.44221
5.21318
4.99703
4.79269
4.59949
4.41653
4.24325
4.07893
3.92307
3.77511
3.63459
3.50111
3.3742
3.2536
3.13886
3.02977
2.92594
2.82717
2.73312
2.64358
2.55829
2.47699
2.39954
2.32565
2.25526
2.18808
2.1241
2.06303
2.00491
1.94943
1.8967
1.84642
1.79856
1.75295
1.70953
1.66816
1.62878
1.59127
1.55554
1.52152
1.4891
1.45825
1.42889
1.40099
1.37447
1.34933
1.3255
1.30297
1.28169
1.26168
1.24284
1.22523
1.20878
1.19348
1.17945
1.1664
1.15503
1.14478
1.13692
1.13314
1.13394
1.13759
1.14689
1.16816
1.21151
1.29858
1.39747
1.58925
1.74752
1.97912
1.00132
1.00266
1.00732
1.01446
1.0418
1.08009
1.2466
1.52243
2.51122
4.83216
10.7495
13.7802
13.5014
12.7606
11.8999
11.2191
10.6552
10.1533
9.66925
9.19585
8.74191
8.31436
7.91347
7.53731
7.18413
6.8523
6.54041
6.24697
5.9709
5.71089
5.46598
5.23496
5.01699
4.81101
4.61631
4.43198
4.25742
4.09194
3.93498
3.78602
3.64455
3.5102
3.38246
3.26111
3.14566
3.03593
2.93148
2.83215
2.73757
2.64755
2.56179
2.48009
2.40226
2.32802
2.2573
2.18979
2.1255
2.06412
2.00569
1.94992
1.89685
1.84623
1.79804
1.7521
1.70836
1.66669
1.62698
1.58919
1.55314
1.51885
1.48614
1.45502
1.42538
1.39719
1.3704
1.34496
1.32085
1.29804
1.27648
1.25618
1.23708
1.21919
1.20248
1.18693
1.17256
1.15928
1.14724
1.13639
1.12675
1.11937
1.11331
1.11368
1.11552
1.12144
1.13334
1.1617
1.21297
1.3178
1.44092
1.69988
1.00111
1.00224
1.00623
1.01242
1.03663
1.06843
1.22876
1.461
2.524
4.97687
11.6003
13.0407
12.8231
12.3769
11.9084
11.4106
10.8746
10.3178
9.77562
9.26627
8.79294
8.3532
7.94425
7.56294
7.20615
6.87136
6.55682
6.26104
5.98289
5.72111
5.4747
5.24244
5.02344
4.81659
4.62113
4.43615
4.26102
4.09503
3.93762
3.78827
3.64645
3.51181
3.38381
3.26223
3.14657
3.03667
2.93206
2.83259
2.73786
2.64771
2.56181
2.47998
2.402
2.32762
2.25675
2.1891
2.12466
2.06313
2.00456
1.94864
1.89543
1.84467
1.79637
1.75033
1.70648
1.66473
1.62492
1.58704
1.55089
1.51653
1.48371
1.45253
1.4228
1.39454
1.36766
1.34214
1.31795
1.29504
1.2734
1.253
1.2338
1.21582
1.19901
1.18336
1.1689
1.1555
1.14337
1.13219
1.12245
1.11353
1.10688
1.10116
1.10152
1.10323
1.10841
1.11831
1.14266
1.18768
1.27849
1.47
3.06392
1.55572
1.04738
0.942491
0.96824
1.047
1.21278
1.34496
1.38604
1.3844
1.37913
1.37929
1.38126
1.38658
1.39739
1.40524
1.40782
1.40764
1.40702
1.40564
1.40382
1.40227
1.40089
1.3992
1.3971
1.39489
1.39411
1.39456
1.39658
1.40281
1.41917
1.45922
1.55344
1.7708
2.27363
3.29727
3.69946
3.67797
3.70178
3.72289
3.79137
3.90608
4.05294
4.19836
4.32317
4.41653
4.50345
4.55913
4.5939
4.61213
4.61788
4.6153
4.60548
4.58436
4.55624
4.52464
4.49095
4.45446
4.41538
4.37375
4.32967
4.28363
4.23575
4.18634
4.13581
4.08394
4.03159
3.97875
3.9256
3.87198
3.81857
3.76514
3.71177
3.65854
3.60548
3.55278
3.50036
3.44853
3.39716
3.3464
3.29627
3.24684
3.19802
3.1499
3.10236
3.05561
3.00944
2.96405
2.91927
2.87547
2.83225
2.78991
2.74817
2.70743
2.66752
2.62899
2.592
2.55784
2.52788
2.50681
3.71843
2.31611
1.71693
1.46598
1.34999
1.27844
1.26402
1.27193
1.29406
1.33967
1.38503
1.4038
1.40351
1.4022
1.4001
1.40043
1.40156
1.40405
1.4068
1.40678
1.40646
1.40549
1.40342
1.40019
1.39707
1.39438
1.39272
1.39309
1.39489
1.40035
1.4142
1.44762
1.52649
1.71048
2.13816
3.09233
3.71968
3.70316
3.6991
3.72602
3.79487
3.89535
4.02276
4.16686
4.29383
4.39648
4.47939
4.53679
4.57365
4.59343
4.60072
4.59937
4.59321
4.57749
4.54878
4.51617
4.4826
4.44661
4.40837
4.36715
4.32368
4.27791
4.23051
4.18142
4.13122
4.07982
4.02774
3.97511
3.92219
3.86894
3.81565
3.76236
3.70911
3.65599
3.60304
3.55043
3.49813
3.44636
3.39505
3.34438
3.29425
3.24484
3.19606
3.14796
3.10052
3.0539
3.00805
2.96286
2.91839
2.87441
2.83126
2.78877
2.7472
2.70635
2.66656
2.6278
2.59074
2.55604
2.52546
2.50373
4.54542
3.24224
2.42437
1.9081
1.57868
1.37482
1.25762
1.24501
1.2524
1.27385
1.31851
1.36075
1.3879
1.40075
1.40314
1.40283
1.402
1.40143
1.40151
1.40151
1.4014
1.40106
1.40023
1.3985
1.39579
1.39289
1.39003
1.38991
1.39067
1.39386
1.40257
1.42608
1.47864
1.60943
1.8981
2.56402
3.61147
3.77481
3.79959
3.84115
3.90291
3.98075
4.06965
4.16965
4.2664
4.36227
4.44294
4.5023
4.5417
4.5633
4.57168
4.57093
4.56721
4.55691
4.53488
4.50241
4.46865
4.43325
4.39563
4.35526
4.31255
4.26753
4.22072
4.17228
4.12261
4.07188
4.02034
3.96822
3.9157
3.8629
3.80992
3.75689
3.70389
3.65098
3.59827
3.54581
3.49377
3.44212
3.39108
3.34057
3.2907
3.24145
3.193
3.1452
3.09818
3.0516
3.00576
2.96053
2.9161
2.87223
2.82923
2.78682
2.74535
2.70451
2.66476
2.62587
2.5886
2.55334
2.52197
2.49845
4.99809
3.82353
2.9537
2.34794
1.94206
1.66924
1.49828
1.39167
1.32999
1.31426
1.31767
1.32906
1.35327
1.38141
1.40082
1.41087
1.4108
1.41009
1.40834
1.40524
1.40331
1.40216
1.40128
1.40028
1.39852
1.39597
1.39276
1.39011
1.39042
1.39195
1.3979
1.411
1.44855
1.52972
1.73207
2.18666
3.2062
3.79431
4.03505
4.12457
4.16762
4.19623
4.20538
4.21619
4.24321
4.29866
4.36829
4.43237
4.48393
4.51572
4.53039
4.53193
4.52989
4.52346
4.50886
4.48062
4.44758
4.41248
4.37555
4.33642
4.29503
4.25132
4.20564
4.15825
4.10952
4.05966
4.00897
3.95758
3.90573
3.85348
3.80104
3.74843
3.69586
3.64329
3.59097
3.53883
3.48716
3.43583
3.38508
3.33488
3.28549
3.2366
3.18841
3.14074
3.09385
3.04744
3.00182
2.95674
2.91252
2.86882
2.82602
2.78371
2.74237
2.70157
2.66188
2.6229
2.58546
2.54969
2.51737
2.49204
5.27096
4.2438
3.40834
2.77522
2.31291
1.97671
1.73297
1.55883
1.4372
1.36078
1.32043
1.32044
1.32386
1.33372
1.35409
1.37434
1.38908
1.39825
1.40087
1.40054
1.39948
1.39724
1.39456
1.39226
1.39029
1.38848
1.38709
1.38523
1.38537
1.38646
1.38895
1.39948
1.41799
1.47799
1.59385
1.8894
2.50742
3.68457
4.37392
4.59499
4.59018
4.54682
4.43769
4.30837
4.24872
4.25247
4.27372
4.3237
4.38797
4.43742
4.46833
4.48239
4.48219
4.4794
4.47111
4.45268
4.4219
4.38684
4.35013
4.31194
4.27195
4.22988
4.18584
4.13998
4.09259
4.04391
3.99427
3.9438
3.89276
3.84121
3.78941
3.73737
3.68534
3.63323
3.58143
3.52972
3.47852
3.42775
3.37767
3.32799
3.27901
3.23042
3.18253
3.13508
3.08844
3.04225
2.99691
2.95202
2.90806
2.86452
2.82195
2.7798
2.73866
2.69799
2.65841
2.61947
2.58193
2.54584
2.51296
2.48608
5.45694
4.56565
3.79002
3.16119
2.6702
2.29315
2.00588
1.78922
1.62705
1.5101
1.42543
1.37172
1.34284
1.34037
1.34279
1.35001
1.36509
1.38179
1.39464
1.40286
1.40425
1.40384
1.4026
1.3999
1.39592
1.39225
1.38918
1.38641
1.3852
1.38566
1.38738
1.3935
1.40698
1.44367
1.52381
1.71988
2.16315
3.18023
4.68706
5.20023
5.14485
4.98544
4.69385
4.45078
4.29453
4.22904
4.22114
4.22825
4.2539
4.30689
4.35727
4.39482
4.41429
4.41818
4.41579
4.40742
4.38853
4.3565
4.32016
4.28218
4.24293
4.20231
4.16022
4.11646
4.07102
4.02406
3.97588
3.92663
3.87663
3.82596
3.77496
3.72361
3.67225
3.6207
3.56953
3.51867
3.46828
3.41817
3.36863
3.31936
3.27075
3.22245
3.17491
3.12773
3.08142
3.03548
2.99047
2.94583
2.90216
2.85887
2.81656
2.77466
2.73374
2.69329
2.65384
2.61502
2.57747
2.54118
2.50797
2.47994
5.58462
4.8101
4.10288
3.49784
2.99978
2.59866
2.27955
2.02734
1.82856
1.67353
1.55326
1.46483
1.39991
1.36188
1.34197
1.34205
1.34413
1.34993
1.36188
1.3744
1.38372
1.39015
1.3907
1.39039
1.3894
1.38731
1.3842
1.38124
1.37965
1.38002
1.38162
1.38636
1.39808
1.4269
1.49252
1.64904
2.01108
2.86553
4.72892
5.84257
5.75822
5.50572
5.07216
4.70654
4.44697
4.28682
4.20557
4.17939
4.17688
4.18551
4.21157
4.26226
4.3034
4.33326
4.34418
4.34281
4.33631
4.32042
4.28872
4.25207
4.21263
4.1723
4.13136
4.08935
4.04596
4.00105
3.95477
3.9071
3.8584
3.80878
3.75866
3.70808
3.65747
3.60692
3.55664
3.50649
3.45682
3.40725
3.35824
3.30939
3.26124
3.21332
3.16621
3.1194
3.07347
3.02787
2.9832
2.9389
2.89552
2.85257
2.81052
2.76894
2.72824
2.68807
2.64879
2.61016
2.57268
2.53633
2.50298
2.47417
5.6777
4.9957
4.35235
3.77991
3.28965
2.87959
2.54174
2.26558
2.04107
1.85971
1.71378
1.59808
1.50782
1.44057
1.39123
1.36296
1.3473
1.34738
1.34911
1.35398
1.36404
1.37527
1.38408
1.39068
1.39093
1.3904
1.38889
1.38577
1.38232
1.38248
1.3836
1.3892
1.39934
1.43143
1.49068
1.64487
1.95497
2.66504
4.13882
5.9054
5.98407
5.84972
5.51914
5.11688
4.74785
4.48611
4.3045
4.19272
4.14256
4.12418
4.12492
4.13449
4.15987
4.20732
4.23854
4.25928
4.26018
4.25654
4.2448
4.21934
4.18253
4.14223
4.10103
4.05916
4.01677
3.97354
3.9293
3.88355
3.8366
3.7884
3.73937
3.68988
3.64043
3.59083
3.5415
3.49207
3.44308
3.39408
3.34567
3.29736
3.24974
3.20233
3.15571
3.10938
3.06387
3.01873
2.97443
2.93056
2.88754
2.84498
2.80325
2.76203
2.72162
2.68176
2.64273
2.60433
2.567
2.53068
2.49731
2.46801
5.74508
5.13907
4.55375
4.0171
3.54292
3.13408
2.78718
2.49591
2.2527
2.05079
1.88342
1.74564
1.633
1.54205
1.4706
1.41679
1.37792
1.3565
1.34565
1.34583
1.34735
1.35139
1.3596
1.36789
1.37381
1.37783
1.37974
1.3797
1.37974
1.3805
1.38275
1.39095
1.4078
1.45169
1.5413
1.74103
2.14135
2.94145
3.70295
4.69577
5.52072
5.67659
5.61646
5.42995
5.08875
4.79998
4.52426
4.32922
4.19605
4.1138
4.08125
4.0655
4.06734
4.07815
4.10374
4.14084
4.16252
4.1723
4.17054
4.16313
4.14564
4.11125
4.07219
4.02962
3.98672
3.94383
3.90078
3.85668
3.81165
3.76519
3.71811
3.67003
3.62183
3.57321
3.52473
3.47604
3.42773
3.37941
3.33163
3.28398
3.23696
3.19017
3.14408
3.09832
3.05329
3.00866
2.96481
2.9214
2.87878
2.83665
2.79529
2.75445
2.71438
2.67485
2.63612
2.59796
2.56087
2.52462
2.49136
2.46174
5.79763
5.25188
4.717
4.21581
3.76183
3.36071
3.012
2.71253
2.45694
2.24014
2.05659
1.90192
1.77194
1.66362
1.57429
1.50165
1.44515
1.40175
1.37075
1.35342
1.34462
1.34481
1.34617
1.34976
1.35708
1.36503
1.37167
1.37601
1.37849
1.38194
1.38946
1.40509
1.4405
1.51495
1.67445
1.99847
2.64796
3.19885
3.52435
3.92008
4.43972
5.01687
5.35026
5.32976
5.24006
5.04628
4.78993
4.57223
4.36217
4.21133
4.10998
4.0467
4.02093
4.00416
4.00606
4.01508
4.03526
4.06187
4.07674
4.0776
4.07425
4.06318
4.03919
4.00053
3.95828
3.91462
3.87098
3.82719
3.78336
3.73869
3.69349
3.64725
3.60055
3.55313
3.50563
3.4578
3.41025
3.36267
3.31558
3.26865
3.22231
3.17622
3.13076
3.08563
3.04119
2.99713
2.95381
2.91092
2.86879
2.82712
2.78623
2.7458
2.70616
2.66698
2.62864
2.59075
2.55397
2.51785
2.48476
2.4549
5.83729
5.34166
4.85081
4.38343
3.95188
3.56273
3.21752
2.91517
2.65226
2.42516
2.22945
2.0615
1.91748
1.79461
1.69012
1.60202
1.52882
1.46888
1.42186
1.38615
1.36122
1.34713
1.34064
1.34087
1.34221
1.34551
1.35219
1.36007
1.36867
1.37832
1.39409
1.42582
1.49301
1.63097
1.91557
2.48956
3.08025
3.33927
3.45794
3.60001
3.81347
4.11451
4.53549
4.86234
5.02041
5.0001
4.92293
4.75339
4.56596
4.40181
4.24001
4.11571
4.03319
3.97917
3.95416
3.93512
3.9368
3.94331
3.9572
3.97566
3.98291
3.98139
3.97503
3.95924
3.92742
3.88674
3.84234
3.79763
3.75385
3.71012
3.66628
3.62167
3.57658
3.53063
3.48442
3.43769
3.39111
3.34441
3.29814
3.25199
3.2064
3.16103
3.11629
3.07182
3.02803
2.98458
2.94185
2.8995
2.85792
2.81673
2.77634
2.73635
2.69717
2.65837
2.62044
2.58288
2.54644
2.51052
2.47767
2.44765
5.87021
5.41434
4.96143
4.52552
4.11685
3.74216
3.4039
3.10257
2.83615
2.60237
2.39775
2.2195
2.06426
1.9296
1.81292
1.71235
1.6262
1.55316
1.49224
1.44239
1.40334
1.37371
1.35331
1.34152
1.33797
1.3387
1.34135
1.34742
1.35978
1.37846
1.40854
1.46953
1.59287
1.84543
2.3541
3.00879
3.30934
3.40168
3.43287
3.47051
3.53343
3.64197
3.81529
4.05053
4.37112
4.61699
4.7457
4.73018
4.67254
4.54547
4.39063
4.25973
4.13407
4.02396
3.94985
3.904
3.87672
3.85744
3.85862
3.86329
3.87306
3.88556
3.88531
3.8823
3.87292
3.85188
3.81319
3.77012
3.72581
3.68145
3.63766
3.59373
3.5498
3.5052
3.46041
3.41507
3.36978
3.32423
3.27901
3.2338
3.18908
3.14451
3.10053
3.05677
3.01367
2.97086
2.92876
2.88699
2.84599
2.80535
2.76549
2.726
2.68729
2.64895
2.61143
2.57426
2.53818
2.50251
2.46993
2.43976
5.89539
5.47315
5.05501
4.64881
4.26268
3.90345
3.57432
3.27656
3.00953
2.77171
2.56089
2.37462
2.21051
2.06608
1.93939
1.82833
1.73151
1.64732
1.57493
1.51311
1.46157
1.41936
1.38631
1.36207
1.34496
1.34079
1.34217
1.34685
1.35971
1.38446
1.43862
1.54481
1.76546
2.20634
2.8828
3.28028
3.40121
3.42085
3.42006
3.41537
3.40715
3.41556
3.44995
3.53053
3.68861
3.90457
4.18271
4.3896
4.51074
4.49998
4.46
4.37503
4.23873
4.12878
4.02749
3.92956
3.86339
3.8224
3.79412
3.77408
3.77505
3.77862
3.78494
3.78927
3.7878
3.78197
3.76771
3.73832
3.69845
3.65435
3.61012
3.5659
3.5221
3.47813
3.4344
3.39039
3.34651
3.30236
3.25839
3.21432
3.17057
3.12691
3.08371
3.04074
2.99833
2.95622
2.91476
2.87364
2.83321
2.79315
2.75382
2.71486
2.67664
2.63879
2.60171
2.56496
2.52928
2.4939
2.46164
2.43135
5.92499
5.531
5.14072
4.75905
4.39348
4.04917
3.7298
3.43706
3.17123
2.93152
2.71654
2.52442
2.35327
2.20109
2.06605
1.94636
1.84063
1.74726
1.66549
1.59393
1.53221
1.47953
1.43546
1.40021
1.373
1.35818
1.35947
1.36503
1.38409
1.42087
1.51017
1.68535
2.04923
2.71486
3.20996
3.39189
3.42421
3.42193
3.40985
3.38004
3.32383
3.27794
3.27732
3.28811
3.32471
3.40619
3.56019
3.75214
3.98276
4.16399
4.29102
4.2903
4.27025
4.21661
4.10802
4.00588
3.91666
3.83789
3.77577
3.73462
3.70712
3.68859
3.68794
3.68926
3.69238
3.69188
3.68872
3.67957
3.6596
3.62268
3.58125
3.53759
3.49361
3.44964
3.40638
3.36337
3.32075
3.27809
3.23554
3.19288
3.15036
3.10784
3.0656
3.02353
2.98189
2.94053
2.89973
2.85927
2.81945
2.78001
2.74124
2.70284
2.66515
2.62779
2.5912
2.55487
2.51964
2.48455
2.45267
2.42232
5.96348
5.5895
5.22183
4.8609
4.51285
4.18239
3.87236
3.58527
3.32167
3.08162
2.864
2.66788
2.49128
2.33305
2.19121
2.06439
1.95129
1.85022
1.76067
1.68099
1.61095
1.54965
1.4964
1.45247
1.41569
1.39557
1.39755
1.40786
1.43408
1.50357
1.64248
1.94244
2.53729
3.10073
3.36259
3.42307
3.42199
3.41139
3.38212
3.32226
3.2592
3.20645
3.16875
3.14633
3.14964
3.16383
3.20044
3.27598
3.4077
3.57362
3.76887
3.94308
4.07005
4.10697
4.09582
4.06166
3.98647
3.8904
3.8121
3.74355
3.68444
3.64446
3.61732
3.60009
3.59658
3.59697
3.59683
3.5951
3.58902
3.57418
3.54394
3.50515
3.46339
3.42037
3.37762
3.33526
3.29352
3.25201
3.21077
3.16951
3.12835
3.08712
3.04606
3.00503
2.96433
2.9238
2.88376
2.84398
2.80482
2.76597
2.72781
2.68995
2.65282
2.61595
2.57989
2.54399
2.50925
2.47447
2.44302
2.41264
6.02194
5.65397
5.30101
4.95758
4.6238
4.30418
4.00285
3.72149
3.46096
3.22188
3.00299
2.80436
2.62392
2.46095
2.3139
2.18113
2.06202
1.95443
1.85836
1.77184
1.69482
1.62652
1.56561
1.51583
1.47078
1.45637
1.4605
1.48052
1.52424
1.64902
1.88648
2.40008
3.0068
3.33281
3.42771
3.42667
3.41567
3.38541
3.32343
3.25766
3.20115
3.15186
3.10819
3.0701
3.04207
3.02231
3.02506
3.03685
3.06632
3.12724
3.23777
3.38323
3.55264
3.72451
3.85132
3.93573
3.93039
3.91093
3.87169
3.79439
3.71333
3.64552
3.5924
3.55237
3.5234
3.50883
3.50673
3.50638
3.50476
3.4997
3.48767
3.46257
3.42875
3.39011
3.34936
3.30782
3.26647
3.22539
3.18483
3.14451
3.10453
3.06457
3.02482
2.98498
2.94542
2.90585
2.86671
2.82769
2.78926
2.75102
2.71349
2.67617
2.63962
2.60324
2.56772
2.53227
2.49804
2.46361
2.4326
2.40224
6.10634
5.72373
5.37719
5.04501
4.72375
4.41545
4.12205
3.84688
3.58972
3.35266
3.13381
2.93372
2.75101
2.58435
2.43343
2.29579
2.17175
2.05876
1.95707
1.86487
1.78191
1.70779
1.64136
1.58701
1.54124
1.542
1.55317
1.58442
1.68483
1.87891
2.31414
2.96029
3.3328
3.45623
3.45505
3.44244
3.40543
3.33078
3.25836
3.19798
3.14758
3.10127
3.05769
3.01622
2.97726
2.94245
2.91571
2.89404
2.89579
2.90377
2.92521
2.97137
3.06339
3.18892
3.34162
3.50507
3.6473
3.74946
3.78684
3.77877
3.7523
3.6941
3.61912
3.55088
3.49555
3.45332
3.42784
3.41715
3.41356
3.41155
3.40722
3.39771
3.37875
3.35044
3.3164
3.27873
3.23936
3.19917
3.15911
3.11923
3.07991
3.04079
3.0021
2.96339
2.92501
2.88652
2.84843
2.8103
2.7727
2.73517
2.69831
2.66157
2.62559
2.58974
2.55474
2.51977
2.48603
2.45198
2.42144
2.39111
6.19149
5.79935
5.45036
5.12565
4.81424
4.51615
4.23136
3.96255
3.70976
3.47486
3.25743
3.05663
2.87268
2.70354
2.54937
2.40821
2.27969
2.16251
2.05579
1.95893
1.87102
1.79196
1.72343
1.66429
1.64083
1.64678
1.67473
1.74447
1.92341
2.28268
2.95824
3.38055
3.52317
3.52103
3.50396
3.45464
3.36812
3.28975
3.21999
3.1587
3.10381
3.05469
3.01047
2.9674
2.92577
2.88597
2.84818
2.81465
2.7871
2.76538
2.76215
2.76695
2.78287
2.81829
2.89144
2.9992
3.13623
3.29132
3.44774
3.56552
3.64839
3.64591
3.63151
3.60047
3.53676
3.46498
3.40703
3.36485
3.33867
3.32475
3.31767
3.31281
3.30551
3.29084
3.26887
3.24031
3.20718
3.17079
3.13286
3.09404
3.05533
3.01669
2.97863
2.94068
2.90324
2.86574
2.82869
2.79152
2.75487
2.71816
2.68207
2.646
2.61065
2.57537
2.54092
2.50644
2.47323
2.43958
2.40953
2.37928
6.31796
5.89299
5.52645
5.20177
4.89771
4.60823
4.33171
4.07008
3.82265
3.59045
3.37466
3.17433
2.9894
2.81894
2.66201
2.51814
2.38592
2.26508
2.15427
2.05338
1.96148
1.87998
1.80965
1.76218
1.76492
1.784
1.84596
1.99696
2.32223
2.97776
3.46838
3.63753
3.6344
3.61182
3.54929
3.44735
3.35359
3.27375
3.20367
3.14075
3.08209
3.0267
2.97451
2.92625
2.88179
2.8388
2.79736
2.75786
2.72063
2.68767
2.65892
2.63783
2.62786
2.63089
2.64219
2.66891
2.72573
2.81758
2.93891
3.08893
3.24778
3.39
3.49501
3.53549
3.52618
3.49861
3.44127
3.37446
3.32288
3.28109
3.2521
3.23488
3.2241
3.21452
3.20246
3.18497
3.16201
3.13364
3.1015
3.06638
3.02987
2.9924
2.95502
2.91758
2.88074
2.84391
2.80768
2.77139
2.73566
2.69984
2.6646
2.62932
2.5947
2.56007
2.52624
2.49231
2.45966
2.42644
2.3969
2.36677
6.34676
5.98755
5.60779
5.27785
4.97685
4.69438
4.42536
4.16981
3.92857
3.70056
3.48666
3.28731
3.10197
2.93047
2.7717
2.62534
2.49038
2.36622
2.25217
2.14813
2.05339
1.97326
1.90439
1.89947
1.91328
1.95935
2.10776
2.39647
3.03022
3.59824
3.80246
3.79865
3.7712
3.69628
3.56422
3.44689
3.35119
3.27045
3.1995
3.13541
3.07377
3.01423
2.95658
2.90121
2.84943
2.80149
2.75602
2.71269
2.67138
2.63211
2.5955
2.56263
2.53345
2.5125
2.49672
2.49873
2.50685
2.52657
2.56716
2.64497
2.75424
2.89682
3.05644
3.22055
3.34582
3.42332
3.41586
3.39328
3.35018
3.29042
3.24085
3.19857
3.16774
3.1471
3.13202
3.11804
3.10238
3.08276
3.05907
3.03079
2.99954
2.96546
2.93022
2.89398
2.85788
2.8216
2.78595
2.75029
2.71529
2.68026
2.64587
2.61141
2.5776
2.54372
2.5106
2.4773
2.44528
2.41255
2.38357
2.35361
6.31297
6.1011
5.70748
5.36036
5.05773
4.77991
4.51588
4.26552
4.02871
3.80531
3.59428
3.39611
3.211
3.03872
2.87864
2.73029
2.59301
2.46624
2.3497
2.24337
2.1502
2.0711
2.04341
2.05405
2.09734
2.22658
2.50749
3.11043
3.76808
4.01478
4.01038
3.97778
3.88848
3.73128
3.59012
3.47291
3.37418
3.28791
3.21027
3.1386
3.07218
3.01046
2.94914
2.88957
2.83166
2.77639
2.72502
2.67749
2.63222
2.58918
2.54841
2.50975
2.47395
2.44106
2.41232
2.3901
2.37181
2.37161
2.37575
2.38997
2.42096
2.48568
2.5845
2.71761
2.87824
3.05527
3.20408
3.30863
3.30482
3.28978
3.26037
3.20254
3.15527
3.11419
3.08318
3.05998
3.04127
3.02366
3.00533
2.98379
2.95962
2.93119
2.90078
2.8676
2.83351
2.79849
2.76365
2.72863
2.69422
2.65984
2.62612
2.59244
2.55939
2.52632
2.49396
2.46141
2.43008
2.39795
2.36958
2.33988
6.2206
6.09897
5.82398
5.45853
5.14245
4.86281
4.60449
4.35928
4.1256
3.90489
3.69699
3.5008
3.31624
3.14382
2.98277
2.83306
2.69397
2.56542
2.44725
2.34225
2.25177
2.20418
2.2116
2.25026
2.36129
2.63372
3.2053
3.96381
4.26495
4.26075
4.22404
4.12024
3.93851
3.77464
3.63786
3.52099
3.41783
3.32435
3.23839
3.15837
3.08359
3.01312
2.94725
2.88562
2.82365
2.76404
2.7068
2.65283
2.60263
2.5557
2.5113
2.46913
2.42915
2.39141
2.35642
2.32397
2.29591
2.2722
2.25439
2.24841
2.2514
2.26218
2.28676
2.33919
2.42786
2.55073
2.71264
2.90016
3.07389
3.19183
3.20127
3.19085
3.16481
3.1128
3.0683
3.03013
2.99877
2.973
2.9513
2.93071
2.9104
2.88737
2.86283
2.83452
2.8047
2.77256
2.73968
2.70598
2.67248
2.63882
2.60573
2.57271
2.54031
2.50799
2.47637
2.44457
2.41401
2.38254
2.35486
2.32555
6.11639
6.06172
5.89569
5.56038
5.23386
4.9487
4.69075
4.44929
4.22005
4.00185
3.79564
3.6015
3.41827
3.24589
3.08447
2.9336
2.79355
2.66389
2.54729
2.44613
2.37947
2.38413
2.41719
2.51862
2.78045
3.33112
4.19265
4.55061
4.54661
4.50557
4.38564
4.17914
3.99273
3.83631
3.70207
3.58248
3.47343
3.37233
3.27808
3.18965
3.10662
3.02843
2.95505
2.88554
2.82118
2.75914
2.69834
2.63982
2.58396
2.53184
2.48343
2.43754
2.39414
2.35309
2.31422
2.27767
2.24356
2.21198
2.18444
2.16004
2.14278
2.13236
2.1344
2.14269
2.16227
2.20561
2.2839
2.39865
2.56228
2.75985
2.95333
3.07619
3.1017
3.0931
3.06945
3.02336
2.98235
2.94588
2.91367
2.88562
2.86173
2.83907
2.81737
2.79347
2.76861
2.7408
2.71156
2.6806
2.64902
2.61676
2.58464
2.55242
2.52069
2.48904
2.45808
2.42698
2.39716
2.3664
2.33942
2.31061
5.91561
5.95652
5.88158
5.68753
5.34697
5.04452
4.77996
4.53846
4.31211
4.09688
3.89207
3.69895
3.51718
3.34561
3.18405
3.03286
2.89255
2.76402
2.65397
2.56765
2.56963
2.59661
2.6908
2.93166
3.44933
4.42465
4.85862
4.85543
4.81135
4.67992
4.44752
4.23767
4.06196
3.91065
3.77547
3.65131
3.53587
3.42743
3.32554
3.22937
3.13881
3.05335
2.97285
2.89693
2.82551
2.75825
2.69556
2.63414
2.57497
2.51821
2.46442
2.41426
2.36745
2.32321
2.28131
2.24165
2.20409
2.16884
2.13575
2.10529
2.07818
2.05391
2.03684
2.02336
2.02485
2.03128
2.04753
2.08331
2.15254
2.26316
2.42733
2.63166
2.84555
2.96646
3.0036
2.99593
2.9749
2.93397
2.89645
2.86068
2.82767
2.79832
2.77315
2.74929
2.72659
2.70248
2.6773
2.65017
2.62178
2.59209
2.56184
2.53106
2.50036
2.46955
2.43932
2.40891
2.37978
2.3497
2.3234
2.29517
5.42852
5.83991
5.82016
5.71281
5.47256
5.1542
4.87547
4.62921
4.40286
4.1902
3.98862
3.79641
3.61414
3.44282
3.2818
3.1312
2.99219
2.87206
2.77153
2.76589
2.78985
2.87983
3.11877
3.63405
4.66648
5.17689
5.1879
5.14313
4.99903
4.74
4.50641
4.31097
4.14283
3.9921
3.85342
3.72371
3.60176
3.48643
3.37759
3.27451
3.17724
3.08522
2.9984
2.91638
2.83896
2.76601
2.69711
2.63262
2.57171
2.51196
2.4547
2.40008
2.34899
2.30124
2.25613
2.21346
2.17309
2.13492
2.09882
2.06495
2.03307
2.00382
1.97729
1.9537
1.93649
1.92148
1.9224
1.92751
1.94081
1.97189
2.03474
2.14443
2.30564
2.51334
2.74435
2.86016
2.90462
2.89837
2.88079
2.84621
2.81039
2.77504
2.74197
2.71231
2.68637
2.66209
2.63855
2.61442
2.5894
2.56305
2.53566
2.50727
2.4784
2.44903
2.4199
2.39038
2.36202
2.33265
2.30703
2.27939
4.37173
5.56496
5.7353
5.6891
5.55305
5.27183
4.97912
4.72442
4.49562
4.28302
4.08218
3.89157
3.71071
3.53954
3.37909
3.23012
3.09947
2.98985
2.97039
2.99346
3.08335
3.32575
3.86073
4.94487
5.53074
5.55629
5.50607
5.34406
5.05642
4.79748
4.58158
4.39605
4.22985
4.07647
3.93285
3.79722
3.66895
3.54727
3.43217
3.32297
3.21978
3.12196
3.02951
2.94196
2.8592
2.78097
2.70703
2.63736
2.57144
2.50994
2.45059
2.39332
2.33849
2.28652
2.23808
2.1924
2.14923
2.10839
2.06976
2.03321
1.99868
1.96621
1.93563
1.90759
1.8818
1.8591
1.84171
1.82666
1.82656
1.83006
1.84248
1.87031
1.9294
2.04051
2.20367
2.40785
2.64803
2.75889
2.80747
2.80279
2.78848
2.75934
2.72481
2.69037
2.65774
2.62826
2.60204
2.57753
2.55381
2.52985
2.50532
2.47981
2.45357
2.42641
2.39907
2.37097
2.34376
2.31531
2.29046
2.26351
2.75736
4.93573
5.57611
5.61588
5.55085
5.39072
5.10062
4.83071
4.59232
4.37667
4.17543
3.98546
3.80539
3.6356
3.47711
3.33674
3.21866
3.18705
3.20928
3.30028
3.54878
4.11001
5.25154
5.91742
5.95905
5.90206
5.71777
5.39803
5.11144
4.8734
4.66974
4.48742
4.31917
4.16123
4.01196
3.87035
3.73607
3.60857
3.48781
3.37317
3.2647
3.16172
3.06427
2.97182
2.88431
2.80138
2.72288
2.64863
2.57842
2.51214
2.44964
2.39098
2.33363
2.2788
2.22661
2.17773
2.13173
2.08823
2.04706
2.00809
1.97122
1.93634
1.90339
1.87242
1.84321
1.81642
1.79163
1.7698
1.75268
1.7379
1.73709
1.74038
1.75197
1.77907
1.83714
1.94931
2.11233
2.32332
2.55877
2.66365
2.71433
2.71096
2.69885
2.67399
2.64079
2.60742
2.57564
2.54667
2.52062
2.49623
2.47273
2.44919
2.42541
2.4008
2.37586
2.34983
2.32435
2.29733
2.27355
2.24759
2.10203
3.51977
5.14106
5.50901
5.50176
5.42278
5.23809
4.95308
4.69881
4.4743
4.26974
4.07799
3.89928
3.73189
3.58214
3.45584
3.41488
3.4367
3.52927
3.78511
4.36572
5.55396
6.32186
6.38215
6.31893
6.11488
5.76273
5.44752
5.18647
4.96358
4.76447
4.58059
4.40794
4.24443
4.0893
3.94188
3.80201
3.66916
3.54329
3.42376
3.31058
3.20304
3.10119
3.00438
2.91264
2.82552
2.74293
2.66461
2.59043
2.52018
2.45383
2.39092
2.33205
2.27546
2.22093
2.16886
2.11993
2.07379
2.03013
1.98878
1.94963
1.91257
1.8775
1.84434
1.813
1.78357
1.75578
1.73029
1.70667
1.68571
1.66932
1.65497
1.65423
1.65754
1.66882
1.69661
1.7546
1.86809
2.02676
2.24833
2.47735
2.57396
2.62503
2.62274
2.61256
2.59069
2.5591
2.52703
2.49641
2.46825
2.44278
2.41881
2.39585
2.37289
2.3501
2.32635
2.30304
2.27801
2.25573
2.23137
1.62575
2.32886
4.18698
5.23871
5.42209
5.39542
5.2959
5.0804
4.81112
4.57364
4.36304
4.172
3.99451
3.83593
3.70135
3.65262
3.67469
3.77105
4.03949
4.65322
5.91897
6.76045
6.82998
6.75909
6.53323
6.14751
5.80342
5.51887
5.27643
5.05985
4.85992
4.67188
4.49379
4.32451
4.1637
4.01086
3.86586
3.72818
3.59771
3.47379
3.35637
3.24472
3.13889
3.03818
2.94265
2.85178
2.76556
2.68364
2.60593
2.53223
2.46238
2.39625
2.33365
2.27463
2.21866
2.16457
2.11287
2.06412
2.01805
1.9744
1.93304
1.89388
1.8568
1.8217
1.78849
1.75711
1.72743
1.6996
1.6733
1.64911
1.62682
1.6067
1.59142
1.57756
1.5777
1.58129
1.59247
1.6221
1.68242
1.79955
1.9546
2.17831
2.40129
2.48997
2.53975
2.53855
2.53022
2.51071
2.4808
2.45017
2.4209
2.39375
2.36913
2.34576
2.32363
2.30132
2.2799
2.25693
2.23652
2.21437
1.27937
1.73792
2.62697
4.60722
5.25104
5.33194
5.28742
5.16998
4.92991
4.68127
4.46295
4.26932
4.09936
3.95762
3.90042
3.92311
4.02469
4.3092
4.96304
6.31536
7.24712
7.31379
7.23048
6.9753
6.55365
6.17912
5.87047
5.60784
5.37339
5.15661
4.95267
4.75917
4.5753
4.40038
4.23425
4.07644
3.92678
3.78473
3.65008
3.5222
3.40094
3.28563
3.17619
3.07201
2.97308
2.87887
2.78941
2.70429
2.62347
2.5467
2.47383
2.40472
2.33917
2.27713
2.21832
2.16301
2.10947
2.05831
2.01002
1.96425
1.92085
1.8797
1.84071
1.80376
1.76877
1.73566
1.70432
1.67474
1.64673
1.6205
1.59574
1.57281
1.55202
1.5327
1.5188
1.50582
1.50654
1.51162
1.52223
1.55615
1.61639
1.73857
1.90276
2.12168
2.33055
2.41316
2.46002
2.45954
2.45224
2.43449
2.40641
2.37746
2.34981
2.32381
2.30026
2.27758
2.25668
2.23508
2.21621
2.19628
1.17403
1.36797
1.96808
3.19723
4.79345
5.20833
5.23419
5.17937
5.04649
4.80254
4.57526
4.38193
4.223
4.15832
4.18216
4.29089
4.59775
5.30537
6.77208
7.78198
7.83099
7.73056
7.44121
6.98259
6.5771
6.24341
5.9597
5.70609
5.47144
5.25028
5.04054
4.84102
4.65145
4.47122
4.30025
4.13794
3.98409
3.83808
3.69966
3.56818
3.44343
3.32477
3.21208
3.10476
3.00277
2.90561
2.81327
2.72534
2.6418
2.56233
2.48685
2.41514
2.34705
2.28243
2.22116
2.16298
2.10825
2.05548
2.00504
1.9574
1.91215
1.86919
1.82843
1.78977
1.75313
1.7184
1.68553
1.65442
1.62498
1.5972
1.5709
1.54621
1.52304
1.50132
1.48206
1.46375
1.45096
1.44008
1.44112
1.44617
1.46083
1.49315
1.5604
1.68355
1.85397
2.07329
2.26525
2.34156
2.38518
2.38583
2.37957
2.36288
2.33679
2.30967
2.28374
2.25896
2.23681
2.21512
2.19641
2.17802
1.08128
1.2212
1.48537
2.21407
3.74757
4.87798
5.14116
5.1361
5.0764
4.9347
4.70758
4.5132
4.42741
4.45207
4.56964
4.9025
5.67391
7.27112
8.34138
8.3688
8.24901
7.92534
7.43277
6.99659
6.6382
6.33324
6.05994
5.80611
5.56649
5.33883
5.12252
4.91691
4.72187
4.53672
4.36131
4.19489
4.03723
3.88761
3.74577
3.61098
3.48309
3.3614
3.24578
3.13565
3.03094
2.93114
2.83627
2.74586
2.65994
2.57813
2.50039
2.42643
2.35614
2.28933
2.22586
2.16562
2.10836
2.05443
2.00248
1.95306
1.90617
1.86161
1.81928
1.77907
1.74094
1.70476
1.67048
1.63797
1.60719
1.57807
1.55048
1.52444
1.49985
1.47663
1.4551
1.4346
1.41685
1.39989
1.38793
1.37991
1.38115
1.38766
1.4026
1.43987
1.5121
1.64422
1.81761
2.03133
2.20566
2.27715
2.31661
2.3179
2.31212
2.29682
2.2727
2.2475
2.22357
2.20028
2.18063
2.16192
1.04144
1.11583
1.23589
1.64001
2.38322
4.14031
4.9175
5.07122
5.05697
4.99524
4.85515
4.72191
4.74376
4.86795
5.22855
6.08003
7.83494
8.96494
8.95102
8.79365
8.41155
7.89509
7.43539
7.05461
6.72875
6.43517
6.16131
5.90177
5.65493
5.42016
5.1974
4.98613
4.78612
4.59657
4.41715
4.24702
4.08589
3.93295
3.78795
3.65021
3.51942
3.39498
3.27671
3.16406
3.05691
2.9548
2.85768
2.76513
2.67714
2.5933
2.5136
2.43771
2.36554
2.29688
2.23158
2.16949
2.1105
2.05441
2.00144
1.95052
1.90219
1.85623
1.81254
1.77101
1.73156
1.6941
1.65854
1.6248
1.59281
1.56248
1.53374
1.50654
1.48079
1.45643
1.43354
1.4118
1.39186
1.37281
1.35628
1.34136
1.32969
1.32532
1.32699
1.33457
1.35186
1.39285
1.47023
1.60808
1.7884
1.99758
2.15227
2.21903
2.25458
2.25655
2.2512
2.23711
2.21505
2.19202
2.17152
2.15124
1.02509
1.04977
1.13848
1.28674
1.73874
2.60452
4.36361
4.9169
5.02659
5.02276
5.00913
5.0338
5.17542
5.58071
6.53911
8.48386
9.59867
9.56756
9.36603
8.91321
8.37032
7.89148
7.49046
7.14429
6.83007
6.53524
6.25488
5.98763
5.73348
5.4923
5.26399
5.0479
4.84359
4.65017
4.46717
4.29373
4.12946
3.97356
3.82573
3.68525
3.55185
3.42491
3.30425
3.18933
3.08006
2.97594
2.87692
2.78255
2.69281
2.60729
2.52593
2.4484
2.37467
2.30444
2.23764
2.17403
2.11354
2.05598
2.00132
1.94934
1.8998
1.85263
1.80777
1.76508
1.72449
1.6859
1.64924
1.61441
1.58134
1.54994
1.52016
1.49192
1.46517
1.43981
1.41589
1.39321
1.37201
1.35189
1.33338
1.31617
1.30052
1.28813
1.27708
1.27614
1.27832
1.28816
1.30709
1.35415
1.44013
1.58318
1.76687
1.96948
2.10628
2.16871
2.20025
2.20257
2.1977
2.18493
2.16618
2.14691
1.01148
1.03104
1.06364
1.17129
1.37185
1.93334
3.11005
4.49066
4.9274
5.0558
5.16485
5.41681
5.95463
7.10037
9.31244
10.3352
10.2699
10.0019
9.44007
8.86534
8.37279
7.957
7.59057
7.25302
6.9339
6.62955
6.3395
6.06392
5.80297
5.55622
5.32324
5.10306
4.89506
4.69822
4.51202
4.33554
4.16837
4.00974
3.85929
3.71635
3.58054
3.45135
3.3285
3.21157
3.10036
2.99442
2.89365
2.79767
2.70638
2.6194
2.53669
2.45789
2.38288
2.3114
2.24335
2.1785
2.11678
2.05802
2.00207
1.94899
1.89835
1.85015
1.80427
1.76063
1.7191
1.6796
1.64202
1.60629
1.57231
1.54002
1.50933
1.48018
1.45253
1.4263
1.40149
1.37798
1.35588
1.33495
1.31537
1.29707
1.27988
1.26468
1.25018
1.23987
1.23115
1.23195
1.2354
1.24843
1.27054
1.32485
1.41819
1.56368
1.75265
1.94851
2.06807
2.12678
2.15412
2.15805
2.1542
2.14484
1.00705
1.01422
1.03836
1.07948
1.2116
1.45963
2.12406
3.48916
4.62685
5.04178
5.43207
6.21091
7.7373
10.2544
11.1474
11.0407
10.696
10.0008
9.37137
8.86308
8.43712
8.05521
7.69564
7.35101
7.02073
6.70582
6.40718
6.12496
5.85882
5.60783
5.37118
5.14769
4.93665
4.73697
4.54809
4.36909
4.19954
4.03863
3.886
3.741
3.60334
3.47246
3.34802
3.22956
3.11684
3.00954
2.90744
2.81024
2.71776
2.62967
2.54584
2.46595
2.3899
2.3174
2.24836
2.18253
2.11985
2.06011
2.00324
1.94912
1.89758
1.84849
1.8018
1.75734
1.71504
1.67477
1.63643
1.59994
1.5652
1.53215
1.50071
1.47083
1.44245
1.41553
1.39002
1.36582
1.34298
1.32138
1.30106
1.28202
1.26405
1.24762
1.23202
1.21846
1.20618
1.19665
1.19252
1.19367
1.19964
1.21136
1.24341
1.30259
1.40759
1.55459
1.7463
1.93664
2.03776
2.09627
2.11802
2.13312
1.0032
1.00859
1.01725
1.04663
1.09615
1.25576
1.55425
2.32897
3.90286
4.97361
6.0359
8.15714
11.337
12.1259
11.9598
11.476
10.6048
9.91345
9.38041
8.94303
8.54574
8.16433
7.7937
7.43609
7.09469
6.7713
6.46638
6.17932
5.90919
5.65467
5.41475
5.18822
4.97428
4.77189
4.58046
4.39908
4.22727
4.06427
3.90966
3.76281
3.62333
3.49074
3.36466
3.24477
3.13071
3.0222
2.91896
2.82071
2.7272
2.63817
2.5534
2.47263
2.3957
2.32235
2.2525
2.18587
2.12242
2.06191
2.00432
1.94938
1.89712
1.84732
1.79998
1.7549
1.71201
1.67115
1.63224
1.59517
1.55986
1.52623
1.49422
1.46376
1.4348
1.40728
1.38116
1.3564
1.33298
1.31084
1.28997
1.27036
1.25188
1.23473
1.21861
1.20384
1.19038
1.17806
1.16867
1.16026
1.16046
1.1626
1.16955
1.18607
1.22175
1.29185
1.40481
1.55839
1.74382
1.93672
2.01554
2.09511
1.00177
1.0047
1.00947
1.02537
1.05164
1.13829
1.29292
1.75185
2.64823
4.72575
7.58498
12.3337
13.1163
12.8485
12.1582
11.2429
10.5404
9.99028
9.52567
9.08617
8.66369
8.25683
7.86715
7.49662
7.14653
6.81696
6.50727
6.21624
5.94261
5.68494
5.44221
5.21318
4.99703
4.79269
4.59949
4.41653
4.24325
4.07893
3.92307
3.77511
3.63459
3.50111
3.3742
3.2536
3.13886
3.02977
2.92594
2.82717
2.73312
2.64358
2.55829
2.47699
2.39954
2.32565
2.25526
2.18808
2.1241
2.06303
2.00491
1.94943
1.8967
1.84642
1.79856
1.75295
1.70953
1.66816
1.62878
1.59127
1.55554
1.52152
1.4891
1.45825
1.42889
1.40099
1.37447
1.34933
1.3255
1.30297
1.28169
1.26168
1.24284
1.22523
1.20878
1.19348
1.17944
1.1664
1.15503
1.14478
1.13692
1.13314
1.13394
1.13759
1.14689
1.16816
1.21151
1.29858
1.39747
1.58925
1.74751
1.97911
1.00132
1.00266
1.00732
1.01446
1.0418
1.08009
1.2466
1.52243
2.51121
4.83214
10.7494
13.7802
13.5014
12.7606
11.8999
11.2191
10.6552
10.1533
9.66925
9.19585
8.74191
8.31436
7.91347
7.53731
7.18413
6.8523
6.54041
6.24697
5.9709
5.71089
5.46598
5.23496
5.01699
4.81101
4.61631
4.43198
4.25742
4.09194
3.93498
3.78602
3.64455
3.5102
3.38246
3.26111
3.14566
3.03593
2.93148
2.83215
2.73757
2.64755
2.56179
2.48009
2.40226
2.32802
2.2573
2.18979
2.1255
2.06412
2.00569
1.94992
1.89685
1.84623
1.79804
1.7521
1.70836
1.66669
1.62698
1.58919
1.55314
1.51885
1.48614
1.45502
1.42538
1.39719
1.3704
1.34496
1.32085
1.29804
1.27648
1.25618
1.23708
1.21919
1.20248
1.18692
1.17256
1.15928
1.14724
1.13639
1.12674
1.11937
1.11331
1.11368
1.11552
1.12144
1.13334
1.1617
1.21296
1.3178
1.44092
1.69988
1.00111
1.00224
1.00623
1.01242
1.03663
1.06843
1.22876
1.461
2.52399
4.97686
11.6002
13.0407
12.8231
12.3769
11.9084
11.4106
10.8746
10.3178
9.77562
9.26627
8.79294
8.3532
7.94425
7.56295
7.20615
6.87136
6.55682
6.26104
5.98289
5.72111
5.4747
5.24244
5.02344
4.81659
4.62113
4.43615
4.26102
4.09503
3.93762
3.78827
3.64645
3.51181
3.38381
3.26223
3.14657
3.03667
2.93206
2.83259
2.73786
2.64771
2.56181
2.47998
2.402
2.32762
2.25675
2.1891
2.12466
2.06313
2.00456
1.94864
1.89543
1.84467
1.79637
1.75033
1.70648
1.66473
1.62492
1.58704
1.55089
1.51653
1.48371
1.45253
1.4228
1.39454
1.36766
1.34214
1.31795
1.29504
1.2734
1.253
1.2338
1.21582
1.19901
1.18336
1.1689
1.1555
1.14337
1.13219
1.12245
1.11353
1.10688
1.10116
1.10152
1.10323
1.10841
1.11831
1.14265
1.18768
1.27848
1.46999
3.06392
1.55572
1.04738
0.94249
0.968239
1.047
1.21278
1.34496
1.38604
1.3844
1.37913
1.37929
1.38126
1.38658
1.39739
1.40524
1.40782
1.40764
1.40702
1.40564
1.40382
1.40227
1.40089
1.3992
1.3971
1.39489
1.39411
1.39456
1.39658
1.40281
1.41917
1.45922
1.55344
1.77079
2.27362
3.29725
3.69945
3.67796
3.70176
3.72287
3.79133
3.90604
4.0529
4.19832
4.32313
4.41649
4.50341
4.55909
4.59386
4.6121
4.61785
4.61527
4.60545
4.58435
4.55623
4.52463
4.49094
4.45445
4.41538
4.37375
4.32967
4.28363
4.23575
4.18634
4.13581
4.08394
4.03159
3.97875
3.9256
3.87198
3.81857
3.76514
3.71177
3.65854
3.60548
3.55278
3.50036
3.44853
3.39716
3.3464
3.29627
3.24684
3.19802
3.14991
3.10236
3.05561
3.00944
2.96405
2.91927
2.87547
2.83225
2.78991
2.74817
2.70743
2.66752
2.629
2.592
2.55784
2.52788
2.50681
3.71843
2.31611
1.71693
1.46598
1.34999
1.27844
1.26402
1.27193
1.29406
1.33967
1.38503
1.4038
1.40351
1.4022
1.4001
1.40043
1.40156
1.40405
1.4068
1.40678
1.40646
1.40549
1.40342
1.40019
1.39707
1.39438
1.39272
1.39309
1.39489
1.40035
1.4142
1.44762
1.52649
1.71048
2.13815
3.09231
3.71967
3.70315
3.69908
3.726
3.79485
3.89533
4.02273
4.16683
4.29381
4.39646
4.47936
4.53676
4.57362
4.5934
4.60069
4.59935
4.59319
4.57747
4.54877
4.51615
4.4826
4.44661
4.40836
4.36714
4.32368
4.27791
4.23051
4.18142
4.13122
4.07982
4.02775
3.97511
3.92219
3.86894
3.81565
3.76236
3.70911
3.656
3.60304
3.55043
3.49813
3.44636
3.39505
3.34438
3.29426
3.24484
3.19606
3.14796
3.10052
3.0539
3.00805
2.96286
2.91839
2.87441
2.83126
2.78877
2.7472
2.70635
2.66656
2.6278
2.59074
2.55604
2.52546
2.50373
4.54542
3.24224
2.42437
1.9081
1.57868
1.37482
1.25762
1.24501
1.2524
1.27385
1.31851
1.36075
1.3879
1.40075
1.40314
1.40283
1.402
1.40143
1.40151
1.40151
1.4014
1.40106
1.40023
1.3985
1.39579
1.39289
1.39003
1.38991
1.39067
1.39386
1.40257
1.42607
1.47866
1.6094
1.89811
2.56399
3.61145
3.7748
3.79958
3.84114
3.9029
3.98074
4.06964
4.16964
4.2664
4.36227
4.44294
4.50229
4.54169
4.56329
4.57166
4.57092
4.5672
4.55689
4.53487
4.5024
4.46864
4.43324
4.39562
4.35526
4.31255
4.26753
4.22072
4.17228
4.12261
4.07188
4.02034
3.96822
3.9157
3.8629
3.80992
3.75689
3.70389
3.65098
3.59828
3.54581
3.49377
3.44212
3.39108
3.34058
3.2907
3.24145
3.193
3.1452
3.09818
3.0516
3.00576
2.96053
2.9161
2.87224
2.82923
2.78682
2.74535
2.70451
2.66476
2.62587
2.5886
2.55334
2.52197
2.49845
4.99809
3.82353
2.95369
2.34794
1.94206
1.66924
1.49828
1.39167
1.32999
1.31426
1.31767
1.32906
1.35327
1.38141
1.40082
1.41087
1.4108
1.41009
1.40834
1.40524
1.40331
1.40216
1.40128
1.40028
1.39852
1.39597
1.39276
1.39011
1.39042
1.39194
1.39792
1.41093
1.44868
1.52948
1.73237
2.18644
3.20624
3.79431
4.03504
4.12457
4.16764
4.19625
4.20541
4.21621
4.24323
4.29868
4.3683
4.43237
4.48393
4.51572
4.53039
4.53192
4.52989
4.52345
4.50885
4.48062
4.44757
4.41247
4.37555
4.33642
4.29502
4.25132
4.20564
4.15825
4.10952
4.05966
4.00897
3.95758
3.90573
3.85348
3.80104
3.74843
3.69586
3.6433
3.59098
3.53883
3.48716
3.43583
3.38508
3.33488
3.28549
3.2366
3.18841
3.14075
3.09385
3.04744
3.00182
2.95674
2.91252
2.86882
2.82602
2.78371
2.74238
2.70157
2.66188
2.6229
2.58546
2.54969
2.51737
2.49204
5.27096
4.2438
3.40834
2.77522
2.31291
1.97671
1.73297
1.55883
1.4372
1.36078
1.32043
1.32044
1.32386
1.33372
1.35409
1.37434
1.38908
1.39825
1.40087
1.40054
1.39948
1.39724
1.39456
1.39226
1.39029
1.38848
1.38709
1.38523
1.38537
1.38646
1.38895
1.39947
1.41798
1.47799
1.59386
1.88938
2.50743
3.68456
4.37392
4.59503
4.59023
4.54688
4.43776
4.30842
4.24875
4.2525
4.27375
4.32372
4.38798
4.43743
4.46834
4.48239
4.48219
4.4794
4.4711
4.45267
4.4219
4.38683
4.35013
4.31194
4.27195
4.22988
4.18583
4.13998
4.09259
4.04391
3.99427
3.9438
3.89276
3.84121
3.78941
3.73737
3.68534
3.63323
3.58143
3.52972
3.47853
3.42775
3.37767
3.32799
3.27901
3.23042
3.18253
3.13508
3.08844
3.04225
2.99692
2.95202
2.90806
2.86452
2.82195
2.7798
2.73866
2.69799
2.65841
2.61947
2.58193
2.54584
2.51296
2.48608
5.45694
4.56565
3.79002
3.16119
2.6702
2.29315
2.00588
1.78922
1.62705
1.5101
1.42543
1.37172
1.34284
1.34037
1.34279
1.35001
1.36509
1.38179
1.39464
1.40286
1.40425
1.40384
1.4026
1.3999
1.39592
1.39225
1.38918
1.38641
1.3852
1.38566
1.38738
1.39349
1.40699
1.44366
1.52382
1.71986
2.16316
3.18023
4.68712
5.20034
5.14496
4.98554
4.69393
4.45084
4.29457
4.22908
4.22116
4.22827
4.25391
4.3069
4.35728
4.39483
4.41429
4.41818
4.41578
4.40742
4.38852
4.3565
4.32016
4.28218
4.24293
4.20231
4.16022
4.11646
4.07102
4.02406
3.97588
3.92663
3.87663
3.82596
3.77496
3.72361
3.67225
3.6207
3.56953
3.51867
3.46828
3.41817
3.36863
3.31936
3.27075
3.22245
3.17491
3.12773
3.08142
3.03548
2.99047
2.94583
2.90216
2.85887
2.81656
2.77467
2.73374
2.69329
2.65384
2.61502
2.57747
2.54118
2.50797
2.47994
5.58462
4.8101
4.10287
3.49784
2.99978
2.59866
2.27955
2.02734
1.82855
1.67353
1.55326
1.46482
1.39991
1.36188
1.34197
1.34205
1.34413
1.34993
1.36188
1.3744
1.38372
1.39015
1.3907
1.39038
1.3894
1.38731
1.3842
1.38124
1.37965
1.38002
1.38162
1.38636
1.39808
1.4269
1.49253
1.64905
2.0111
2.86557
4.72905
5.84275
5.75838
5.50585
5.07225
4.7066
4.44701
4.28685
4.20559
4.17941
4.17689
4.18552
4.21158
4.26226
4.30341
4.33326
4.34418
4.34281
4.33631
4.32042
4.28871
4.25207
4.21263
4.1723
4.13135
4.08935
4.04596
4.00105
3.95477
3.9071
3.8584
3.80878
3.75866
3.70808
3.65747
3.60692
3.55664
3.50649
3.45682
3.40725
3.35824
3.30939
3.26124
3.21332
3.16622
3.1194
3.07347
3.02787
2.9832
2.9389
2.89553
2.85257
2.81052
2.76894
2.72824
2.68807
2.64879
2.61016
2.57268
2.53633
2.50298
2.47417
5.6777
4.9957
4.35235
3.77991
3.28965
2.87959
2.54174
2.26558
2.04107
1.85971
1.71378
1.59808
1.50782
1.44057
1.39123
1.36296
1.3473
1.34738
1.34911
1.35398
1.36404
1.37527
1.38408
1.39068
1.39093
1.3904
1.38889
1.38577
1.38232
1.38248
1.3836
1.3892
1.39934
1.43144
1.49069
1.64489
1.95502
2.66514
4.13897
5.9055
5.98415
5.8498
5.51921
5.11692
4.74788
4.48613
4.30451
4.19273
4.14257
4.12418
4.12492
4.13449
4.15987
4.20732
4.23854
4.25928
4.26017
4.25654
4.2448
4.21933
4.18252
4.14223
4.10102
4.05916
4.01677
3.97354
3.9293
3.88355
3.8366
3.7884
3.73937
3.68988
3.64043
3.59083
3.5415
3.49207
3.44308
3.39408
3.34567
3.29736
3.24974
3.20234
3.15571
3.10938
3.06387
3.01873
2.97444
2.93057
2.88754
2.84498
2.80325
2.76203
2.72162
2.68177
2.64273
2.60433
2.567
2.53068
2.49731
2.46801
5.74508
5.13907
4.55375
4.0171
3.54292
3.13408
2.78718
2.49591
2.2527
2.05079
1.88342
1.74564
1.633
1.54205
1.4706
1.41679
1.37792
1.3565
1.34565
1.34583
1.34734
1.35139
1.3596
1.36789
1.37381
1.37783
1.37974
1.3797
1.37974
1.3805
1.38276
1.39095
1.40781
1.45171
1.54133
1.74109
2.14147
2.94162
3.70304
4.69577
5.52071
5.67662
5.6165
5.42999
5.08878
4.8
4.52426
4.32922
4.19605
4.11379
4.08125
4.06549
4.06734
4.07815
4.10374
4.14084
4.16252
4.1723
4.17054
4.16313
4.14563
4.11125
4.07219
4.02962
3.98672
3.94383
3.90078
3.85668
3.81165
3.76519
3.71811
3.67004
3.62184
3.57321
3.52473
3.47604
3.42773
3.37941
3.33163
3.28398
3.23696
3.19017
3.14408
3.09832
3.05329
3.00867
2.96481
2.9214
2.87879
2.83665
2.79529
2.75445
2.71438
2.67485
2.63612
2.59796
2.56088
2.52462
2.49136
2.46174
5.79763
5.25188
4.717
4.21581
3.76183
3.36071
3.012
2.71253
2.45694
2.24014
2.05659
1.90192
1.77194
1.66362
1.57429
1.50165
1.44515
1.40175
1.37075
1.35342
1.34462
1.34481
1.34617
1.34976
1.35708
1.36503
1.37167
1.37601
1.37849
1.38195
1.38946
1.4051
1.44051
1.51498
1.67451
1.99858
2.64816
3.19897
3.52438
3.92008
4.43971
5.01689
5.35028
5.32979
5.24008
5.04631
4.78995
4.57222
4.36217
4.21132
4.10997
4.04669
4.02093
4.00416
4.00606
4.01508
4.03526
4.06187
4.07674
4.0776
4.07425
4.06318
4.03919
4.00053
3.95828
3.91462
3.87098
3.82719
3.78336
3.73869
3.69349
3.64725
3.60055
3.55313
3.50563
3.4578
3.41025
3.36267
3.31558
3.26865
3.22231
3.17622
3.13076
3.08563
3.04119
2.99713
2.95381
2.91092
2.86879
2.82712
2.78623
2.7458
2.70616
2.66698
2.62864
2.59075
2.55397
2.51785
2.48476
2.4549
5.83729
5.34166
4.85081
4.38343
3.95188
3.56273
3.21752
2.91517
2.65226
2.42516
2.22945
2.0615
1.91748
1.79461
1.69012
1.60202
1.52882
1.46888
1.42186
1.38615
1.36122
1.34713
1.34064
1.34087
1.34221
1.34551
1.35219
1.36007
1.36868
1.37832
1.39409
1.42585
1.49302
1.63104
1.91567
2.48976
3.08037
3.3393
3.45793
3.6
3.81347
4.11453
4.53551
4.86237
5.02044
5.00012
4.92295
4.75339
4.56595
4.40179
4.24
4.1157
4.03318
3.97916
3.95415
3.93512
3.9368
3.94331
3.9572
3.97566
3.98291
3.98139
3.97503
3.95924
3.92742
3.88674
3.84234
3.79764
3.75385
3.71012
3.66628
3.62167
3.57658
3.53063
3.48442
3.43769
3.39111
3.34441
3.29814
3.25199
3.2064
3.16103
3.11629
3.07182
3.02803
2.98458
2.94185
2.8995
2.85792
2.81673
2.77634
2.73635
2.69717
2.65838
2.62044
2.58288
2.54645
2.51052
2.47767
2.44765
5.87021
5.41434
4.96143
4.52552
4.11685
3.74216
3.4039
3.10257
2.83615
2.60237
2.39775
2.2195
2.06426
1.9296
1.81292
1.71235
1.6262
1.55316
1.49224
1.44239
1.40334
1.37371
1.35331
1.34152
1.33797
1.3387
1.34136
1.34743
1.35979
1.37847
1.40855
1.46956
1.59292
1.84553
2.35427
3.00887
3.30935
3.40166
3.43284
3.47049
3.53342
3.64198
3.81531
4.05055
4.37114
4.61701
4.74571
4.73019
4.67254
4.54545
4.39061
4.25972
4.13406
4.02395
3.94984
3.904
3.87672
3.85744
3.85862
3.86329
3.87306
3.88556
3.88531
3.8823
3.87292
3.85188
3.81319
3.77012
3.72581
3.68145
3.63766
3.59373
3.5498
3.5052
3.46041
3.41507
3.36978
3.32424
3.27901
3.2338
3.18908
3.14451
3.10053
3.05678
3.01367
2.97086
2.92876
2.88699
2.84599
2.80535
2.76549
2.726
2.6873
2.64895
2.61144
2.57426
2.53818
2.50251
2.46993
2.43976
5.89539
5.47315
5.05501
4.64881
4.26268
3.90345
3.57432
3.27656
3.00953
2.77171
2.56089
2.37462
2.21051
2.06608
1.93939
1.82833
1.73151
1.64732
1.57493
1.51311
1.46157
1.41936
1.38631
1.36207
1.34496
1.34079
1.34217
1.34685
1.35972
1.38447
1.43864
1.54485
1.76553
2.20647
2.88285
3.28029
3.40117
3.4208
3.42002
3.41533
3.40714
3.41557
3.44997
3.53055
3.68861
3.90457
4.18272
4.3896
4.51073
4.49998
4.45999
4.37501
4.23872
4.12877
4.02749
3.92956
3.86339
3.8224
3.79412
3.77408
3.77505
3.77862
3.78494
3.78927
3.7878
3.78197
3.76771
3.73832
3.69845
3.65435
3.61012
3.5659
3.52211
3.47813
3.4344
3.39039
3.34651
3.30236
3.25839
3.21432
3.17057
3.12691
3.08371
3.04074
2.99833
2.95622
2.91476
2.87364
2.83321
2.79315
2.75382
2.71487
2.67665
2.63879
2.60171
2.56496
2.52928
2.4939
2.46164
2.43135
5.92499
5.531
5.14072
4.75906
4.39348
4.04917
3.7298
3.43706
3.17123
2.93152
2.71654
2.52442
2.35327
2.20109
2.06605
1.94636
1.84063
1.74726
1.66549
1.59393
1.53221
1.47953
1.43546
1.40021
1.373
1.35819
1.35948
1.36504
1.3841
1.42089
1.51019
1.68541
2.0494
2.71482
3.20995
3.39186
3.42416
3.42188
3.40981
3.38001
3.32382
3.27794
3.27734
3.28813
3.3247
3.40619
3.56017
3.75212
3.98275
4.16397
4.29101
4.29028
4.27024
4.2166
4.10801
4.00588
3.91666
3.83789
3.77578
3.73462
3.70712
3.68859
3.68794
3.68926
3.69238
3.69188
3.68872
3.67957
3.6596
3.62268
3.58125
3.53759
3.49361
3.44964
3.40638
3.36337
3.32075
3.27809
3.23554
3.19288
3.15036
3.10784
3.0656
3.02353
2.98189
2.94053
2.89973
2.85927
2.81945
2.78001
2.74124
2.70284
2.66515
2.62779
2.5912
2.55487
2.51964
2.48455
2.45267
2.42232
5.96348
5.5895
5.22183
4.8609
4.51285
4.18239
3.87236
3.58526
3.32167
3.08162
2.864
2.66788
2.49128
2.33305
2.19121
2.06439
1.95129
1.85022
1.76067
1.68099
1.61095
1.54965
1.4964
1.45247
1.41569
1.39558
1.39756
1.40791
1.434
1.50374
1.64232
1.94253
2.53735
3.10072
3.36256
3.42305
3.42196
3.41136
3.38209
3.32223
3.2592
3.20645
3.16876
3.14633
3.14963
3.16382
3.20042
3.27595
3.40768
3.5736
3.76886
3.94307
4.07004
4.10696
4.09581
4.06166
3.98648
3.89041
3.8121
3.74355
3.68444
3.64446
3.61732
3.60009
3.59658
3.59697
3.59683
3.5951
3.58902
3.57418
3.54394
3.50515
3.46339
3.42037
3.37762
3.33526
3.29352
3.25201
3.21077
3.16951
3.12835
3.08712
3.04606
3.00503
2.96433
2.9238
2.88376
2.84398
2.80482
2.76597
2.72781
2.68995
2.65282
2.61595
2.57989
2.54399
2.50925
2.47447
2.44302
2.41264
6.02194
5.65397
5.30101
4.95758
4.62379
4.30418
4.00285
3.72149
3.46096
3.22188
3.00299
2.80436
2.62392
2.46095
2.3139
2.18113
2.06202
1.95443
1.85836
1.77184
1.69482
1.62652
1.56561
1.51584
1.47078
1.45638
1.46051
1.48053
1.52426
1.64902
1.88648
2.40006
3.0067
3.33274
3.42769
3.42666
3.41568
3.38543
3.32344
3.25768
3.20117
3.15187
3.1082
3.0701
3.04206
3.02229
3.02504
3.03683
3.0663
3.12721
3.23776
3.38322
3.55264
3.72451
3.85132
3.93573
3.93039
3.91093
3.87169
3.79439
3.71333
3.64552
3.5924
3.55237
3.5234
3.50883
3.50673
3.50638
3.50476
3.4997
3.48767
3.46257
3.42875
3.39011
3.34936
3.30782
3.26647
3.22539
3.18483
3.14451
3.10454
3.06457
3.02482
2.98498
2.94542
2.90585
2.86671
2.82769
2.78926
2.75103
2.71349
2.67617
2.63962
2.60325
2.56772
2.53227
2.49804
2.46361
2.43261
2.40224
6.10634
5.72373
5.37719
5.04501
4.72375
4.41545
4.12205
3.84688
3.58972
3.35266
3.13381
2.93372
2.75101
2.58435
2.43343
2.29579
2.17175
2.05876
1.95707
1.86487
1.78191
1.70779
1.64136
1.58701
1.54124
1.542
1.55319
1.58442
1.68486
1.8789
2.31406
2.96009
3.33266
3.45624
3.45506
3.44247
3.40548
3.33086
3.25841
3.19801
3.14762
3.10129
3.0577
3.01622
2.97725
2.94243
2.91569
2.89402
2.89577
2.90375
2.92519
2.97135
3.06338
3.18892
3.34162
3.50507
3.6473
3.74947
3.78684
3.77877
3.7523
3.6941
3.61912
3.55088
3.49555
3.45332
3.42784
3.41715
3.41356
3.41156
3.40722
3.39771
3.37875
3.35044
3.3164
3.27873
3.23936
3.19917
3.15911
3.11923
3.07991
3.04079
3.00211
2.96339
2.92501
2.88652
2.84843
2.8103
2.77271
2.73517
2.69831
2.66157
2.62559
2.58974
2.55474
2.51977
2.48603
2.45198
2.42144
2.39111
6.19149
5.79935
5.45036
5.12565
4.81424
4.51615
4.23136
3.96255
3.70976
3.47486
3.25743
3.05663
2.87268
2.70354
2.54937
2.40821
2.27969
2.16251
2.05579
1.95893
1.87102
1.79196
1.72342
1.6643
1.64084
1.64679
1.67474
1.74461
1.9234
2.28272
2.95796
3.38056
3.52326
3.5211
3.50402
3.45468
3.36813
3.28975
3.21998
3.15869
3.1038
3.05468
3.01047
2.96739
2.92576
2.88594
2.84815
2.81462
2.78708
2.76535
2.76213
2.76693
2.78286
2.81828
2.89144
2.9992
3.13623
3.29132
3.44774
3.56552
3.64839
3.64591
3.63151
3.60047
3.53676
3.46498
3.40703
3.36485
3.33867
3.32475
3.31767
3.31281
3.30551
3.29084
3.26887
3.24031
3.20718
3.1708
3.13286
3.09404
3.05533
3.01669
2.97863
2.94068
2.90324
2.86574
2.82869
2.79152
2.75487
2.71816
2.68207
2.646
2.61065
2.57537
2.54092
2.50644
2.47323
2.43958
2.40953
2.37928
6.31796
5.89299
5.52644
5.20177
4.89771
4.60823
4.33171
4.07008
3.82265
3.59045
3.37466
3.17434
2.9894
2.81894
2.66201
2.51814
2.38592
2.26508
2.15427
2.05339
1.96147
1.88
1.80963
1.76224
1.765
1.78336
1.84806
1.99526
2.32384
2.97724
3.46821
3.63757
3.63445
3.61185
3.54927
3.44733
3.35356
3.27371
3.20364
3.14072
3.08206
3.02666
2.97447
2.92621
2.88175
2.83876
2.79732
2.75782
2.7206
2.68764
2.6589
2.63781
2.62785
2.63089
2.64218
2.66891
2.72573
2.81759
2.93891
3.08894
3.24779
3.39
3.49501
3.5355
3.52618
3.49861
3.44127
3.37446
3.32288
3.28109
3.2521
3.23488
3.2241
3.21452
3.20246
3.18497
3.16201
3.13364
3.10151
3.06638
3.02987
2.9924
2.95502
2.91758
2.88074
2.84391
2.80768
2.77139
2.73566
2.69984
2.66461
2.62932
2.5947
2.56007
2.52624
2.49231
2.45966
2.42644
2.3969
2.36677
6.34676
5.98755
5.60779
5.27785
4.97685
4.69438
4.42536
4.16981
3.92857
3.70055
3.48666
3.28731
3.10197
2.93046
2.7717
2.62534
2.49038
2.36622
2.25216
2.14814
2.05338
1.97328
1.90435
1.89956
1.91335
1.9595
2.10751
2.39652
3.03011
3.59795
3.80233
3.79854
3.77111
3.69623
3.56414
3.44684
3.35114
3.2704
3.19945
3.13536
3.07371
3.01417
2.95653
2.90116
2.84938
2.80143
2.75597
2.71265
2.67135
2.63209
2.59549
2.56262
2.53344
2.51249
2.49672
2.49874
2.50685
2.52658
2.56716
2.64497
2.75424
2.89682
3.05644
3.22055
3.34582
3.42332
3.41586
3.39328
3.35018
3.29042
3.24085
3.19857
3.16774
3.1471
3.13202
3.11804
3.10238
3.08276
3.05907
3.03079
2.99954
2.96546
2.93022
2.89398
2.85788
2.82161
2.78595
2.75029
2.71529
2.68026
2.64587
2.61142
2.5776
2.54372
2.5106
2.4773
2.44528
2.41255
2.38357
2.35361
6.31297
6.1011
5.70748
5.36036
5.05773
4.77991
4.51588
4.26552
4.02872
3.80531
3.59429
3.3961
3.21101
3.03871
2.87864
2.73029
2.59301
2.46624
2.3497
2.24337
2.1502
2.0711
2.04342
2.05407
2.09726
2.22682
2.50733
3.11056
3.76818
4.01478
4.01036
3.97774
3.88842
3.73122
3.59006
3.47283
3.37411
3.28783
3.21019
3.13852
3.07211
3.0104
2.94907
2.88951
2.83161
2.77635
2.72498
2.67745
2.63219
2.58917
2.5484
2.50974
2.47395
2.44107
2.41232
2.3901
2.37182
2.37161
2.37576
2.38998
2.42097
2.48569
2.5845
2.71761
2.87824
3.05527
3.20408
3.30864
3.30482
3.28978
3.26037
3.20254
3.15527
3.11419
3.08318
3.05998
3.04127
3.02366
3.00533
2.98379
2.95963
2.93119
2.90078
2.8676
2.83351
2.79849
2.76366
2.72863
2.69422
2.65984
2.62612
2.59244
2.55939
2.52632
2.49397
2.46141
2.43009
2.39795
2.36958
2.33988
6.2206
6.09897
5.82398
5.45853
5.14245
4.86281
4.60449
4.35928
4.12561
3.90488
3.697
3.50079
3.31624
3.14382
2.98277
2.83306
2.69397
2.56542
2.44725
2.34225
2.25177
2.20418
2.2116
2.25027
2.36129
2.63372
3.20531
3.96384
4.26496
4.26076
4.22404
4.12024
3.9385
3.77461
3.63782
3.52093
3.41776
3.32427
3.23831
3.15828
3.0835
3.01304
2.94718
2.88557
2.8236
2.76399
2.70677
2.65281
2.60261
2.55569
2.51129
2.46913
2.42915
2.39141
2.35642
2.32397
2.29591
2.27221
2.2544
2.24841
2.2514
2.26219
2.28676
2.33919
2.42786
2.55074
2.71264
2.90016
3.07389
3.19183
3.20127
3.19085
3.16481
3.1128
3.0683
3.03013
2.99877
2.973
2.9513
2.93071
2.9104
2.88737
2.86283
2.83452
2.80471
2.77256
2.73968
2.70599
2.67248
2.63882
2.60573
2.57271
2.54032
2.50799
2.47637
2.44457
2.41401
2.38254
2.35486
2.32555
6.11639
6.06172
5.89569
5.56038
5.23387
4.9487
4.69075
4.44929
4.22005
4.00185
3.79565
3.6015
3.41827
3.24589
3.08447
2.9336
2.79355
2.66389
2.54729
2.44613
2.37946
2.38413
2.41719
2.51862
2.78045
3.33112
4.19267
4.55064
4.54665
4.50561
4.38567
4.17917
3.99275
3.83631
3.70206
3.58245
3.47338
3.37227
3.27801
3.18957
3.10655
3.02836
2.95498
2.88548
2.82113
2.7591
2.69832
2.6398
2.58395
2.53183
2.48343
2.43754
2.39414
2.3531
2.31422
2.27767
2.24356
2.21198
2.18444
2.16004
2.14278
2.13236
2.13441
2.14269
2.16227
2.20561
2.2839
2.39866
2.56228
2.75985
2.95333
3.07619
3.1017
3.0931
3.06945
3.02336
2.98235
2.94588
2.91367
2.88562
2.86173
2.83907
2.81737
2.79348
2.76861
2.7408
2.71157
2.6806
2.64902
2.61676
2.58464
2.55243
2.52069
2.48904
2.45808
2.42699
2.39716
2.3664
2.33942
2.31061
5.91561
5.95652
5.88158
5.68752
5.34697
5.04452
4.77996
4.53845
4.31211
4.09688
3.89207
3.69895
3.51718
3.34561
3.18405
3.03286
2.89255
2.76402
2.65397
2.56765
2.56963
2.59661
2.6908
2.93165
3.44933
4.42465
4.85864
4.85545
4.81138
4.67996
4.44756
4.2377
4.06199
3.91067
3.77548
3.6513
3.53585
3.4274
3.32549
3.22932
3.13876
3.0533
2.9728
2.89689
2.82548
2.75822
2.69554
2.63412
2.57496
2.51821
2.46442
2.41426
2.36745
2.32322
2.28131
2.24166
2.20409
2.16884
2.13575
2.10529
2.07819
2.05391
2.03684
2.02336
2.02485
2.03128
2.04753
2.08332
2.15255
2.26317
2.42734
2.63166
2.84555
2.96646
3.0036
2.99593
2.9749
2.93397
2.89645
2.86068
2.82767
2.79832
2.77315
2.74929
2.72659
2.70248
2.67731
2.65017
2.62178
2.59209
2.56184
2.53106
2.50036
2.46955
2.43932
2.40891
2.37978
2.3497
2.3234
2.29517
5.42852
5.83991
5.82016
5.71281
5.47257
5.1542
4.87547
4.62921
4.40287
4.1902
3.98862
3.79641
3.61414
3.44282
3.2818
3.13119
2.99219
2.87206
2.77153
2.76589
2.78984
2.87982
3.11877
3.63404
4.66648
5.17689
5.18791
5.14315
4.99905
4.74003
4.50644
4.311
4.14286
3.99213
3.85344
3.72372
3.60176
3.48643
3.37757
3.27448
3.17722
3.0852
2.99837
2.91635
2.83893
2.76599
2.6971
2.63261
2.5717
2.51195
2.4547
2.40008
2.34899
2.30124
2.25614
2.21347
2.17309
2.13492
2.09883
2.06495
2.03307
2.00383
1.97729
1.9537
1.9365
1.92148
1.9224
1.92751
1.94081
1.97189
2.03475
2.14443
2.30564
2.51335
2.74435
2.86016
2.90462
2.89837
2.88079
2.84621
2.81039
2.77505
2.74197
2.71231
2.68637
2.66209
2.63855
2.61442
2.5894
2.56305
2.53567
2.50727
2.4784
2.44903
2.4199
2.39038
2.36202
2.33265
2.30703
2.27939
4.37173
5.56496
5.7353
5.6891
5.55305
5.27183
4.97912
4.72442
4.49562
4.28302
4.08218
3.89157
3.71071
3.53954
3.37909
3.23012
3.09947
2.98985
2.97039
2.99346
3.08335
3.32575
3.86072
4.94486
5.53074
5.55629
5.50608
5.34408
5.05644
4.7975
4.58161
4.39608
4.22988
4.0765
3.93288
3.79724
3.66897
3.54728
3.43217
3.32297
3.21977
3.12195
3.02949
2.94195
2.85919
2.78096
2.70702
2.63736
2.57143
2.50994
2.45059
2.39333
2.33849
2.28653
2.23808
2.1924
2.14923
2.10839
2.06976
2.03322
1.99868
1.96622
1.93563
1.90759
1.8818
1.8591
1.84171
1.82666
1.82656
1.83006
1.84248
1.87031
1.9294
2.04051
2.20367
2.40786
2.64803
2.75889
2.80747
2.80279
2.78848
2.75934
2.72481
2.69037
2.65774
2.62826
2.60204
2.57753
2.55381
2.52985
2.50532
2.47982
2.45357
2.42641
2.39907
2.37097
2.34376
2.31532
2.29046
2.26351
2.75736
4.93573
5.57611
5.61588
5.55085
5.39072
5.10062
4.83071
4.59232
4.37667
4.17543
3.98546
3.80539
3.6356
3.47711
3.33674
3.21866
3.18705
3.20928
3.30028
3.54877
4.11
5.25153
5.91742
5.95906
5.90206
5.71778
5.39804
5.11145
4.87342
4.66976
4.48744
4.31919
4.16125
4.01198
3.87037
3.73609
3.60859
3.48782
3.37318
3.2647
3.16172
3.06427
2.97182
2.8843
2.80137
2.72288
2.64862
2.57842
2.51213
2.44964
2.39098
2.33363
2.2788
2.22661
2.17773
2.13173
2.08823
2.04706
2.00809
1.97122
1.93634
1.90339
1.87242
1.84321
1.81643
1.79163
1.7698
1.75269
1.7379
1.73709
1.74039
1.75197
1.77908
1.83714
1.94931
2.11233
2.32333
2.55877
2.66365
2.71433
2.71096
2.69885
2.67399
2.64079
2.60742
2.57564
2.54667
2.52062
2.49623
2.47273
2.44919
2.42541
2.4008
2.37586
2.34983
2.32436
2.29733
2.27355
2.24759
2.10203
3.51977
5.14106
5.50901
5.50176
5.42278
5.23809
4.95308
4.69881
4.4743
4.26974
4.07799
3.89928
3.73189
3.58214
3.45584
3.41488
3.43669
3.52927
3.78511
4.36571
5.55394
6.32186
6.38215
6.31893
6.11489
5.76274
5.44752
5.18648
4.96358
4.76448
4.5806
4.40795
4.24445
4.08932
3.9419
3.80203
3.66918
3.54331
3.42377
3.31059
3.20305
3.10119
3.00438
2.91264
2.82552
2.74293
2.66461
2.59043
2.52018
2.45383
2.39093
2.33205
2.27546
2.22093
2.16886
2.11993
2.0738
2.03013
1.98878
1.94963
1.91257
1.8775
1.84434
1.813
1.78357
1.75578
1.73029
1.70667
1.68571
1.66933
1.65497
1.65423
1.65754
1.66882
1.69662
1.7546
1.86809
2.02675
2.24833
2.47735
2.57396
2.62503
2.62274
2.61256
2.59069
2.5591
2.52703
2.49641
2.46825
2.44278
2.41881
2.39585
2.37289
2.3501
2.32635
2.30304
2.27801
2.25573
2.23137
1.62574
2.32886
4.18697
5.23871
5.42209
5.39542
5.2959
5.0804
4.81112
4.57364
4.36304
4.172
3.99451
3.83593
3.70135
3.65262
3.67469
3.77105
4.03948
4.65321
5.91895
6.76045
6.82998
6.75909
6.53323
6.14752
5.80342
5.51888
5.27643
5.05985
4.85992
4.67189
4.4938
4.32452
4.16371
4.01087
3.86587
3.72819
3.59772
3.4738
3.35637
3.24473
3.13889
3.03818
2.94266
2.85178
2.76556
2.68364
2.60593
2.53223
2.46238
2.39625
2.33365
2.27463
2.21866
2.16458
2.11287
2.06412
2.01805
1.9744
1.93304
1.89388
1.8568
1.8217
1.78849
1.75711
1.72743
1.69961
1.6733
1.64911
1.62682
1.6067
1.59142
1.57756
1.5777
1.58129
1.59248
1.6221
1.68242
1.79955
1.9546
2.17831
2.40129
2.48997
2.53975
2.53855
2.53022
2.51071
2.4808
2.45017
2.4209
2.39375
2.36913
2.34576
2.32363
2.30132
2.2799
2.25694
2.23652
2.21437
1.27937
1.73792
2.62696
4.60721
5.25104
5.33194
5.28742
5.16998
4.92991
4.68127
4.46295
4.26932
4.09935
3.95762
3.90041
3.92311
4.02469
4.30919
4.96303
6.31534
7.24712
7.3138
7.23048
6.9753
6.55365
6.17912
5.87047
5.60784
5.37339
5.15661
4.95268
4.75918
4.57531
4.40039
4.23426
4.07645
3.92679
3.78474
3.65008
3.52221
3.40095
3.28563
3.1762
3.07201
2.97308
2.87887
2.78941
2.70429
2.62347
2.5467
2.47383
2.40472
2.33917
2.27713
2.21832
2.16301
2.10947
2.05831
2.01002
1.96425
1.92085
1.8797
1.84071
1.80376
1.76877
1.73566
1.70432
1.67474
1.64674
1.6205
1.59574
1.57281
1.55202
1.5327
1.5188
1.50582
1.50654
1.51163
1.52223
1.55615
1.61639
1.73857
1.90276
2.12168
2.33055
2.41316
2.46002
2.45954
2.45224
2.43449
2.40641
2.37746
2.34981
2.32382
2.30026
2.27758
2.25668
2.23508
2.21621
2.19628
1.17403
1.36797
1.96808
3.19723
4.79345
5.20833
5.23419
5.17937
5.04649
4.80254
4.57526
4.38193
4.223
4.15831
4.18216
4.29088
4.59774
5.30536
6.77206
7.78197
7.83099
7.73056
7.44121
6.98259
6.5771
6.24342
5.95971
5.70609
5.47145
5.25029
5.04055
4.84102
4.65145
4.47123
4.30026
4.13794
3.98409
3.83809
3.69966
3.56818
3.44343
3.32478
3.21208
3.10476
3.00277
2.90561
2.81327
2.72534
2.6418
2.56233
2.48685
2.41514
2.34705
2.28243
2.22116
2.16298
2.10825
2.05548
2.00504
1.9574
1.91215
1.86919
1.82843
1.78977
1.75313
1.7184
1.68553
1.65442
1.62498
1.5972
1.5709
1.54621
1.52304
1.50132
1.48206
1.46375
1.45096
1.44008
1.44112
1.44617
1.46084
1.49314
1.5604
1.68355
1.85397
2.07329
2.26525
2.34156
2.38518
2.38583
2.37957
2.36288
2.33679
2.30967
2.28374
2.25896
2.23681
2.21512
2.19641
2.17803
1.08128
1.2212
1.48537
2.21407
3.74756
4.87798
5.14116
5.1361
5.0764
4.9347
4.70758
4.5132
4.42741
4.45207
4.56963
4.90249
5.6739
7.2711
8.34137
8.3688
8.24901
7.92535
7.43277
6.9966
6.6382
6.33324
6.05994
5.80612
5.56649
5.33883
5.12253
4.91691
4.72187
4.53672
4.36131
4.19489
4.03723
3.88761
3.74577
3.61098
3.48309
3.36141
3.24579
3.13565
3.03094
2.93114
2.83627
2.74586
2.65994
2.57813
2.50039
2.42643
2.35614
2.28933
2.22586
2.16562
2.10836
2.05443
2.00248
1.95306
1.90617
1.86161
1.81928
1.77907
1.74094
1.70476
1.67048
1.63797
1.60719
1.57807
1.55048
1.52445
1.49985
1.47663
1.4551
1.4346
1.41685
1.39989
1.38793
1.37991
1.38115
1.38767
1.4026
1.43987
1.5121
1.64422
1.81761
2.03133
2.20566
2.27715
2.31661
2.3179
2.31212
2.29682
2.2727
2.2475
2.22357
2.20028
2.18063
2.16192
1.04144
1.11583
1.23589
1.64001
2.38322
4.14031
4.9175
5.07122
5.05697
4.99524
4.85515
4.7219
4.74375
4.86795
5.22855
6.08001
7.83492
8.96493
8.95102
8.79365
8.41156
7.89509
7.4354
7.05461
6.72875
6.43517
6.16131
5.90177
5.65493
5.42016
5.1974
4.98614
4.78612
4.59657
4.41715
4.24702
4.0859
3.93295
3.78795
3.65021
3.51942
3.39498
3.27672
3.16406
3.05691
2.9548
2.85768
2.76513
2.67714
2.5933
2.5136
2.43771
2.36554
2.29688
2.23158
2.16949
2.1105
2.05441
2.00144
1.95052
1.90219
1.85623
1.81254
1.77101
1.73156
1.6941
1.65854
1.6248
1.59281
1.56248
1.53374
1.50654
1.48079
1.45643
1.43354
1.4118
1.39186
1.37281
1.35628
1.34136
1.32969
1.32533
1.32699
1.33458
1.35186
1.39285
1.47023
1.60809
1.7884
1.99758
2.15227
2.21903
2.25458
2.25655
2.2512
2.23712
2.21505
2.19202
2.17152
2.15124
1.02509
1.04977
1.13848
1.28674
1.73874
2.60452
4.36361
4.9169
5.02659
5.02276
5.00913
5.0338
5.17542
5.5807
6.5391
8.48383
9.59867
9.56756
9.36603
8.91322
8.37032
7.89148
7.49047
7.14429
6.83007
6.53524
6.25488
5.98763
5.73348
5.4923
5.26399
5.0479
4.84359
4.65017
4.46718
4.29373
4.12946
3.97356
3.82573
3.68525
3.55185
3.42491
3.30425
3.18933
3.08006
2.97594
2.87692
2.78255
2.69281
2.60729
2.52593
2.4484
2.37467
2.30444
2.23764
2.17403
2.11354
2.05598
2.00132
1.94934
1.8998
1.85263
1.80777
1.76508
1.72449
1.6859
1.64924
1.61441
1.58134
1.54994
1.52016
1.49192
1.46517
1.43981
1.41589
1.39321
1.37201
1.35189
1.33338
1.31617
1.30053
1.28813
1.27708
1.27614
1.27832
1.28816
1.30709
1.35416
1.44013
1.58318
1.76687
1.96948
2.10628
2.16872
2.20025
2.20257
2.1977
2.18493
2.16618
2.14691
1.01148
1.03104
1.06364
1.17129
1.37185
1.93334
3.11004
4.49066
4.9274
5.0558
5.16485
5.41681
5.95462
7.10035
9.31242
10.3352
10.2699
10.0019
9.44007
8.86535
8.37279
7.957
7.59057
7.25302
6.9339
6.62955
6.3395
6.06392
5.80297
5.55622
5.32324
5.10306
4.89507
4.69822
4.51202
4.33554
4.16837
4.00974
3.85929
3.71635
3.58054
3.45135
3.3285
3.21157
3.10036
2.99442
2.89365
2.79767
2.70638
2.6194
2.53669
2.45789
2.38288
2.3114
2.24335
2.1785
2.11678
2.05802
2.00207
1.94899
1.89835
1.85015
1.80427
1.76063
1.7191
1.6796
1.64202
1.60629
1.57231
1.54002
1.50933
1.48018
1.45253
1.4263
1.40149
1.37798
1.35588
1.33495
1.31537
1.29707
1.27988
1.26468
1.25018
1.23987
1.23115
1.23195
1.2354
1.24843
1.27054
1.32485
1.4182
1.56368
1.75265
1.94851
2.06807
2.12678
2.15413
2.15805
2.1542
2.14484
1.00705
1.01422
1.03836
1.07948
1.2116
1.45963
2.12406
3.48916
4.62685
5.04177
5.43207
6.21089
7.73728
10.2544
11.1474
11.0407
10.696
10.0008
9.37138
8.86309
8.43712
8.05521
7.69564
7.35101
7.02073
6.70582
6.40718
6.12496
5.85882
5.60783
5.37118
5.14769
4.93665
4.73697
4.54809
4.36909
4.19954
4.03864
3.88601
3.741
3.60334
3.47246
3.34802
3.22956
3.11684
3.00954
2.90744
2.81024
2.71776
2.62967
2.54584
2.46595
2.3899
2.3174
2.24836
2.18253
2.11985
2.06011
2.00324
1.94912
1.89758
1.84849
1.8018
1.75734
1.71504
1.67477
1.63643
1.59994
1.5652
1.53215
1.50071
1.47083
1.44245
1.41553
1.39002
1.36582
1.34298
1.32138
1.30106
1.28202
1.26405
1.24762
1.23202
1.21846
1.20618
1.19665
1.19253
1.19367
1.19965
1.21136
1.24341
1.30259
1.40759
1.55459
1.74631
1.93664
2.03776
2.09627
2.11802
2.13312
1.0032
1.00859
1.01725
1.04663
1.09615
1.25576
1.55425
2.32897
3.90286
4.9736
6.03588
8.15711
11.337
12.1259
11.9598
11.476
10.6048
9.91345
9.38041
8.94303
8.54574
8.16434
7.7937
7.43609
7.09469
6.7713
6.46638
6.17932
5.90919
5.65467
5.41475
5.18822
4.97428
4.77189
4.58046
4.39908
4.22727
4.06427
3.90966
3.76281
3.62333
3.49074
3.36466
3.24477
3.13071
3.0222
2.91896
2.82071
2.7272
2.63817
2.5534
2.47263
2.3957
2.32235
2.2525
2.18587
2.12242
2.06191
2.00432
1.94938
1.89712
1.84732
1.79998
1.7549
1.71201
1.67115
1.63224
1.59517
1.55986
1.52623
1.49422
1.46376
1.4348
1.40728
1.38116
1.3564
1.33298
1.31084
1.28997
1.27036
1.25188
1.23473
1.21861
1.20384
1.19038
1.17806
1.16867
1.16026
1.16046
1.1626
1.16955
1.18607
1.22175
1.29185
1.40481
1.55839
1.74382
1.93673
2.01554
2.09511
1.00177
1.0047
1.00947
1.02537
1.05164
1.13829
1.29292
1.75185
2.64823
4.72574
7.58493
12.3336
13.1163
12.8485
12.1582
11.2429
10.5404
9.99028
9.52567
9.08617
8.6637
8.25683
7.86715
7.49662
7.14653
6.81696
6.50727
6.21624
5.94261
5.68494
5.44221
5.21318
4.99703
4.79269
4.59949
4.41653
4.24325
4.07893
3.92307
3.77511
3.63459
3.50111
3.3742
3.2536
3.13886
3.02977
2.92594
2.82717
2.73312
2.64358
2.55829
2.47699
2.39954
2.32565
2.25526
2.18808
2.1241
2.06303
2.00491
1.94943
1.8967
1.84642
1.79856
1.75295
1.70953
1.66816
1.62878
1.59127
1.55554
1.52152
1.4891
1.45825
1.42889
1.40099
1.37447
1.34933
1.3255
1.30297
1.28169
1.26168
1.24284
1.22523
1.20878
1.19348
1.17945
1.1664
1.15503
1.14478
1.13692
1.13314
1.13394
1.13759
1.14689
1.16816
1.21151
1.29858
1.39747
1.58925
1.74752
1.97912
1.00132
1.00266
1.00732
1.01446
1.0418
1.08009
1.2466
1.52243
2.5112
4.83211
10.7493
13.7802
13.5014
12.7606
11.8999
11.2191
10.6552
10.1533
9.66926
9.19585
8.74191
8.31436
7.91347
7.53731
7.18413
6.8523
6.54041
6.24697
5.9709
5.71089
5.46598
5.23496
5.01699
4.81101
4.61631
4.43198
4.25742
4.09194
3.93498
3.78602
3.64455
3.5102
3.38246
3.26111
3.14566
3.03593
2.93148
2.83215
2.73757
2.64755
2.56179
2.48009
2.40226
2.32802
2.2573
2.18979
2.1255
2.06412
2.00569
1.94992
1.89685
1.84623
1.79804
1.7521
1.70836
1.66669
1.62698
1.58919
1.55314
1.51885
1.48614
1.45502
1.42538
1.39719
1.3704
1.34496
1.32085
1.29804
1.27648
1.25618
1.23708
1.21919
1.20248
1.18692
1.17256
1.15928
1.14724
1.13639
1.12675
1.11937
1.11331
1.11368
1.11552
1.12144
1.13334
1.1617
1.21297
1.3178
1.44092
1.69988
1.00111
1.00224
1.00623
1.01242
1.03663
1.06843
1.22876
1.461
2.52398
4.97683
11.6002
13.0408
12.8231
12.3769
11.9084
11.4106
10.8746
10.3178
9.77562
9.26627
8.79294
8.3532
7.94425
7.56295
7.20615
6.87136
6.55682
6.26104
5.98289
5.72111
5.4747
5.24244
5.02344
4.81659
4.62113
4.43615
4.26102
4.09503
3.93762
3.78827
3.64645
3.51181
3.38381
3.26223
3.14657
3.03667
2.93206
2.83259
2.73786
2.64771
2.56181
2.47998
2.402
2.32762
2.25675
2.1891
2.12466
2.06313
2.00456
1.94864
1.89543
1.84467
1.79637
1.75033
1.70648
1.66473
1.62492
1.58704
1.55089
1.51653
1.48371
1.45253
1.4228
1.39454
1.36766
1.34214
1.31795
1.29504
1.2734
1.253
1.2338
1.21582
1.19901
1.18336
1.1689
1.1555
1.14337
1.13219
1.12245
1.11353
1.10688
1.10116
1.10152
1.10323
1.10841
1.11831
1.14266
1.18768
1.27849
1.46999
3.06392
1.55572
1.04738
0.94249
0.968239
1.047
1.21278
1.34496
1.38604
1.3844
1.37913
1.37929
1.38125
1.38658
1.39739
1.40524
1.40782
1.40764
1.40702
1.40564
1.40382
1.40227
1.40089
1.3992
1.3971
1.39489
1.39411
1.39456
1.39658
1.40281
1.41917
1.45922
1.55343
1.77076
2.27354
3.29711
3.69942
3.6779
3.70169
3.72278
3.79123
3.90593
4.05279
4.19821
4.32304
4.41638
4.50332
4.55898
4.59376
4.612
4.61775
4.61518
4.60537
4.58428
4.55616
4.52457
4.4909
4.45442
4.41535
4.37373
4.32966
4.28362
4.23575
4.18634
4.13581
4.08394
4.03159
3.97875
3.9256
3.87198
3.81857
3.76514
3.71177
3.65854
3.60548
3.55278
3.50036
3.44853
3.39716
3.3464
3.29627
3.24684
3.19802
3.1499
3.10236
3.05561
3.00944
2.96405
2.91927
2.87547
2.83225
2.7899
2.74816
2.70743
2.66752
2.62899
2.592
2.55784
2.52788
2.50681
3.71842
2.31611
1.71692
1.46598
1.34999
1.27844
1.26402
1.27193
1.29406
1.33967
1.38503
1.4038
1.40351
1.4022
1.4001
1.40043
1.40156
1.40405
1.4068
1.40678
1.40646
1.40549
1.40342
1.40019
1.39707
1.39438
1.39272
1.39309
1.39489
1.40035
1.4142
1.44761
1.52647
1.71045
2.13808
3.09216
3.71962
3.70309
3.69901
3.72592
3.79477
3.89525
4.02265
4.16675
4.29374
4.39639
4.47929
4.53668
4.57355
4.59333
4.60062
4.59927
4.59311
4.57741
4.54871
4.51611
4.48255
4.44657
4.40834
4.36712
4.32366
4.2779
4.2305
4.18142
4.13122
4.07982
4.02774
3.97511
3.92219
3.86894
3.81565
3.76235
3.70911
3.65599
3.60304
3.55043
3.49812
3.44635
3.39505
3.34438
3.29425
3.24484
3.19606
3.14796
3.10052
3.0539
3.00805
2.96286
2.91838
2.87441
2.83125
2.78877
2.7472
2.70635
2.66656
2.6278
2.59073
2.55603
2.52546
2.50373
4.54542
3.24223
2.42437
1.90809
1.57868
1.37482
1.25762
1.24501
1.2524
1.27385
1.31851
1.36075
1.3879
1.40075
1.40314
1.40283
1.402
1.40143
1.40151
1.4015
1.4014
1.40106
1.40023
1.3985
1.39579
1.39289
1.39003
1.38991
1.39068
1.39385
1.4026
1.42602
1.47871
1.60929
1.89812
2.56383
3.61137
3.77475
3.79951
3.84108
3.90286
3.98071
4.06961
4.16962
4.26638
4.36225
4.4429
4.50225
4.54164
4.56324
4.57161
4.57086
4.56714
4.55684
4.53482
4.50236
4.46861
4.43321
4.3956
4.35524
4.31254
4.26752
4.22071
4.17228
4.12261
4.07188
4.02034
3.96822
3.9157
3.8629
3.80992
3.75689
3.70389
3.65098
3.59827
3.54581
3.49377
3.44212
3.39108
3.34057
3.2907
3.24145
3.193
3.1452
3.09818
3.0516
3.00576
2.96053
2.9161
2.87223
2.82923
2.78682
2.74535
2.70451
2.66476
2.62587
2.5886
2.55334
2.52197
2.49845
4.99809
3.82353
2.95369
2.34794
1.94206
1.66924
1.49828
1.39167
1.32999
1.31426
1.31767
1.32906
1.35327
1.38141
1.40082
1.41087
1.4108
1.41009
1.40834
1.40524
1.40331
1.40216
1.40128
1.40028
1.39852
1.39597
1.39276
1.39011
1.39042
1.39191
1.398
1.41065
1.44915
1.52863
1.73339
2.18569
3.20629
3.79426
4.03499
4.12456
4.16767
4.19629
4.20546
4.21626
4.24326
4.2987
4.36831
4.43236
4.48391
4.51569
4.53036
4.53189
4.52985
4.52341
4.50881
4.48058
4.44754
4.41245
4.37553
4.3364
4.29501
4.25131
4.20563
4.15825
4.10951
4.05966
4.00897
3.95758
3.90573
3.85348
3.80104
3.74843
3.69586
3.64329
3.59097
3.53883
3.48716
3.43583
3.38508
3.33488
3.28549
3.2366
3.18841
3.14074
3.09385
3.04744
3.00182
2.95674
2.91252
2.86882
2.82602
2.7837
2.74237
2.70157
2.66187
2.6229
2.58545
2.54969
2.51737
2.49204
5.27096
4.2438
3.40834
2.77521
2.31291
1.97671
1.73297
1.55883
1.4372
1.36078
1.32043
1.32044
1.32386
1.33372
1.35409
1.37434
1.38908
1.39825
1.40087
1.40054
1.39948
1.39724
1.39456
1.39226
1.39029
1.38848
1.38709
1.38523
1.38537
1.38646
1.38896
1.39946
1.41798
1.47797
1.59389
1.88927
2.50741
3.68445
4.37384
4.59509
4.5903
4.54698
4.4379
4.30852
4.24881
4.25255
4.27379
4.32373
4.38798
4.43742
4.46832
4.48237
4.48216
4.47937
4.47108
4.45265
4.42188
4.38681
4.35011
4.31192
4.27193
4.22987
4.18583
4.13998
4.09258
4.04391
3.99427
3.9438
3.89276
3.84121
3.78941
3.73737
3.68534
3.63323
3.58143
3.52972
3.47853
3.42775
3.37767
3.32799
3.27901
3.23042
3.18253
3.13508
3.08844
3.04225
2.99691
2.95202
2.90806
2.86452
2.82195
2.7798
2.73866
2.69799
2.65841
2.61947
2.58193
2.54584
2.51296
2.48608
5.45694
4.56565
3.79002
3.16119
2.6702
2.29315
2.00588
1.78922
1.62705
1.5101
1.42543
1.37172
1.34284
1.34037
1.34279
1.35001
1.36509
1.38179
1.39464
1.40286
1.40425
1.40384
1.4026
1.3999
1.39592
1.39225
1.38918
1.38641
1.3852
1.38566
1.38738
1.39349
1.40699
1.44365
1.52383
1.7198
2.16311
3.18007
4.68701
5.20046
5.1451
4.9857
4.69408
4.45095
4.29464
4.22913
4.2212
4.22831
4.25394
4.30691
4.35728
4.39482
4.41427
4.41816
4.41576
4.4074
4.3885
4.35648
4.32014
4.28217
4.24291
4.2023
4.16021
4.11645
4.07102
4.02405
3.97588
3.92663
3.87663
3.82596
3.77496
3.72361
3.67225
3.6207
3.56953
3.51867
3.46828
3.41817
3.36863
3.31936
3.27075
3.22245
3.17491
3.12773
3.08142
3.03548
2.99047
2.94583
2.90216
2.85887
2.81656
2.77466
2.73374
2.69329
2.65384
2.61502
2.57746
2.54118
2.50797
2.47994
5.58462
4.8101
4.10287
3.49784
2.99978
2.59866
2.27955
2.02734
1.82855
1.67353
1.55326
1.46482
1.39991
1.36188
1.34196
1.34205
1.34413
1.34993
1.36187
1.3744
1.38372
1.39015
1.3907
1.39038
1.3894
1.38731
1.3842
1.38124
1.37965
1.38002
1.38162
1.38636
1.39808
1.42689
1.49253
1.64903
2.01107
2.86548
4.7289
5.84292
5.75854
5.506
5.07239
4.7067
4.4471
4.28691
4.20564
4.17945
4.17691
4.18554
4.21158
4.26225
4.30339
4.33324
4.34417
4.34279
4.33629
4.3204
4.2887
4.25206
4.21262
4.17229
4.13135
4.08934
4.04596
4.00105
3.95477
3.9071
3.8584
3.80878
3.75866
3.70808
3.65747
3.60692
3.55664
3.50649
3.45682
3.40725
3.35824
3.30939
3.26124
3.21332
3.16621
3.1194
3.07347
3.02787
2.9832
2.9389
2.89552
2.85257
2.81052
2.76893
2.72824
2.68806
2.64879
2.61016
2.57268
2.53633
2.50298
2.47417
5.6777
4.9957
4.35235
3.77991
3.28965
2.87959
2.54174
2.26558
2.04107
1.85971
1.71378
1.59808
1.50782
1.44057
1.39123
1.36296
1.3473
1.34738
1.34911
1.35398
1.36404
1.37527
1.38408
1.39068
1.39093
1.3904
1.38889
1.38577
1.38232
1.38248
1.3836
1.3892
1.39934
1.43144
1.49069
1.64489
1.955
2.6651
4.13881
5.90548
5.98421
5.84987
5.51929
5.11701
4.74797
4.48621
4.30457
4.19277
4.14259
4.1242
4.12493
4.13448
4.15986
4.2073
4.23852
4.25926
4.26016
4.25652
4.24479
4.21932
4.18251
4.14222
4.10102
4.05916
4.01677
3.97354
3.9293
3.88355
3.8366
3.7884
3.73937
3.68988
3.64043
3.59083
3.5415
3.49207
3.44308
3.39408
3.34567
3.29736
3.24974
3.20233
3.15571
3.10937
3.06387
3.01873
2.97443
2.93056
2.88754
2.84498
2.80325
2.76203
2.72162
2.68176
2.64273
2.60433
2.567
2.53067
2.49731
2.46801
5.74508
5.13907
4.55375
4.0171
3.54292
3.13408
2.78718
2.49591
2.2527
2.05079
1.88342
1.74564
1.633
1.54205
1.4706
1.41679
1.37791
1.35649
1.34565
1.34582
1.34734
1.35139
1.3596
1.36789
1.37381
1.37783
1.37974
1.3797
1.37974
1.3805
1.38276
1.39095
1.40781
1.45171
1.54134
1.74109
2.14147
2.94159
3.7029
4.69561
5.52062
5.67665
5.61654
5.43006
5.08887
4.80009
4.52433
4.32927
4.19608
4.11381
4.08125
4.06549
4.06733
4.07814
4.10372
4.14082
4.1625
4.17228
4.17052
4.16311
4.14562
4.11124
4.07218
4.02962
3.98672
3.94383
3.90078
3.85668
3.81165
3.76519
3.71811
3.67004
3.62183
3.57321
3.52473
3.47604
3.42773
3.37941
3.33163
3.28398
3.23696
3.19017
3.14408
3.09832
3.05329
3.00866
2.96481
2.9214
2.87878
2.83665
2.79529
2.75445
2.71438
2.67485
2.63612
2.59796
2.56087
2.52462
2.49135
2.46173
5.79763
5.25187
4.717
4.21581
3.76183
3.36071
3.012
2.71253
2.45694
2.24014
2.05659
1.90192
1.77194
1.66362
1.57429
1.50165
1.44515
1.40175
1.37075
1.35342
1.34462
1.3448
1.34617
1.34976
1.35708
1.36503
1.37167
1.37601
1.37849
1.38195
1.38946
1.40511
1.44051
1.51499
1.6745
1.99857
2.64811
3.19888
3.52426
3.91996
4.43959
5.01688
5.35033
5.32985
5.24017
5.04643
4.79004
4.5723
4.36221
4.21134
4.10998
4.04669
4.02092
4.00414
4.00604
4.01506
4.03524
4.06185
4.07672
4.07759
4.07424
4.06317
4.03919
4.00053
3.95828
3.91462
3.87098
3.82719
3.78336
3.73869
3.69349
3.64725
3.60055
3.55313
3.50563
3.4578
3.41025
3.36267
3.31558
3.26865
3.22231
3.17621
3.13076
3.08563
3.04119
2.99713
2.95381
2.91091
2.86879
2.82712
2.78623
2.7458
2.70616
2.66698
2.62864
2.59075
2.55397
2.51784
2.48476
2.4549
5.83728
5.34166
4.85081
4.38343
3.95187
3.56273
3.21752
2.91517
2.65226
2.42516
2.22945
2.0615
1.91748
1.79461
1.69012
1.60202
1.52882
1.46888
1.42186
1.38615
1.36122
1.34713
1.34064
1.34087
1.34221
1.34551
1.35219
1.36007
1.36868
1.37833
1.39408
1.42587
1.49296
1.63108
1.9156
2.48972
3.08022
3.33919
3.45782
3.59987
3.81337
4.11452
4.53554
4.86242
5.02052
5.00021
4.92305
4.75349
4.56602
4.40182
4.24001
4.1157
4.03317
3.97914
3.95414
3.9351
3.93678
3.94329
3.95719
3.97565
3.9829
3.98138
3.97503
3.95924
3.92743
3.88674
3.84234
3.79764
3.75386
3.71012
3.66628
3.62167
3.57658
3.53063
3.48442
3.43769
3.39111
3.34441
3.29814
3.25199
3.2064
3.16103
3.11629
3.07182
3.02803
2.98457
2.94185
2.8995
2.85792
2.81673
2.77634
2.73635
2.69717
2.65837
2.62044
2.58288
2.54644
2.51052
2.47767
2.44764
5.87021
5.41434
4.96143
4.52552
4.11685
3.74216
3.4039
3.10257
2.83615
2.60237
2.39775
2.2195
2.06426
1.9296
1.81292
1.71235
1.6262
1.55316
1.49224
1.44239
1.40334
1.37371
1.3533
1.34152
1.33797
1.3387
1.34136
1.34742
1.35979
1.37847
1.40855
1.46956
1.59289
1.84552
2.35423
3.00869
3.30921
3.40155
3.43274
3.47037
3.53332
3.64197
3.81533
4.05054
4.37118
4.61708
4.74581
4.73029
4.67262
4.54549
4.39062
4.25971
4.13405
4.02394
3.94983
3.90398
3.87671
3.85743
3.85861
3.86328
3.87305
3.88555
3.88531
3.8823
3.87292
3.85188
3.81319
3.77013
3.72581
3.68146
3.63766
3.59373
3.5498
3.5052
3.46041
3.41507
3.36977
3.32423
3.27901
3.2338
3.18907
3.14451
3.10052
3.05677
3.01367
2.97086
2.92876
2.88699
2.84599
2.80535
2.76549
2.726
2.68729
2.64895
2.61143
2.57426
2.53818
2.50251
2.46993
2.43975
5.89539
5.47315
5.05501
4.64881
4.26268
3.90345
3.57432
3.27656
3.00953
2.77171
2.56089
2.37462
2.21051
2.06608
1.93939
1.82833
1.73151
1.64732
1.57493
1.51311
1.46157
1.41936
1.38631
1.36207
1.34496
1.34079
1.34217
1.34685
1.35971
1.38446
1.43863
1.54482
1.76553
2.20651
2.88273
3.28017
3.40107
3.42071
3.41992
3.41523
3.40705
3.41552
3.44999
3.53054
3.68865
3.90459
4.18275
4.38964
4.5108
4.50003
4.46002
4.37499
4.2387
4.12875
4.02747
3.92955
3.86338
3.82239
3.79411
3.77407
3.77505
3.77862
3.78493
3.78927
3.7878
3.78197
3.76771
3.73832
3.69846
3.65435
3.61012
3.5659
3.5221
3.47813
3.4344
3.39038
3.3465
3.30236
3.25839
3.21432
3.17056
3.12691
3.08371
3.04074
2.99833
2.95622
2.91475
2.87363
2.83321
2.79315
2.75382
2.71486
2.67664
2.63879
2.60171
2.56496
2.52927
2.4939
2.46163
2.43135
5.92498
5.531
5.14072
4.75906
4.39348
4.04917
3.7298
3.43706
3.17123
2.93152
2.71654
2.52442
2.35327
2.20109
2.06605
1.94636
1.84063
1.74726
1.66548
1.59393
1.53221
1.47953
1.43546
1.40021
1.373
1.35818
1.35947
1.36503
1.3841
1.42087
1.5102
1.68542
2.04954
2.71478
3.20989
3.3918
3.42409
3.4218
3.40971
3.37989
3.32374
3.27792
3.27732
3.28812
3.32476
3.4062
3.56011
3.75207
3.98273
4.16397
4.29102
4.29027
4.27021
4.21658
4.108
4.00586
3.91665
3.83788
3.77577
3.73462
3.70712
3.68859
3.68794
3.68926
3.69238
3.69188
3.68872
3.67957
3.6596
3.62268
3.58125
3.53759
3.49361
3.44964
3.40638
3.36337
3.32075
3.27809
3.23554
3.19288
3.15035
3.10784
3.0656
3.02353
2.98189
2.94053
2.89973
2.85927
2.81945
2.78001
2.74124
2.70284
2.66515
2.62779
2.5912
2.55487
2.51964
2.48455
2.45267
2.42231
5.96348
5.5895
5.22183
4.86089
4.51285
4.18239
3.87236
3.58526
3.32167
3.08162
2.864
2.66788
2.49127
2.33304
2.19121
2.06439
1.95129
1.85022
1.76067
1.68099
1.61095
1.54965
1.4964
1.45247
1.41569
1.39557
1.39756
1.40786
1.4341
1.50356
1.64251
1.94255
2.53763
3.10067
3.36252
3.42302
3.42192
3.4113
3.38202
3.32213
3.25915
3.20644
3.16878
3.14636
3.14966
3.16384
3.20042
3.27592
3.40763
3.57355
3.76883
3.94305
4.07003
4.10694
4.09579
4.06165
3.98647
3.8904
3.81209
3.74354
3.68444
3.64446
3.61732
3.60009
3.59658
3.59697
3.59683
3.5951
3.58903
3.57418
3.54394
3.50515
3.46339
3.42037
3.37762
3.33526
3.29352
3.25201
3.21077
3.16951
3.12835
3.08712
3.04606
3.00503
2.96433
2.9238
2.88376
2.84398
2.80482
2.76597
2.72781
2.68995
2.65282
2.61595
2.57989
2.54399
2.50925
2.47447
2.44302
2.41264
6.02193
5.65397
5.301
4.95758
4.62378
4.30418
4.00284
3.72149
3.46095
3.22188
3.00298
2.80436
2.62392
2.46095
2.3139
2.18113
2.06202
1.95443
1.85836
1.77184
1.69482
1.62652
1.56561
1.51584
1.47078
1.45637
1.4605
1.48053
1.52421
1.64907
1.88653
2.40035
3.0068
3.33271
3.42764
3.42661
3.41563
3.38539
3.32338
3.25764
3.20117
3.1519
3.10825
3.07015
3.04211
3.02231
3.02506
3.03685
3.06629
3.12718
3.23772
3.3832
3.55261
3.72448
3.85129
3.93571
3.93038
3.91092
3.87168
3.79438
3.71333
3.64552
3.5924
3.55237
3.5234
3.50883
3.50673
3.50638
3.50476
3.4997
3.48767
3.46257
3.42875
3.39011
3.34936
3.30782
3.26647
3.22539
3.18483
3.14451
3.10453
3.06457
3.02481
2.98498
2.94542
2.90585
2.86671
2.82769
2.78926
2.75102
2.71349
2.67617
2.63962
2.60324
2.56772
2.53227
2.49803
2.46361
2.4326
2.40224
6.10633
5.72373
5.37719
5.04502
4.72375
4.41543
4.12205
3.84687
3.58973
3.35265
3.13381
2.93372
2.75101
2.58435
2.43343
2.29579
2.17175
2.05876
1.95707
1.86487
1.7819
1.70779
1.64136
1.58701
1.54123
1.54199
1.55319
1.58434
1.68491
1.87889
2.31432
2.96048
3.33272
3.45613
3.45496
3.44238
3.4054
3.33077
3.25836
3.19801
3.14767
3.10135
3.05777
3.01629
2.97732
2.94249
2.91573
2.89404
2.89578
2.90375
2.92517
2.97134
3.06335
3.18887
3.34158
3.50504
3.64727
3.74944
3.78683
3.77876
3.75229
3.6941
3.61912
3.55088
3.49556
3.45333
3.42784
3.41716
3.41356
3.41156
3.40722
3.39771
3.37875
3.35044
3.3164
3.27873
3.23936
3.19917
3.15911
3.11923
3.07991
3.04079
3.0021
2.96339
2.92501
2.88652
2.84843
2.8103
2.7727
2.73517
2.69831
2.66157
2.62559
2.58974
2.55474
2.51977
2.48603
2.45198
2.42144
2.39111
6.19149
5.79935
5.45036
5.12565
4.81424
4.51614
4.23137
3.96255
3.70976
3.47485
3.25742
3.05663
2.87268
2.70353
2.54937
2.40821
2.27969
2.16251
2.05579
1.95893
1.87102
1.79195
1.72343
1.66429
1.64081
1.64676
1.67473
1.74439
1.9234
2.28261
2.9586
3.38068
3.52311
3.52097
3.50391
3.45459
3.36807
3.2897
3.21995
3.15869
3.10382
3.05473
3.01055
2.96747
2.92583
2.886
2.84819
2.81464
2.78708
2.76535
2.76211
2.76692
2.78284
2.81825
2.8914
2.99917
3.1362
3.29129
3.44771
3.5655
3.64837
3.6459
3.63151
3.60047
3.53676
3.46499
3.40704
3.36486
3.33868
3.32475
3.31767
3.31281
3.30551
3.29084
3.26887
3.24031
3.20718
3.17079
3.13285
3.09404
3.05533
3.01669
2.97863
2.94067
2.90324
2.86573
2.82869
2.79152
2.75487
2.71816
2.68207
2.646
2.61065
2.57537
2.54092
2.50644
2.47323
2.43958
2.40953
2.37928
6.31796
5.89299
5.52644
5.20176
4.89771
4.60823
4.33171
4.07009
3.82262
3.59045
3.37465
3.17433
2.9894
2.81893
2.66201
2.51815
2.38592
2.26508
2.15427
2.05338
1.96148
1.87998
1.80966
1.76214
1.76487
1.78424
1.84504
1.99774
2.32137
2.97822
3.46868
3.63759
3.63443
3.61182
3.54924
3.4473
3.35353
3.27368
3.20361
3.14072
3.08206
3.02668
2.9745
2.92625
2.88179
2.83879
2.79734
2.75782
2.72059
2.68762
2.65888
2.63779
2.62783
2.63086
2.64216
2.66889
2.72571
2.81756
2.93889
3.08891
3.24776
3.38998
3.495
3.5355
3.52618
3.49862
3.44128
3.37447
3.32289
3.2811
3.2521
3.23489
3.22411
3.21452
3.20246
3.18497
3.162
3.13364
3.1015
3.06638
3.02987
2.9924
2.95502
2.91758
2.88073
2.84391
2.80768
2.77139
2.73566
2.69984
2.6646
2.62932
2.5947
2.56007
2.52624
2.49231
2.45966
2.42644
2.3969
2.36677
6.34676
5.98755
5.60779
5.27785
4.97685
4.69439
4.42534
4.16981
3.92858
3.70055
3.48666
3.2873
3.10197
2.93047
2.7717
2.62534
2.49038
2.36622
2.25216
2.14813
2.05339
1.97325
1.9044
1.89945
1.91325
1.95937
2.1077
2.39643
3.03019
3.59824
3.80246
3.79865
3.7712
3.69627
3.56418
3.44684
3.35112
3.27038
3.19943
3.13536
3.0737
3.01417
2.95652
2.90116
2.84938
2.80143
2.75596
2.71264
2.67133
2.63207
2.59547
2.5626
2.53342
2.51248
2.4967
2.49872
2.50683
2.52657
2.56715
2.64496
2.75423
2.8968
3.05642
3.22054
3.34581
3.42333
3.41586
3.39328
3.35019
3.29043
3.24086
3.19857
3.16774
3.1471
3.13202
3.11804
3.10238
3.08276
3.05907
3.03079
2.99954
2.96546
2.93022
2.89398
2.85788
2.8216
2.78595
2.75029
2.71529
2.68026
2.64587
2.61141
2.5776
2.54372
2.5106
2.4773
2.44528
2.41255
2.38357
2.35361
6.31297
6.1011
5.70748
5.36036
5.05773
4.77991
4.51589
4.26552
4.02873
3.80531
3.5943
3.3961
3.21101
3.03872
2.87864
2.73029
2.59301
2.46624
2.3497
2.24337
2.1502
2.07109
2.04342
2.05407
2.09722
2.22682
2.50722
3.11041
3.7681
4.01477
4.01037
3.97778
3.88849
3.73127
3.5901
3.47285
3.3741
3.28781
3.21016
3.13848
3.07208
3.01038
2.94905
2.88949
2.83159
2.77632
2.72496
2.67744
2.63218
2.58915
2.54839
2.50973
2.47394
2.44106
2.41232
2.3901
2.37181
2.37161
2.37575
2.38997
2.42096
2.48568
2.58449
2.7176
2.87823
3.05525
3.20407
3.30863
3.30483
3.28978
3.26038
3.20255
3.15527
3.11419
3.08318
3.05998
3.04127
3.02366
3.00532
2.98379
2.95962
2.93119
2.90078
2.8676
2.83351
2.79849
2.76365
2.72863
2.69422
2.65983
2.62612
2.59244
2.55939
2.52632
2.49396
2.46141
2.43008
2.39795
2.36958
2.33988
6.22059
6.09897
5.82398
5.45853
5.14245
4.8628
4.60449
4.35926
4.12562
3.90487
3.69701
3.50079
3.31624
3.14382
2.98276
2.83306
2.69397
2.56542
2.44725
2.34225
2.25177
2.20418
2.2116
2.25025
2.3613
2.63368
3.20527
3.96379
4.26498
4.26077
4.22406
4.12026
3.93853
3.77463
3.63783
3.52092
3.41774
3.32423
3.23826
3.15823
3.08345
3.01299
2.94715
2.88553
2.82356
2.76396
2.70674
2.65279
2.6026
2.55568
2.51128
2.46913
2.42915
2.39141
2.35643
2.32398
2.29592
2.27221
2.2544
2.24842
2.2514
2.26219
2.28676
2.33919
2.42785
2.55072
2.71262
2.90015
3.07388
3.19182
3.20128
3.19085
3.16481
3.11281
3.06831
3.03013
2.99877
2.973
2.9513
2.93071
2.9104
2.88737
2.86283
2.83451
2.8047
2.77256
2.73968
2.70598
2.67248
2.63882
2.60573
2.57271
2.54031
2.50799
2.47637
2.44457
2.41401
2.38254
2.35486
2.32555
6.11639
6.06172
5.89569
5.56038
5.23387
4.94869
4.69076
4.44927
4.22006
4.00184
3.79566
3.60149
3.41827
3.24589
3.08447
2.9336
2.79355
2.66389
2.54729
2.44613
2.37946
2.38413
2.41719
2.5186
2.78044
3.33108
4.19263
4.55062
4.54663
4.50559
4.38567
4.17917
3.99274
3.8363
3.70205
3.58242
3.47335
3.37223
3.27796
3.18952
3.10649
3.02831
2.95493
2.88543
2.82108
2.75907
2.69829
2.63978
2.58394
2.53182
2.48342
2.43754
2.39414
2.3531
2.31423
2.27768
2.24357
2.21199
2.18445
2.16005
2.14279
2.13236
2.13441
2.1427
2.16227
2.20561
2.2839
2.39864
2.56227
2.75983
2.95331
3.07619
3.1017
3.0931
3.06946
3.02336
2.98235
2.94588
2.91367
2.88562
2.86173
2.83907
2.81737
2.79347
2.76861
2.7408
2.71156
2.6806
2.64901
2.61676
2.58464
2.55242
2.52069
2.48903
2.45808
2.42698
2.39716
2.36639
2.33942
2.31061
5.9156
5.95652
5.88158
5.68752
5.34697
5.04451
4.77997
4.53845
4.31212
4.09687
3.89207
3.69895
3.51718
3.34561
3.18405
3.03286
2.89255
2.76402
2.65397
2.56765
2.56962
2.59661
2.69078
2.93163
3.44928
4.42461
4.85862
4.85544
4.81137
4.67995
4.44754
4.23769
4.06197
3.91065
3.77546
3.65128
3.53582
3.42737
3.32546
3.22928
3.13871
3.05326
2.97276
2.89685
2.82545
2.7582
2.69552
2.63411
2.57495
2.5182
2.46442
2.41427
2.36746
2.32322
2.28132
2.24167
2.20411
2.16885
2.13576
2.1053
2.0782
2.05392
2.03685
2.02337
2.02485
2.03128
2.04753
2.08331
2.15254
2.26315
2.42732
2.63164
2.84554
2.96646
3.0036
2.99593
2.9749
2.93397
2.89645
2.86068
2.82767
2.79832
2.77315
2.74929
2.72659
2.70248
2.6773
2.65017
2.62178
2.59209
2.56184
2.53105
2.50036
2.46955
2.43932
2.40891
2.37977
2.3497
2.3234
2.29517
5.42851
5.83991
5.82016
5.71281
5.47257
5.1542
4.87548
4.62921
4.40287
4.19019
3.98862
3.79641
3.61414
3.44282
3.2818
3.13119
2.99218
2.87206
2.77152
2.76588
2.78984
2.87981
3.11875
3.63401
4.66642
5.17686
5.1879
5.14314
4.99905
4.74002
4.50643
4.31099
4.14285
3.99212
3.85343
3.72371
3.60176
3.48642
3.37757
3.27448
3.17721
3.08518
2.99835
2.91633
2.83891
2.76597
2.69708
2.63259
2.5717
2.51195
2.4547
2.40009
2.349
2.30125
2.25614
2.21348
2.17311
2.13493
2.09884
2.06496
2.03308
2.00383
1.9773
1.95371
1.9365
1.92149
1.9224
1.92751
1.94081
1.97189
2.03474
2.14441
2.30562
2.51332
2.74434
2.86015
2.90462
2.89837
2.88079
2.84622
2.81039
2.77504
2.74197
2.71231
2.68637
2.66208
2.63855
2.61442
2.5894
2.56304
2.53566
2.50727
2.4784
2.44903
2.41989
2.39038
2.36202
2.33265
2.30703
2.27939
4.37171
5.56495
5.7353
5.6891
5.55305
5.27183
4.97912
4.72442
4.49563
4.28302
4.08218
3.89157
3.71071
3.53954
3.37909
3.23012
3.09947
2.98985
2.97039
2.99345
3.08333
3.32573
3.86069
4.9448
5.53072
5.55629
5.50608
5.34408
5.05643
4.7975
4.58161
4.39608
4.22988
4.0765
3.93288
3.79725
3.66898
3.5473
3.43219
3.32298
3.21978
3.12195
3.02949
2.94195
2.85919
2.78096
2.70702
2.63736
2.57143
2.50994
2.45059
2.39333
2.3385
2.28653
2.23809
2.19241
2.14924
2.1084
2.06977
2.03322
1.99869
1.96622
1.93564
1.90759
1.88181
1.8591
1.84171
1.82666
1.82656
1.83006
1.84248
1.87031
1.92939
2.04049
2.20365
2.40783
2.64801
2.75888
2.80747
2.80279
2.78848
2.75934
2.72481
2.69037
2.65774
2.62826
2.60204
2.57753
2.5538
2.52985
2.50532
2.47981
2.45357
2.42641
2.39907
2.37097
2.34376
2.31531
2.29046
2.26351
2.75735
4.93572
5.57611
5.61587
5.55085
5.39072
5.10062
4.83071
4.59232
4.37667
4.17543
3.98546
3.80539
3.6356
3.47711
3.33674
3.21866
3.18704
3.20927
3.30026
3.54875
4.10997
5.25146
5.91739
5.95905
5.90207
5.71778
5.39804
5.11145
4.87342
4.66976
4.48744
4.3192
4.16126
4.01199
3.87039
3.73612
3.60861
3.48785
3.3732
3.26472
3.16173
3.06429
2.97183
2.88431
2.80137
2.72288
2.64862
2.57842
2.51213
2.44964
2.39098
2.33364
2.27881
2.22661
2.17773
2.13173
2.08823
2.04707
2.0081
1.97123
1.93635
1.90339
1.87243
1.84321
1.81643
1.79163
1.7698
1.75269
1.7379
1.73709
1.74038
1.75197
1.77907
1.83713
1.9493
2.11231
2.3233
2.55875
2.66364
2.71432
2.71096
2.69884
2.67399
2.64079
2.60742
2.57564
2.54667
2.52062
2.49623
2.47272
2.44919
2.42541
2.4008
2.37586
2.34983
2.32435
2.29733
2.27355
2.24759
2.10202
3.51975
5.14105
5.50901
5.50176
5.42278
5.23809
4.95308
4.6988
4.47429
4.26974
4.07798
3.89928
3.73189
3.58214
3.45584
3.41487
3.43669
3.52925
3.78509
4.36567
5.55387
6.32183
6.38215
6.31893
6.11489
5.76274
5.44753
5.18648
4.96359
4.76449
4.58061
4.40796
4.24446
4.08934
3.94192
3.80205
3.6692
3.54333
3.4238
3.31062
3.20307
3.1012
3.00439
2.91265
2.82552
2.74293
2.66461
2.59043
2.52018
2.45383
2.39093
2.33205
2.27546
2.22093
2.16886
2.11993
2.0738
2.03013
1.98878
1.94964
1.91257
1.87751
1.84435
1.813
1.78358
1.75578
1.73029
1.70667
1.68571
1.66932
1.65497
1.65422
1.65753
1.66883
1.69658
1.75461
1.86808
2.02674
2.24831
2.47733
2.57395
2.62503
2.62273
2.61255
2.5907
2.5591
2.52702
2.49641
2.46825
2.44278
2.41881
2.39585
2.37289
2.3501
2.32635
2.30304
2.27801
2.25573
2.23137
1.62574
2.32885
4.18695
5.2387
5.42209
5.39542
5.2959
5.0804
4.81112
4.57364
4.36303
4.172
3.99451
3.83593
3.70135
3.65261
3.67468
3.77103
4.03946
4.65316
5.91888
6.76042
6.82998
6.75909
6.53323
6.14752
5.80342
5.51888
5.27644
5.05986
4.85993
4.67189
4.4938
4.32453
4.16372
4.01088
3.86589
3.72821
3.59774
3.47382
3.35639
3.24475
3.13891
3.03819
2.94266
2.85179
2.76556
2.68364
2.60593
2.53223
2.46238
2.39625
2.33366
2.27464
2.21866
2.16458
2.11288
2.06412
2.01805
1.9744
1.93305
1.89388
1.8568
1.82171
1.78849
1.75712
1.72743
1.69961
1.6733
1.64911
1.62682
1.6067
1.59142
1.57756
1.57769
1.58129
1.59247
1.6221
1.68241
1.79954
1.95458
2.1783
2.40128
2.48996
2.53975
2.53854
2.53022
2.5107
2.48079
2.45017
2.4209
2.39375
2.36913
2.34576
2.32363
2.30131
2.27989
2.25693
2.23652
2.21436
1.27937
1.73791
2.62695
4.6072
5.25103
5.33194
5.28742
5.16998
4.92991
4.68127
4.46295
4.26932
4.09935
3.95762
3.90041
3.92309
4.02467
4.30916
4.96298
6.31525
7.24709
7.31379
7.23048
6.97531
6.55365
6.17913
5.87048
5.60785
5.37339
5.15662
4.95268
4.75918
4.57531
4.40039
4.23427
4.07645
3.9268
3.78475
3.6501
3.52222
3.40096
3.28564
3.17621
3.07202
2.97309
2.87888
2.78941
2.70429
2.62347
2.5467
2.47383
2.40472
2.33917
2.27714
2.21832
2.16302
2.10947
2.05831
2.01003
1.96425
1.92085
1.8797
1.84071
1.80376
1.76878
1.73566
1.70432
1.67474
1.64674
1.6205
1.59574
1.57281
1.55202
1.5327
1.5188
1.50582
1.50654
1.51162
1.52223
1.55615
1.61638
1.73856
1.90274
2.12166
2.33053
2.41315
2.46002
2.45953
2.45223
2.43449
2.40641
2.37746
2.34981
2.32381
2.30025
2.27758
2.25668
2.23508
2.21621
2.19628
1.17403
1.36797
1.96806
3.1972
4.79344
5.20832
5.23419
5.17937
5.04649
4.80254
4.57526
4.38192
4.22299
4.1583
4.18215
4.29087
4.59771
5.30531
6.77197
7.78195
7.83099
7.73057
7.44122
6.9826
6.5771
6.24342
5.95971
5.7061
5.47145
5.25029
5.04055
4.84102
4.65145
4.47123
4.30026
4.13795
3.9841
3.83809
3.69967
3.56819
3.44344
3.32478
3.21208
3.10476
3.00278
2.90561
2.81327
2.72534
2.6418
2.56233
2.48685
2.41514
2.34705
2.28243
2.22116
2.16298
2.10825
2.05548
2.00504
1.9574
1.91215
1.8692
1.82843
1.78977
1.75313
1.7184
1.68554
1.65442
1.62498
1.5972
1.5709
1.54621
1.52304
1.50133
1.48206
1.46375
1.45096
1.44008
1.44112
1.44617
1.46082
1.49315
1.56039
1.68353
1.85395
2.07327
2.26524
2.34155
2.38518
2.38583
2.37956
2.36288
2.33679
2.30967
2.28374
2.25896
2.23681
2.21512
2.1964
2.17802
1.08128
1.22119
1.48537
2.21406
3.74755
4.87798
5.14116
5.13609
5.0764
4.9347
4.70758
4.51319
4.4274
4.45206
4.56962
4.90246
5.67384
7.271
8.34133
8.3688
8.24902
7.92537
7.43278
6.99661
6.63821
6.33324
6.05994
5.80612
5.5665
5.33884
5.12253
4.91691
4.72187
4.53672
4.36131
4.1949
4.03724
3.88762
3.74577
3.61099
3.48309
3.36141
3.24579
3.13565
3.03094
2.93114
2.83627
2.74586
2.65994
2.57813
2.50039
2.42643
2.35614
2.28933
2.22586
2.16562
2.10836
2.05443
2.00248
1.95306
1.90617
1.86161
1.81928
1.77908
1.74095
1.70476
1.67048
1.63797
1.6072
1.57807
1.55048
1.52445
1.49985
1.47663
1.4551
1.4346
1.41685
1.39989
1.38793
1.3799
1.38115
1.38766
1.4026
1.43986
1.51209
1.64421
1.81758
2.03131
2.20564
2.27714
2.3166
2.3179
2.31211
2.29682
2.2727
2.2475
2.22357
2.20028
2.18063
2.16192
1.04144
1.11583
1.23588
1.64001
2.38321
4.14029
4.91749
5.07121
5.05697
4.99524
4.85514
4.72189
4.74374
4.86793
5.22851
6.07995
7.83482
8.96492
8.95101
8.79365
8.41158
7.89511
7.43541
7.05462
6.72875
6.43517
6.16131
5.90178
5.65493
5.42016
5.1974
4.98614
4.78612
4.59657
4.41715
4.24703
4.0859
3.93295
3.78796
3.65021
3.51942
3.39498
3.27672
3.16406
3.05691
2.9548
2.85768
2.76513
2.67713
2.5933
2.5136
2.43771
2.36554
2.29688
2.23158
2.16949
2.1105
2.05441
2.00144
1.95052
1.90219
1.85623
1.81254
1.77101
1.73156
1.6941
1.65854
1.6248
1.59281
1.56248
1.53374
1.50654
1.48079
1.45643
1.43354
1.4118
1.39186
1.37281
1.35628
1.34136
1.32969
1.32532
1.32699
1.33457
1.35185
1.39285
1.47022
1.60807
1.78838
1.99755
2.15226
2.21902
2.25458
2.25654
2.2512
2.23711
2.21505
2.19202
2.17151
2.15124
1.02509
1.04977
1.13848
1.28674
1.73873
2.6045
4.3636
4.91689
5.02659
5.02276
5.00912
5.03378
5.1754
5.58066
6.53904
8.48373
9.59865
9.56755
9.36604
8.91324
8.37034
7.89149
7.49047
7.1443
6.83007
6.53524
6.25488
5.98763
5.73348
5.4923
5.264
5.0479
4.8436
4.65017
4.46718
4.29373
4.12946
3.97356
3.82573
3.68525
3.55185
3.42491
3.30425
3.18933
3.08006
2.97594
2.87692
2.78255
2.69281
2.60729
2.52593
2.4484
2.37467
2.30444
2.23764
2.17403
2.11354
2.05598
2.00132
1.94934
1.8998
1.85263
1.80777
1.76508
1.72449
1.68591
1.64924
1.61441
1.58134
1.54994
1.52016
1.49192
1.46517
1.43981
1.41589
1.39321
1.37201
1.35189
1.33338
1.31617
1.30052
1.28813
1.27708
1.27614
1.27832
1.28816
1.30709
1.35415
1.44012
1.58316
1.76685
1.96946
2.10626
2.16871
2.20024
2.20257
2.19769
2.18493
2.16618
2.14691
1.01148
1.03104
1.06364
1.17128
1.37185
1.93333
3.11002
4.49065
4.92739
5.05579
5.16484
5.41678
5.95457
7.10027
9.31232
10.3352
10.2699
10.0019
9.4401
8.86536
8.37281
7.95701
7.59057
7.25302
6.9339
6.62955
6.3395
6.06392
5.80297
5.55622
5.32324
5.10306
4.89507
4.69822
4.51203
4.33554
4.16837
4.00974
3.85929
3.71635
3.58054
3.45135
3.3285
3.21157
3.10035
2.99442
2.89365
2.79767
2.70638
2.6194
2.53669
2.45789
2.38288
2.3114
2.24334
2.1785
2.11678
2.05802
2.00207
1.94899
1.89835
1.85015
1.80427
1.76063
1.7191
1.6796
1.64202
1.60629
1.57231
1.54002
1.50933
1.48018
1.45253
1.42629
1.40149
1.37798
1.35588
1.33495
1.31537
1.29707
1.27988
1.26468
1.25018
1.23987
1.23115
1.23195
1.23539
1.24843
1.27054
1.32484
1.41818
1.56366
1.75263
1.94849
2.06805
2.12678
2.15412
2.15804
2.1542
2.14484
1.00705
1.01422
1.03836
1.07948
1.2116
1.45962
2.12405
3.48914
4.62684
5.04176
5.43204
6.21083
7.73717
10.2543
11.1473
11.0407
10.696
10.0009
9.37139
8.8631
8.43713
8.05521
7.69564
7.35101
7.02073
6.70582
6.40718
6.12496
5.85882
5.60783
5.37118
5.14769
4.93665
4.73698
4.54809
4.3691
4.19954
4.03864
3.88601
3.741
3.60334
3.47245
3.34802
3.22956
3.11684
3.00954
2.90744
2.81024
2.71776
2.62967
2.54584
2.46595
2.3899
2.3174
2.24836
2.18253
2.11985
2.06011
2.00324
1.94912
1.89758
1.84849
1.8018
1.75734
1.71504
1.67477
1.63643
1.59994
1.5652
1.53215
1.50071
1.47083
1.44245
1.41553
1.39002
1.36582
1.34298
1.32138
1.30106
1.28202
1.26405
1.24762
1.23202
1.21846
1.20618
1.19665
1.19252
1.19367
1.19964
1.21135
1.24341
1.30258
1.40758
1.55457
1.74628
1.93662
2.03774
2.09626
2.11801
2.13312
1.0032
1.00859
1.01725
1.04663
1.09615
1.25576
1.55424
2.32896
3.90283
4.97357
6.0358
8.15695
11.3369
12.1259
11.9598
11.4761
10.6048
9.91347
9.38042
8.94304
8.54575
8.16434
7.79371
7.43609
7.09469
6.7713
6.46638
6.17932
5.90919
5.65467
5.41475
5.18822
4.97428
4.77189
4.58046
4.39908
4.22727
4.06427
3.90966
3.76281
3.62333
3.49074
3.36466
3.24477
3.1307
3.0222
2.91895
2.82071
2.7272
2.63816
2.5534
2.47262
2.3957
2.32235
2.2525
2.18587
2.12242
2.06191
2.00431
1.94938
1.89712
1.84732
1.79998
1.7549
1.71201
1.67115
1.63224
1.59517
1.55986
1.52623
1.49422
1.46376
1.43479
1.40728
1.38116
1.3564
1.33298
1.31084
1.28997
1.27036
1.25188
1.23473
1.21861
1.20384
1.19038
1.17806
1.16866
1.16026
1.16046
1.1626
1.16955
1.18606
1.22174
1.29184
1.40479
1.55837
1.7438
1.93671
2.01552
2.0951
1.00177
1.0047
1.00947
1.02537
1.05164
1.13829
1.29292
1.75184
2.64821
4.72568
7.58471
12.3334
13.1163
12.8485
12.1583
11.243
10.5404
9.99029
9.52568
9.08618
8.6637
8.25683
7.86715
7.49662
7.14653
6.81696
6.50727
6.21624
5.94261
5.68494
5.44221
5.21318
4.99703
4.79269
4.59949
4.41653
4.24325
4.07893
3.92307
3.77511
3.63459
3.50111
3.3742
3.2536
3.13886
3.02977
2.92594
2.82717
2.73312
2.64358
2.55829
2.47699
2.39953
2.32565
2.25526
2.18808
2.1241
2.06303
2.00491
1.94943
1.8967
1.84642
1.79856
1.75295
1.70953
1.66816
1.62878
1.59127
1.55554
1.52152
1.4891
1.45825
1.42889
1.40099
1.37447
1.34932
1.3255
1.30297
1.28169
1.26168
1.24284
1.22523
1.20878
1.19347
1.17944
1.1664
1.15503
1.14478
1.13692
1.13314
1.13394
1.13758
1.14689
1.16815
1.21151
1.29857
1.39745
1.58923
1.74749
1.9791
1.00132
1.00266
1.00731
1.01446
1.04179
1.08009
1.24659
1.52243
2.51113
4.83199
10.749
13.7803
13.5015
12.7607
11.8999
11.2192
10.6552
10.1533
9.66926
9.19585
8.74191
8.31437
7.91348
7.53731
7.18413
6.8523
6.54041
6.24697
5.9709
5.71089
5.46598
5.23496
5.01699
4.81101
4.61631
4.43198
4.25743
4.09194
3.93498
3.78602
3.64454
3.5102
3.38246
3.26111
3.14566
3.03593
2.93148
2.83215
2.73757
2.64754
2.56179
2.48009
2.40226
2.32802
2.2573
2.18979
2.1255
2.06412
2.00569
1.94992
1.89685
1.84623
1.79804
1.7521
1.70836
1.66669
1.62698
1.58919
1.55314
1.51885
1.48614
1.45502
1.42538
1.39719
1.3704
1.34496
1.32085
1.29804
1.27648
1.25618
1.23708
1.21919
1.20248
1.18692
1.17256
1.15928
1.14724
1.13639
1.12674
1.11937
1.1133
1.11368
1.11552
1.12143
1.13334
1.16169
1.21296
1.31778
1.4409
1.69985
1.00111
1.00224
1.00623
1.01242
1.03663
1.06843
1.22875
1.46098
2.52394
4.9767
11.6
13.0408
12.8232
12.3769
11.9084
11.4106
10.8746
10.3178
9.77562
9.26627
8.79294
8.3532
7.94425
7.56295
7.20615
6.87136
6.55682
6.26104
5.98289
5.72111
5.4747
5.24245
5.02344
4.81659
4.62113
4.43615
4.26102
4.09503
3.93762
3.78827
3.64645
3.51181
3.3838
3.26223
3.14657
3.03667
2.93205
2.83259
2.73786
2.6477
2.56181
2.47998
2.402
2.32762
2.25675
2.1891
2.12466
2.06313
2.00456
1.94864
1.89543
1.84467
1.79637
1.75033
1.70648
1.66473
1.62492
1.58704
1.55089
1.51653
1.48371
1.45253
1.42279
1.39454
1.36766
1.34214
1.31795
1.29504
1.2734
1.253
1.2338
1.21582
1.19901
1.18336
1.1689
1.1555
1.14337
1.13218
1.12245
1.11353
1.10688
1.10116
1.10152
1.10323
1.10841
1.11831
1.14265
1.18767
1.27847
1.46997
3.06389
1.5557
1.04736
0.942483
0.968233
1.04699
1.21278
1.34496
1.38604
1.3844
1.37913
1.37929
1.38126
1.38658
1.39739
1.40525
1.40782
1.40764
1.40702
1.40565
1.40382
1.40228
1.40089
1.39921
1.3971
1.39489
1.39411
1.39455
1.39657
1.40278
1.41911
1.45907
1.5531
1.77004
2.27194
3.29469
3.69991
3.67818
3.70195
3.72294
3.79131
3.906
4.05283
4.19826
4.32307
4.41637
4.50337
4.55904
4.59387
4.61215
4.61793
4.61536
4.60553
4.58441
4.55627
4.52466
4.49098
4.45449
4.41542
4.37379
4.32973
4.28369
4.23582
4.18642
4.13588
4.08401
4.03166
3.97882
3.92567
3.87204
3.81863
3.76519
3.71182
3.65858
3.60553
3.55282
3.50041
3.44858
3.39722
3.34647
3.29634
3.24692
3.1981
3.14999
3.10244
3.05568
3.00951
2.96411
2.91932
2.87551
2.83228
2.78992
2.74817
2.70744
2.66752
2.62899
2.592
2.55784
2.52788
2.50682
3.71839
2.31608
1.71691
1.46597
1.34998
1.27844
1.26402
1.27193
1.29406
1.33968
1.38503
1.40381
1.40352
1.40221
1.4001
1.40044
1.40157
1.40405
1.40681
1.40679
1.40646
1.4055
1.40342
1.40019
1.39707
1.39438
1.39271
1.39309
1.39488
1.40033
1.41415
1.44747
1.52618
1.70981
2.13666
3.08955
3.71976
3.70333
3.69925
3.7261
3.79486
3.89537
4.02271
4.16681
4.29381
4.39645
4.47934
4.53674
4.57362
4.59342
4.60073
4.59939
4.59324
4.57753
4.54881
4.51619
4.48263
4.44664
4.40841
4.3672
4.32374
4.27798
4.23058
4.18149
4.1313
4.07989
4.02782
3.97518
3.92226
3.86901
3.81571
3.76241
3.70916
3.65604
3.60309
3.55047
3.49818
3.44641
3.39511
3.34444
3.29432
3.24491
3.19613
3.14803
3.1006
3.05397
3.00811
2.96292
2.91843
2.87445
2.83128
2.78879
2.74721
2.70635
2.66656
2.6278
2.59073
2.55603
2.52546
2.50374
4.54538
3.2422
2.42434
1.90808
1.57867
1.37481
1.25761
1.24501
1.2524
1.27385
1.31852
1.36075
1.3879
1.40075
1.40314
1.40283
1.402
1.40144
1.40151
1.40151
1.40141
1.40107
1.40023
1.3985
1.39579
1.3929
1.39003
1.38991
1.39067
1.39377
1.40273
1.4256
1.47905
1.60812
1.89744
2.56089
3.61087
3.77486
3.79978
3.84129
3.90309
3.98089
4.06975
4.16974
4.26648
4.36233
4.44298
4.50232
4.54169
4.56328
4.57167
4.57092
4.56721
4.55692
4.53491
4.50244
4.46868
4.43329
4.39567
4.3553
4.3126
4.26759
4.22077
4.17235
4.12268
4.07195
4.02041
3.9683
3.91577
3.86297
3.80998
3.75695
3.70395
3.65103
3.59833
3.54586
3.49382
3.44217
3.39114
3.34064
3.29077
3.24151
3.19307
3.14527
3.09825
3.05166
3.00582
2.96058
2.91615
2.87227
2.82925
2.78683
2.74536
2.70451
2.66476
2.62587
2.5886
2.55334
2.52197
2.49846
4.99806
3.8235
2.95367
2.34792
1.94205
1.66923
1.49827
1.39167
1.32998
1.31426
1.31768
1.32906
1.35328
1.38141
1.40082
1.41087
1.41081
1.4101
1.40834
1.40525
1.40331
1.40216
1.40129
1.40029
1.39852
1.39597
1.39278
1.39007
1.39035
1.39227
1.39673
1.41313
1.44377
1.53695
1.72085
2.19328
3.20142
3.79374
4.0355
4.12499
4.16803
4.19658
4.2057
4.21645
4.2434
4.29878
4.36838
4.43239
4.48393
4.51569
4.53036
4.53191
4.52988
4.52346
4.50887
4.48066
4.44762
4.41252
4.3756
4.33647
4.29507
4.25137
4.20569
4.15831
4.10958
4.05973
4.00904
3.95765
3.9058
3.85355
3.8011
3.74849
3.69592
3.64335
3.59103
3.53889
3.48722
3.43588
3.38514
3.33494
3.28556
3.23667
3.18847
3.14081
3.09391
3.0475
3.00187
2.95678
2.91256
2.86885
2.82604
2.78372
2.74238
2.70158
2.66188
2.6229
2.58546
2.54969
2.51738
2.49205
5.27092
4.24377
3.40832
2.77519
2.31289
1.9767
1.73296
1.55882
1.4372
1.36078
1.32043
1.32044
1.32387
1.33373
1.3541
1.37435
1.38908
1.39825
1.40088
1.40054
1.39948
1.39724
1.39456
1.39226
1.3903
1.38848
1.3871
1.38523
1.38537
1.38647
1.38896
1.39946
1.41803
1.47765
1.59401
1.88804
2.50593
3.683
4.37361
4.5956
4.5908
4.54743
4.43825
4.30878
4.24896
4.25269
4.2739
4.32375
4.38798
4.43739
4.4683
4.48237
4.48219
4.47942
4.47113
4.45272
4.42195
4.38689
4.35018
4.31199
4.272
4.22993
4.18589
4.14004
4.09265
4.04398
3.99434
3.94387
3.89282
3.84128
3.78947
3.73743
3.68539
3.63329
3.58149
3.52978
3.47858
3.42781
3.37773
3.32806
3.27907
3.23048
3.18259
3.13513
3.08849
3.04229
2.99696
2.95206
2.90809
2.86454
2.82197
2.77981
2.73867
2.698
2.65841
2.61947
2.58194
2.54584
2.51297
2.48609
5.4569
4.56562
3.78999
3.16117
2.67018
2.29314
2.00587
1.78921
1.62705
1.5101
1.42543
1.37172
1.34285
1.34037
1.34279
1.35001
1.36509
1.38179
1.39465
1.40286
1.40425
1.40384
1.4026
1.3999
1.39592
1.39225
1.38918
1.38642
1.38519
1.38565
1.3874
1.3934
1.40708
1.44328
1.52393
1.71849
2.1621
3.1766
4.68498
5.20091
5.14555
4.98627
4.6947
4.45136
4.29491
4.22933
4.22136
4.22844
4.254
4.30685
4.35722
4.39478
4.41427
4.4182
4.41581
4.40746
4.38858
4.35655
4.32021
4.28224
4.24298
4.20236
4.16027
4.11651
4.07108
4.02412
3.97594
3.92669
3.87668
3.82602
3.77501
3.72367
3.67231
3.62076
3.56959
3.51873
3.46834
3.41823
3.3687
3.31943
3.27081
3.22251
3.17497
3.12778
3.08147
3.03552
2.99051
2.94587
2.90219
2.85889
2.81658
2.77468
2.73375
2.6933
2.65385
2.61503
2.57747
2.54119
2.50798
2.47995
5.58459
4.81007
4.10285
3.49782
2.99977
2.59865
2.27954
2.02733
1.82855
1.67353
1.55326
1.46482
1.39991
1.36188
1.34197
1.34206
1.34413
1.34993
1.36188
1.3744
1.38372
1.39015
1.3907
1.39039
1.3894
1.38731
1.3842
1.38125
1.37964
1.37999
1.38166
1.38624
1.39823
1.42658
1.49275
1.64817
2.01066
2.86306
4.72515
5.84362
5.75946
5.50708
5.07347
4.70734
4.44759
4.28729
4.20586
4.1796
4.17699
4.18558
4.21155
4.26216
4.30337
4.33324
4.3442
4.34284
4.33636
4.32048
4.28877
4.25213
4.21269
4.17235
4.1314
4.08939
4.046
4.0011
3.95482
3.90714
3.85844
3.80882
3.75871
3.70813
3.65752
3.60698
3.55671
3.50655
3.45688
3.40731
3.35831
3.30945
3.2613
3.21337
3.16626
3.11944
3.07351
3.02791
2.98323
2.93893
2.89555
2.85259
2.81054
2.76895
2.72825
2.68808
2.6488
2.61017
2.57269
2.53634
2.50299
2.47419
5.67767
4.99567
4.35233
3.77989
3.28963
2.87958
2.54173
2.26557
2.04106
1.85971
1.71378
1.59808
1.50782
1.44057
1.39123
1.36296
1.34731
1.34738
1.34911
1.35398
1.36404
1.37527
1.38408
1.39068
1.39093
1.3904
1.38889
1.38577
1.38232
1.38248
1.38359
1.38921
1.39923
1.43155
1.49054
1.64474
1.95427
2.66367
4.13494
5.90414
5.98462
5.85035
5.52018
5.11788
4.7488
4.48684
4.30506
4.1931
4.14275
4.12429
4.12497
4.13448
4.15986
4.20724
4.23851
4.25927
4.2602
4.25657
4.24484
4.21938
4.18258
4.14228
4.10107
4.0592
4.0168
3.97357
3.92933
3.88358
3.83663
3.78843
3.7394
3.68992
3.64047
3.59088
3.54156
3.49213
3.44314
3.39415
3.34573
3.29742
3.2498
3.20239
3.15575
3.10942
3.06391
3.01876
2.97446
2.93059
2.88756
2.845
2.80327
2.76205
2.72164
2.68178
2.64275
2.60434
2.56702
2.53069
2.49732
2.46803
5.74506
5.13905
4.55373
4.01708
3.5429
3.13407
2.78717
2.49591
2.2527
2.05078
1.88342
1.74564
1.633
1.54205
1.4706
1.41679
1.37791
1.35649
1.34565
1.34583
1.34734
1.35139
1.3596
1.36789
1.37381
1.37783
1.37974
1.3797
1.37974
1.3805
1.38274
1.39096
1.40776
1.4517
1.54122
1.74093
2.14107
2.94088
3.70135
4.69285
5.51903
5.67661
5.6167
5.43058
5.08955
4.80079
4.52499
4.32974
4.19639
4.11397
4.08133
4.06554
4.06737
4.07815
4.10369
4.14078
4.16253
4.17231
4.17054
4.16314
4.14568
4.11131
4.07224
4.02966
3.98675
3.94386
3.90081
3.85671
3.81168
3.76523
3.71815
3.67007
3.62188
3.57325
3.52478
3.47609
3.42778
3.37946
3.33168
3.28403
3.237
3.19022
3.14412
3.09835
3.05333
3.00869
2.96484
2.92143
2.87881
2.83667
2.79531
2.75447
2.7144
2.67486
2.63614
2.59798
2.56089
2.52464
2.49137
2.46175
5.79761
5.25186
4.71699
4.21579
3.76182
3.3607
3.01199
2.71252
2.45693
2.24013
2.05658
1.90192
1.77193
1.66361
1.57428
1.50164
1.44515
1.40175
1.37075
1.35342
1.34462
1.3448
1.34617
1.34976
1.35708
1.36503
1.37167
1.37601
1.37849
1.38195
1.38945
1.4051
1.44046
1.51496
1.67436
1.99838
2.64773
3.19867
3.52368
3.91883
4.4378
5.01519
5.34966
5.32936
5.24021
5.0472
4.79052
4.57284
4.36274
4.2117
4.11021
4.04682
4.02099
4.0042
4.00608
4.01509
4.03523
4.06185
4.07676
4.07761
4.07427
4.06322
4.03924
4.00059
3.95833
3.91466
3.87101
3.82722
3.78339
3.73872
3.69352
3.64728
3.60058
3.55316
3.50567
3.45784
3.41029
3.36271
3.31562
3.26869
3.22235
3.17625
3.13079
3.08566
3.04122
2.99715
2.95383
2.91094
2.86881
2.82714
2.78625
2.74582
2.70618
2.667
2.62866
2.59077
2.55399
2.51786
2.48477
2.45492
5.83727
5.34164
4.8508
4.38341
3.95186
3.56271
3.21751
2.91516
2.65225
2.42515
2.22944
2.06149
1.91747
1.7946
1.69011
1.60201
1.52881
1.46887
1.42185
1.38614
1.36122
1.34713
1.34064
1.34087
1.34221
1.34551
1.35219
1.36007
1.36868
1.37832
1.39408
1.42584
1.49294
1.63096
1.91545
2.4894
3.08014
3.33913
3.45763
3.59947
3.81256
4.11328
4.53397
4.86113
5.02017
4.99994
4.92302
4.75405
4.56637
4.40219
4.24042
4.11598
4.0334
3.9793
3.95425
3.93515
3.93679
3.94333
3.95721
3.97561
3.98293
3.98141
3.97506
3.95929
3.92748
3.8868
3.84239
3.79768
3.7539
3.71016
3.66632
3.6217
3.57661
3.53065
3.48444
3.43771
3.39113
3.34443
3.29816
3.25201
3.20642
3.16105
3.11631
3.07184
3.02805
2.9846
2.94187
2.89952
2.85794
2.81676
2.77637
2.73637
2.69719
2.6584
2.62046
2.5829
2.54646
2.51054
2.47769
2.44767
5.87019
5.41432
4.96142
4.52551
4.11684
3.74215
3.40388
3.10255
2.83613
2.60235
2.39774
2.21949
2.06425
1.92958
1.81291
1.71234
1.62619
1.55316
1.49223
1.44238
1.40333
1.37371
1.35331
1.34152
1.33798
1.3387
1.34136
1.34742
1.35978
1.37846
1.40853
1.46952
1.59281
1.84535
2.35389
3.00861
3.30922
3.40154
3.4327
3.47024
3.53298
3.64143
3.81455
4.04943
4.36993
4.61602
4.74551
4.73004
4.67254
4.54584
4.39088
4.25999
4.1344
4.02418
3.94999
3.90409
3.8768
3.85746
3.85862
3.86329
3.87298
3.88551
3.8853
3.88231
3.87296
3.85196
3.81326
3.77019
3.72586
3.6815
3.63769
3.59376
3.54981
3.50521
3.46042
3.41507
3.36978
3.32424
3.27902
3.23381
3.18909
3.14452
3.10054
3.05679
3.01369
2.97087
2.92877
2.88701
2.84601
2.80537
2.76551
2.72602
2.68732
2.64898
2.61146
2.57429
2.53821
2.50254
2.46995
2.43978
5.89537
5.47313
5.05499
4.64879
4.26266
3.90343
3.5743
3.27654
3.00951
2.77169
2.56087
2.3746
2.21049
2.06607
1.93938
1.82832
1.7315
1.64732
1.57493
1.51311
1.46157
1.41936
1.38631
1.36207
1.34496
1.34079
1.34217
1.34685
1.35971
1.38444
1.4386
1.54474
1.76538
2.2062
2.88255
3.28015
3.40108
3.4207
3.41991
3.41519
3.40691
3.41534
3.44967
3.52998
3.6878
3.90352
4.18172
4.38876
4.51048
4.49974
4.4599
4.37531
4.23895
4.12899
4.0277
3.92973
3.86351
3.82246
3.79416
3.77408
3.77504
3.77859
3.78487
3.78926
3.7878
3.78197
3.76772
3.73837
3.69851
3.6544
3.61015
3.56592
3.52212
3.47813
3.4344
3.39038
3.3465
3.30236
3.25839
3.21432
3.17058
3.12692
3.08373
3.04075
2.99835
2.95624
2.91478
2.87366
2.83323
2.79318
2.75385
2.71489
2.67667
2.63882
2.60174
2.56499
2.5293
2.49392
2.46166
2.43137
5.92496
5.53098
5.14069
4.75903
4.39345
4.04915
3.72977
3.43704
3.17121
2.9315
2.71652
2.5244
2.35326
2.20107
2.06604
1.94635
1.84062
1.74725
1.66548
1.59393
1.5322
1.47953
1.43546
1.40021
1.373
1.35818
1.35947
1.36502
1.38408
1.42084
1.51014
1.68531
2.04934
2.71444
3.20979
3.39179
3.42408
3.42179
3.40971
3.37989
3.32373
3.27787
3.27711
3.28788
3.3244
3.40565
3.55939
3.75113
3.98179
4.16324
4.29057
4.29008
4.27024
4.21665
4.10825
4.00602
3.91681
3.83805
3.77587
3.73466
3.70715
3.68859
3.68789
3.68922
3.69235
3.69184
3.68869
3.67955
3.65963
3.6227
3.58127
3.5376
3.49362
3.44965
3.40638
3.36337
3.32076
3.27809
3.23555
3.19289
3.15037
3.10785
3.06562
3.02355
2.98191
2.94055
2.89975
2.8593
2.81948
2.78004
2.74127
2.70287
2.66518
2.62782
2.59123
2.5549
2.51967
2.48458
2.4527
2.42234
5.96345
5.58947
5.2218
4.86085
4.51282
4.18236
3.87233
3.58523
3.32164
3.0816
2.86398
2.66786
2.49126
2.33303
2.1912
2.06438
1.95128
1.85021
1.76067
1.68098
1.61095
1.54965
1.4964
1.45246
1.41569
1.39556
1.39754
1.40787
1.43401
1.50362
1.64228
1.94243
2.5373
3.10049
3.36246
3.42299
3.42189
3.41128
3.382
3.32213
3.25915
3.20643
3.16873
3.1462
3.14949
3.16363
3.2001
3.27541
3.40696
3.57276
3.768
3.9424
4.0695
4.10677
4.09574
4.06163
3.98659
3.89056
3.81224
3.74364
3.68451
3.6445
3.61733
3.60006
3.59652
3.59691
3.59677
3.59504
3.58898
3.57415
3.54393
3.50516
3.46339
3.42037
3.37763
3.33527
3.29353
3.25202
3.21078
3.16952
3.12837
3.08714
3.04608
3.00506
2.96436
2.92382
2.88378
2.84401
2.80485
2.766
2.72784
2.68998
2.65285
2.61599
2.57992
2.54402
2.50928
2.4745
2.44305
2.41266
6.0219
5.65393
5.30096
4.95754
4.62374
4.30415
4.00281
3.72146
3.46093
3.22185
3.00296
2.80434
2.6239
2.46094
2.31388
2.18111
2.06201
1.95442
1.85835
1.77183
1.69482
1.62651
1.5656
1.51583
1.47077
1.45635
1.46048
1.4805
1.52417
1.64897
1.88637
2.40004
3.00654
3.33266
3.42759
3.42657
3.41559
3.38537
3.32337
3.25764
3.20116
3.15189
3.10822
3.0701
3.04203
3.02216
3.0249
3.03665
3.066
3.12673
3.23714
3.38251
3.55187
3.72381
3.85077
3.93543
3.93018
3.9109
3.87184
3.79454
3.71344
3.64561
3.59247
3.55239
3.52338
3.50879
3.50664
3.5063
3.50468
3.49963
3.48762
3.46254
3.42874
3.39011
3.34937
3.30784
3.26649
3.22541
3.18484
3.14453
3.10455
3.06459
3.02484
2.985
2.94544
2.90588
2.86674
2.82772
2.78929
2.75106
2.71352
2.67621
2.63965
2.60328
2.56776
2.53231
2.49807
2.46364
2.43263
2.40226
6.10631
5.72368
5.37715
5.04497
4.72371
4.4154
4.12201
3.84684
3.5897
3.35263
3.13379
2.9337
2.75099
2.58433
2.43341
2.29578
2.17174
2.05875
1.95707
1.86487
1.7819
1.70779
1.64135
1.58701
1.54121
1.54197
1.55316
1.58429
1.68482
1.87874
2.31405
2.96019
3.33258
3.45609
3.45493
3.44235
3.40538
3.33077
3.25836
3.19801
3.14766
3.10134
3.05775
3.01626
2.97727
2.94243
2.91564
2.89391
2.89563
2.90353
2.9249
2.97095
3.06284
3.18827
3.34092
3.50436
3.64675
3.74902
3.78676
3.77872
3.7523
3.69417
3.61926
3.55098
3.4956
3.45332
3.4278
3.41709
3.41347
3.41146
3.40713
3.39763
3.37871
3.35042
3.31639
3.27873
3.23937
3.19918
3.15912
3.11924
3.07993
3.04081
3.00212
2.96341
2.92503
2.88655
2.84845
2.81033
2.77274
2.73521
2.69835
2.66161
2.62563
2.58978
2.55478
2.5198
2.48607
2.45202
2.42147
2.39114
6.19148
5.79932
5.45031
5.1256
4.8142
4.5161
4.23134
3.96252
3.70973
3.47483
3.2574
3.05662
2.87266
2.70352
2.54936
2.4082
2.27968
2.1625
2.05578
1.95892
1.87101
1.79195
1.72342
1.66428
1.64078
1.64672
1.6747
1.74423
1.92332
2.28234
2.95833
3.38054
3.52302
3.5209
3.50385
3.45457
3.36804
3.28967
3.21993
3.15867
3.1038
3.05471
3.01052
2.96744
2.92579
2.88596
2.84814
2.81459
2.787
2.76526
2.76195
2.76673
2.78261
2.81796
2.89097
2.99863
3.13556
3.29063
3.44712
3.56507
3.64813
3.64582
3.63162
3.60054
3.53691
3.46509
3.40711
3.36489
3.33864
3.32468
3.31759
3.31272
3.30544
3.29079
3.26883
3.24028
3.20716
3.17079
3.13285
3.09404
3.05534
3.0167
2.97864
2.94069
2.90326
2.86576
2.82871
2.79155
2.7549
2.7182
2.68211
2.64604
2.61069
2.57541
2.54096
2.50648
2.47327
2.43962
2.40956
2.37931
6.31795
5.89296
5.52641
5.20172
4.89767
4.6082
4.33168
4.07006
3.8226
3.59043
3.37463
3.17432
2.98938
2.81892
2.662
2.51814
2.38591
2.26507
2.15426
2.05337
1.96147
1.87997
1.80965
1.7621
1.76483
1.7843
1.84457
1.99793
2.32078
2.97793
3.46842
3.63742
3.63427
3.6117
3.54917
3.44726
3.35349
3.27365
3.20358
3.14069
3.08203
3.02665
2.97447
2.92622
2.88175
2.83875
2.7973
2.75779
2.72055
2.68758
2.65881
2.63772
2.62769
2.63071
2.64197
2.66864
2.72533
2.81707
2.93831
3.0883
3.24715
3.38956
3.49467
3.53549
3.52619
3.49866
3.44137
3.37461
3.323
3.28115
3.25209
3.23485
3.22406
3.21446
3.20241
3.18492
3.16197
3.13361
3.10148
3.06637
3.02987
2.9924
2.95503
2.91759
2.88075
2.84393
2.80771
2.77142
2.73569
2.69988
2.66465
2.62936
2.59474
2.56011
2.52628
2.49235
2.4597
2.42647
2.39694
2.36679
6.34674
5.98754
5.60776
5.27782
4.97682
4.69437
4.42532
4.16979
3.92856
3.70053
3.48665
3.28729
3.10197
2.93046
2.77169
2.62533
2.49037
2.36621
2.25216
2.14813
2.05338
1.97325
1.90435
1.89947
1.91326
1.95936
2.10745
2.39618
3.02962
3.598
3.80231
3.79851
3.77109
3.6962
3.56413
3.4468
3.35108
3.27034
3.1994
3.13533
3.07367
3.01414
2.95649
2.90113
2.84935
2.80139
2.75593
2.71261
2.67131
2.63204
2.59544
2.56256
2.53338
2.51241
2.49659
2.49861
2.50667
2.52639
2.56678
2.64455
2.75373
2.89622
3.05581
3.22002
3.3454
3.42328
3.41582
3.39323
3.35039
3.2906
3.24096
3.19864
3.16777
3.1471
3.13201
3.11802
3.10235
3.08272
3.05905
3.03078
2.99954
2.96546
2.93023
2.894
2.85789
2.82163
2.78598
2.75032
2.71533
2.68031
2.64591
2.61146
2.57764
2.54376
2.51064
2.47734
2.44532
2.41259
2.38361
2.35364
6.31294
6.10108
5.70746
5.36034
5.05771
4.77989
4.51587
4.26551
4.02872
3.8053
3.5943
3.39609
3.21101
3.03871
2.87863
2.73028
2.593
2.46623
2.34969
2.24336
2.15019
2.07108
2.04335
2.054
2.09719
2.22653
2.50702
3.10981
3.76765
4.01454
4.01017
3.97765
3.88846
3.73125
3.59006
3.47282
3.37407
3.28777
3.21013
3.13846
3.07206
3.01035
2.94903
2.88947
2.83157
2.7763
2.72494
2.67742
2.63216
2.58914
2.54837
2.50972
2.47392
2.44103
2.41229
2.39004
2.37175
2.37148
2.3756
2.38979
2.4207
2.4853
2.58402
2.717
2.87759
3.05466
3.20364
3.30852
3.30478
3.28986
3.26056
3.20268
3.15536
3.11426
3.08323
3.06001
3.04129
3.02367
3.00533
2.9838
2.95965
2.93121
2.9008
2.86763
2.83354
2.79853
2.76369
2.72867
2.69427
2.65988
2.62617
2.59249
2.55944
2.52637
2.49401
2.46145
2.43012
2.39798
2.36961
2.33991
6.22053
6.09894
5.824
5.45853
5.14245
4.8628
4.60449
4.35926
4.12562
3.90487
3.69701
3.50078
3.31624
3.14381
2.98276
2.83305
2.69396
2.56541
2.44724
2.34223
2.25174
2.20411
2.21152
2.25014
2.36111
2.63334
3.20461
3.96332
4.26475
4.26058
4.22393
4.12024
3.93852
3.77462
3.63781
3.52091
3.41773
3.32422
3.23825
3.15822
3.08344
3.01298
2.94713
2.88551
2.82354
2.76395
2.70673
2.65277
2.60258
2.55567
2.51128
2.46912
2.42915
2.39141
2.35642
2.32396
2.29589
2.27216
2.25435
2.2483
2.25129
2.26201
2.28657
2.33887
2.42743
2.55017
2.71203
2.89951
3.07343
3.19168
3.20134
3.19092
3.16491
3.11292
3.06841
3.03024
2.99885
2.97306
2.95134
2.93075
2.91043
2.88741
2.86287
2.83455
2.80475
2.77261
2.73973
2.70604
2.67253
2.63888
2.60578
2.57276
2.54036
2.50803
2.47641
2.44461
2.41404
2.38258
2.35489
2.32557
6.11635
6.06169
5.89568
5.5604
5.23388
4.9487
4.69076
4.44928
4.22006
4.00184
3.79566
3.60149
3.41826
3.24588
3.08446
2.93359
2.79354
2.66388
2.54727
2.44611
2.37939
2.38405
2.41707
2.51839
2.78005
3.33034
4.19199
4.5504
4.54645
4.50549
4.38565
4.17919
3.99275
3.83631
3.70206
3.58243
3.47337
3.37225
3.27798
3.18953
3.1065
3.02831
2.95493
2.88543
2.82107
2.75906
2.69828
2.63977
2.58393
2.53181
2.48342
2.43754
2.39414
2.3531
2.31423
2.27768
2.24357
2.21198
2.18443
2.16001
2.14275
2.13226
2.1343
2.14256
2.16209
2.20531
2.28346
2.3981
2.56165
2.75911
2.95278
3.07595
3.10173
3.09315
3.06955
3.02348
2.9825
2.94602
2.91378
2.8857
2.86179
2.83913
2.81742
2.79352
2.76865
2.74084
2.71161
2.68065
2.64906
2.61681
2.58469
2.55247
2.52074
2.48908
2.45812
2.42702
2.3972
2.36643
2.33945
2.31063
5.9155
5.95651
5.88158
5.68754
5.347
5.04453
4.77999
4.53845
4.31212
4.09687
3.89207
3.69894
3.51717
3.3456
3.18404
3.03285
2.89254
2.764
2.65395
2.56756
2.56953
2.59647
2.69055
2.93121
3.44842
4.4238
4.85839
4.85526
4.8113
4.68003
4.4476
4.23773
4.06201
3.91068
3.7755
3.65132
3.53587
3.42741
3.3255
3.22931
3.13874
3.05328
2.97277
2.89685
2.82545
2.75819
2.69551
2.6341
2.57494
2.5182
2.46441
2.41427
2.36747
2.32323
2.28133
2.24167
2.20411
2.16886
2.13576
2.1053
2.07818
2.05389
2.0368
2.02328
2.02476
2.03115
2.04735
2.08302
2.15215
2.26266
2.42672
2.63095
2.84502
2.96623
3.00361
2.99596
2.97498
2.93412
2.89658
2.8608
2.82777
2.79839
2.7732
2.74933
2.72662
2.70251
2.67733
2.65021
2.62181
2.59212
2.56188
2.5311
2.5004
2.46959
2.43936
2.40895
2.37981
2.34973
2.32343
2.29519
5.42832
5.83987
5.82014
5.71282
5.47263
5.15424
4.87551
4.62922
4.40288
4.19019
3.98862
3.79641
3.61414
3.44281
3.28179
3.13118
2.99217
2.87203
2.77148
2.76574
2.78966
2.87957
3.11836
3.63336
4.66537
5.17643
5.18787
5.14315
4.99913
4.74011
4.50652
4.31106
4.14292
3.99218
3.85349
3.72377
3.60182
3.48649
3.37762
3.27453
3.17724
3.08521
2.99837
2.91633
2.83891
2.76596
2.69707
2.63258
2.57169
2.51195
2.4547
2.40009
2.349
2.30126
2.25615
2.21349
2.17312
2.13494
2.09884
2.06496
2.03308
2.00383
1.97728
1.95368
1.93645
1.92141
1.92231
1.9274
1.94065
1.97165
2.03439
2.14392
2.30499
2.51264
2.74378
2.85988
2.90459
2.89837
2.88082
2.84632
2.8105
2.77513
2.74203
2.71235
2.6864
2.6621
2.63857
2.61444
2.58943
2.56307
2.53569
2.5073
2.47844
2.44906
2.41993
2.39041
2.36206
2.33268
2.30706
2.27942
4.3713
5.56483
5.73529
5.6891
5.55307
5.27187
4.97916
4.72444
4.49564
4.28302
4.08217
3.89156
3.7107
3.53953
3.37908
3.23011
3.09944
2.98979
2.97023
2.99326
3.08307
3.3253
3.86
4.94369
5.53038
5.55637
5.50619
5.34423
5.05658
4.79763
4.58171
4.39617
4.22996
4.07658
3.93296
3.79733
3.66906
3.54737
3.43225
3.32304
3.21983
3.12198
3.02952
2.94196
2.8592
2.78096
2.70702
2.63735
2.57143
2.50994
2.45059
2.39333
2.3385
2.28654
2.2381
2.19242
2.14925
2.10841
2.06979
2.03323
1.99869
1.96622
1.93563
1.90758
1.88179
1.85908
1.84166
1.82662
1.82644
1.82993
1.84232
1.8701
1.92906
2.04003
2.20302
2.40709
2.64746
2.75856
2.8074
2.80275
2.7885
2.75948
2.72491
2.69042
2.65777
2.62828
2.60205
2.57754
2.55382
2.52987
2.50534
2.47984
2.4536
2.42644
2.3991
2.371
2.34379
2.31534
2.29049
2.26353
2.7571
4.93542
5.57603
5.61587
5.55086
5.39074
5.10064
4.83072
4.59233
4.37667
4.17543
3.98545
3.80539
3.63559
3.4771
3.33671
3.2186
3.18686
3.20906
3.29996
3.54826
4.10916
5.25008
5.91709
5.95923
5.90227
5.718
5.39823
5.11161
4.87355
4.66987
4.48753
4.31928
4.16134
4.01207
3.87047
3.73619
3.60869
3.48792
3.37327
3.26477
3.16177
3.06431
2.97184
2.88431
2.80137
2.72287
2.64861
2.57841
2.51213
2.44964
2.39098
2.33364
2.27881
2.22662
2.17774
2.13174
2.08825
2.04708
2.00811
1.97124
1.93636
1.9034
1.87243
1.84321
1.81643
1.79162
1.76979
1.75265
1.73785
1.73702
1.74031
1.75182
1.77895
1.83681
1.94886
2.11175
2.32262
2.55826
2.66339
2.71427
2.71094
2.69887
2.67409
2.64087
2.60748
2.57568
2.5467
2.52065
2.49626
2.47275
2.44921
2.42543
2.40082
2.37589
2.34986
2.32438
2.29736
2.27358
2.24762
2.10176
3.5192
5.14085
5.50898
5.50174
5.42278
5.23812
4.9531
4.69881
4.47429
4.26974
4.07798
3.89927
3.73187
3.58211
3.45577
3.41468
3.43646
3.52893
3.78459
4.36484
5.55254
6.32147
6.38233
6.31915
6.11513
5.76295
5.44769
5.18661
4.9637
4.76458
4.58068
4.40803
4.24453
4.08941
3.94199
3.80212
3.66928
3.54341
3.42386
3.31067
3.20311
3.10124
3.00441
2.91266
2.82552
2.74292
2.66461
2.59042
2.52017
2.45382
2.39092
2.33205
2.27547
2.22094
2.16887
2.11994
2.07381
2.03015
1.9888
1.94965
1.91259
1.87752
1.84436
1.813
1.78358
1.75578
1.73029
1.70666
1.6857
1.66929
1.65494
1.65415
1.65746
1.66865
1.69653
1.75427
1.86761
2.02612
2.24766
2.47686
2.57372
2.62495
2.62269
2.61256
2.59077
2.55915
2.52706
2.49644
2.46828
2.44281
2.41883
2.39587
2.37291
2.35012
2.32637
2.30307
2.27804
2.25576
2.23139
1.62564
2.32861
4.18652
5.23857
5.42205
5.39539
5.2959
5.08042
4.81114
4.57365
4.36303
4.172
3.9945
3.83589
3.70128
3.65241
3.67444
3.77068
4.0389
4.65222
5.91733
6.76007
6.83019
6.75932
6.53348
6.14773
5.80359
5.519
5.27653
5.05994
4.85999
4.67195
4.49386
4.32458
4.16378
4.01095
3.86596
3.72828
3.59781
3.47388
3.35645
3.24479
3.13894
3.03821
2.94267
2.85179
2.76555
2.68363
2.60592
2.53222
2.46237
2.39624
2.33365
2.27464
2.21867
2.16458
2.11288
2.06413
2.01806
1.97441
1.93306
1.8939
1.85682
1.82172
1.78851
1.75713
1.72745
1.69962
1.67331
1.64912
1.62682
1.6067
1.59139
1.57754
1.57764
1.58116
1.59248
1.62178
1.68219
1.79915
1.95396
2.17772
2.40085
2.48975
2.53969
2.53853
2.53023
2.51077
2.48083
2.45021
2.42094
2.39379
2.36916
2.34579
2.32365
2.30134
2.27992
2.25696
2.23655
2.21439
1.27929
1.73785
2.62672
4.60688
5.25094
5.3319
5.2874
5.16998
4.92993
4.68128
4.46295
4.26931
4.09932
3.95755
3.90019
3.92284
4.02428
4.30855
4.96195
6.31356
7.24672
7.314
7.23072
6.97559
6.55389
6.17931
5.87061
5.60794
5.37347
5.15667
4.95273
4.75923
4.57536
4.40044
4.23432
4.07652
3.92686
3.78482
3.65017
3.52229
3.40102
3.28569
3.17624
3.07204
2.97309
2.87888
2.7894
2.70428
2.62346
2.54668
2.47382
2.40471
2.33916
2.27713
2.21832
2.16302
2.10948
2.05832
2.01004
1.96427
1.92086
1.87972
1.84073
1.80378
1.76879
1.73567
1.70434
1.67475
1.64675
1.62051
1.59575
1.57282
1.55202
1.5327
1.51879
1.50578
1.5065
1.51158
1.52211
1.55602
1.61613
1.73824
1.90209
2.12105
2.33022
2.41299
2.45995
2.45952
2.45228
2.43453
2.40645
2.3775
2.34985
2.32385
2.30029
2.2776
2.2567
2.2351
2.21623
2.19631
1.17391
1.36804
1.96763
3.19671
4.79326
5.20827
5.23417
5.17936
5.04649
4.80255
4.57526
4.3819
4.22294
4.15808
4.18188
4.29041
4.59704
5.30415
6.77007
7.78158
7.83125
7.7309
7.44162
6.98291
6.57734
6.2436
5.95984
5.70619
5.47152
5.25034
5.04059
4.84106
4.65149
4.47128
4.30032
4.13801
3.98417
3.83817
3.69974
3.56826
3.4435
3.32483
3.21212
3.10478
3.00279
2.90561
2.81326
2.72532
2.64178
2.56231
2.48683
2.41512
2.34704
2.28242
2.22116
2.16298
2.10825
2.05549
2.00505
1.95741
1.91216
1.86921
1.82845
1.78979
1.75315
1.71842
1.68556
1.65445
1.625
1.59722
1.57091
1.54623
1.52305
1.50133
1.48206
1.46375
1.45096
1.44004
1.44106
1.44623
1.4604
1.49334
1.56
1.68302
1.85328
2.07269
2.26492
2.34142
2.38514
2.38585
2.37959
2.36292
2.33683
2.30971
2.28378
2.259
2.23684
2.21514
2.19643
2.17805
1.08124
1.22115
1.48524
2.21385
3.74711
4.87782
5.14112
5.13607
5.0764
4.93472
4.7076
4.51315
4.42719
4.45179
4.56911
4.90178
5.67254
7.26897
8.34084
8.36911
8.24945
7.92596
7.43322
6.99693
6.63847
6.33344
6.06008
5.80621
5.56656
5.33888
5.12257
4.91695
4.72192
4.53678
4.36138
4.19497
4.03732
3.8877
3.74586
3.61107
3.48316
3.36146
3.24583
3.13568
3.03095
2.93114
2.83625
2.74584
2.65992
2.57811
2.50037
2.42641
2.35613
2.28932
2.22585
2.16562
2.10836
2.05443
2.00249
1.95307
1.90618
1.86162
1.8193
1.7791
1.74097
1.70478
1.6705
1.638
1.60722
1.57809
1.5505
1.52447
1.49986
1.47665
1.45512
1.43461
1.41685
1.39989
1.38792
1.37987
1.38111
1.3876
1.4025
1.4397
1.51178
1.6438
1.81698
2.03074
2.20538
2.27703
2.31657
2.31791
2.31213
2.29685
2.27274
2.24754
2.22361
2.20032
2.18066
2.16195
1.04141
1.11581
1.2358
1.63994
2.38297
4.13998
4.91737
5.07116
5.05692
4.99522
4.85514
4.72166
4.7434
4.86738
5.22768
6.0785
7.83259
8.96484
8.95103
8.79397
8.41239
7.89568
7.4358
7.05493
6.729
6.43536
6.16144
5.90186
5.65498
5.4202
5.19744
4.98618
4.78618
4.59664
4.41724
4.24713
4.086
3.93307
3.78806
3.6503
3.5195
3.39505
3.27676
3.16408
3.05692
2.9548
2.85767
2.76511
2.67711
2.59328
2.51358
2.43769
2.36553
2.29687
2.23157
2.16949
2.1105
2.05441
2.00144
1.95053
1.90221
1.85625
1.81256
1.77103
1.73159
1.69412
1.65857
1.62483
1.59284
1.56251
1.53377
1.50656
1.48081
1.45645
1.43356
1.41182
1.39188
1.37281
1.35628
1.34135
1.32968
1.32528
1.32694
1.33454
1.3516
1.39275
1.46991
1.60763
1.78778
1.99702
2.152
2.2189
2.25453
2.25655
2.25122
2.23715
2.21509
2.19206
2.17156
2.15128
1.02508
1.04975
1.13844
1.28672
1.73853
2.60406
4.36338
4.91679
5.02651
5.02265
5.00891
5.03349
5.17478
5.57973
6.53735
8.48139
9.5983
9.56739
9.36628
8.91404
8.37098
7.89192
7.49078
7.14456
6.83029
6.53541
6.25498
5.98768
5.7335
5.4923
5.26401
5.04794
4.84366
4.65025
4.46728
4.29385
4.12958
3.97368
3.82585
3.68535
3.55194
3.42498
3.3043
3.18936
3.08007
2.97594
2.87691
2.78253
2.69279
2.60726
2.52591
2.44838
2.37465
2.30442
2.23763
2.17403
2.11354
2.05598
2.00133
1.94935
1.89981
1.85265
1.80779
1.7651
1.72452
1.68593
1.64927
1.61444
1.58137
1.54998
1.52019
1.49195
1.46519
1.43984
1.41591
1.39323
1.37203
1.3519
1.33339
1.31618
1.30053
1.28812
1.27707
1.2761
1.27827
1.28808
1.30698
1.35396
1.43978
1.58277
1.7663
1.96895
2.10603
2.1686
2.20021
2.20258
2.19772
2.18497
2.16623
2.14696
1.01147
1.03104
1.06362
1.17129
1.37177
1.93319
3.10949
4.49046
4.92727
5.05556
5.16444
5.41609
5.95329
7.09783
9.31006
10.3349
10.2698
10.0021
9.44079
8.866
8.37328
7.95734
7.59082
7.25322
6.93405
6.62964
6.33954
6.06392
5.80295
5.55621
5.32324
5.1031
4.89513
4.69831
4.51214
4.33567
4.16851
4.00988
3.85943
3.71647
3.58065
3.45143
3.32856
3.21161
3.10038
2.99443
2.89365
2.79766
2.70636
2.61938
2.53667
2.45786
2.38286
2.31138
2.24333
2.17849
2.11677
2.05802
2.00207
1.949
1.89836
1.85016
1.80429
1.76065
1.71912
1.67963
1.64205
1.60632
1.57234
1.54005
1.50936
1.48021
1.45256
1.42632
1.40152
1.37801
1.3559
1.33497
1.31539
1.29708
1.27989
1.26469
1.25019
1.23987
1.23113
1.23192
1.23536
1.24836
1.27042
1.32463
1.41783
1.56327
1.75207
1.94803
2.06784
2.12668
2.15408
2.15806
2.15422
2.14488
1.00704
1.01421
1.03835
1.07945
1.21155
1.4595
2.12376
3.48865
4.62657
5.04142
5.43123
6.20913
7.73421
10.2513
11.147
11.0406
10.6962
10.0016
9.37208
8.86357
8.43743
8.05541
7.69581
7.35116
7.02084
6.70588
6.40718
6.1249
5.85873
5.60774
5.37109
5.14763
4.93662
4.73699
4.54814
4.36917
4.19963
4.03873
3.88611
3.7411
3.60343
3.47253
3.34808
3.22961
3.11687
3.00955
2.90744
2.81023
2.71774
2.62965
2.54582
2.46593
2.38988
2.31738
2.24834
2.18252
2.11984
2.06011
2.00324
1.94912
1.89759
1.84851
1.80182
1.75736
1.71506
1.6748
1.63646
1.59997
1.56523
1.53218
1.50075
1.47086
1.44248
1.41556
1.39004
1.36585
1.343
1.32141
1.30109
1.28204
1.26408
1.24764
1.23203
1.21848
1.20619
1.19666
1.19251
1.19365
1.19961
1.21129
1.2433
1.30238
1.40722
1.55415
1.74577
1.93622
2.03755
2.09619
2.11798
2.13314
1.00319
1.00857
1.01723
1.04661
1.09612
1.25568
1.55411
2.32869
3.9023
4.97286
6.03381
8.15308
11.3332
12.1261
11.9604
11.4773
10.6059
9.91427
9.38099
8.94341
8.54601
8.16453
7.79385
7.4362
7.09475
6.77132
6.46636
6.17927
5.90911
5.65459
5.41469
5.18817
4.97427
4.77191
4.58051
4.39915
4.22736
4.06437
3.90976
3.76292
3.62342
3.49082
3.36473
3.24482
3.13073
3.02222
2.91895
2.8207
2.72718
2.63814
2.55338
2.4726
2.39568
2.32233
2.25248
2.18585
2.12241
2.0619
2.00431
1.94938
1.89712
1.84733
1.8
1.75492
1.71203
1.67118
1.63227
1.5952
1.55989
1.52626
1.49425
1.46379
1.43483
1.40731
1.38119
1.35643
1.33301
1.31087
1.28999
1.27039
1.25191
1.23476
1.21864
1.20386
1.1904
1.17808
1.16868
1.16027
1.16046
1.16257
1.16952
1.18599
1.22163
1.29163
1.40444
1.55794
1.74331
1.93642
2.01534
2.09506
1.00176
1.00469
1.00946
1.02535
1.05161
1.13824
1.29281
1.75163
2.64756
4.72411
7.57919
12.3283
13.1164
12.8491
12.1597
11.244
10.5411
9.9908
9.52609
9.08653
8.66398
8.25703
7.86729
7.49673
7.1466
6.817
6.50728
6.21622
5.94257
5.68489
5.44216
5.21314
4.997
4.79269
4.59951
4.41658
4.24332
4.07901
3.92315
3.7752
3.63467
3.50118
3.37425
3.25364
3.13888
3.02978
2.92594
2.82716
2.7331
2.64356
2.55827
2.47697
2.39951
2.32563
2.25524
2.18807
2.12409
2.06303
2.00491
1.94943
1.8967
1.84643
1.79858
1.75297
1.70955
1.66819
1.62881
1.5913
1.55557
1.52155
1.48914
1.45829
1.42893
1.40102
1.37451
1.34936
1.32553
1.303
1.28172
1.26171
1.24286
1.22526
1.20881
1.1935
1.17947
1.16642
1.15506
1.1448
1.13694
1.13314
1.13394
1.13757
1.14688
1.16807
1.21139
1.29831
1.3971
1.58882
1.74696
1.97887
1.00131
1.00265
1.0073
1.01445
1.04175
1.08009
1.24627
1.52225
2.50957
4.82883
10.7405
13.7819
13.5033
12.7624
11.9009
11.2197
10.6555
10.1536
9.66956
9.19617
8.7422
8.31461
7.91366
7.53745
7.18424
6.85237
6.54046
6.247
5.97091
5.71089
5.46597
5.23495
5.01699
4.81103
4.61634
4.43203
4.25749
4.09202
3.93507
3.78611
3.64463
3.51027
3.38252
3.26115
3.14568
3.03593
2.93148
2.83214
2.73755
2.64752
2.56177
2.48006
2.40224
2.328
2.25728
2.18978
2.12549
2.06411
2.00569
1.94992
1.89686
1.84624
1.79806
1.75212
1.70838
1.66672
1.62701
1.58922
1.55318
1.51888
1.48617
1.45505
1.42541
1.39722
1.37043
1.34499
1.32088
1.29807
1.27651
1.25622
1.23711
1.21922
1.20251
1.18695
1.17259
1.15931
1.14727
1.13642
1.12677
1.11939
1.11332
1.11369
1.11552
1.12142
1.13329
1.16161
1.21281
1.31751
1.44054
1.69932
1.00109
1.00223
1.00622
1.0124
1.03659
1.06838
1.22858
1.46061
2.523
4.97337
11.5944
13.0418
12.8241
12.3776
11.9089
11.411
10.8748
10.3179
9.7758
9.2665
8.79319
8.35344
7.94447
7.56313
7.2063
6.87149
6.55692
6.26111
5.98293
5.72113
5.4747
5.24244
5.02344
4.8166
4.62116
4.4362
4.26108
4.0951
3.9377
3.78836
3.64653
3.51187
3.38386
3.26227
3.14659
3.03667
2.93205
2.83257
2.73784
2.64768
2.56179
2.47995
2.40197
2.3276
2.25673
2.18908
2.12465
2.06312
2.00455
1.94864
1.89543
1.84468
1.79638
1.75035
1.70651
1.66476
1.62495
1.58708
1.55092
1.51656
1.48375
1.45257
1.42283
1.39457
1.3677
1.34217
1.31798
1.29507
1.27343
1.25303
1.23383
1.21586
1.19904
1.18339
1.16893
1.15553
1.1434
1.13221
1.12248
1.11355
1.10691
1.10117
1.10154
1.10324
1.1084
1.11828
1.14259
1.18753
1.27823
1.46948
)
;
boundaryField
{
inlet
{
type fixedValue;
value uniform 1;
}
outlet
{
type waveTransmissive;
gamma 1.4;
fieldInf 1;
lInf 3;
value nonuniform List<scalar>
400
(
2.50112
2.49803
2.49275
2.48636
2.48044
2.47432
2.46858
2.46244
2.45619
2.44939
2.44217
2.43432
2.42596
2.41697
2.40733
2.39699
2.38591
2.37413
2.36167
2.34857
2.33488
2.32059
2.3057
2.29031
2.2746
2.25877
2.24292
2.22671
2.20971
2.19163
2.17344
2.15756
2.14728
2.14317
2.14072
2.12816
2.08744
1.96468
1.67538
1.44901
2.50111
2.49801
2.49274
2.48634
2.48042
2.4743
2.46856
2.46242
2.45617
2.44937
2.44215
2.4343
2.42593
2.41694
2.40731
2.39696
2.38588
2.3741
2.36164
2.34853
2.33485
2.32056
2.30567
2.29028
2.27457
2.25874
2.24288
2.22668
2.20968
2.1916
2.17341
2.15752
2.14723
2.14312
2.14068
2.12814
2.08749
1.96492
1.67591
1.44948
2.50111
2.49801
2.49274
2.48634
2.48042
2.4743
2.46856
2.46242
2.45617
2.44937
2.44215
2.4343
2.42593
2.41694
2.40731
2.39696
2.38588
2.3741
2.36164
2.34854
2.33485
2.32057
2.30567
2.29029
2.27457
2.25875
2.24288
2.22668
2.20968
2.19161
2.17341
2.15753
2.14723
2.14312
2.14068
2.12814
2.0875
1.96493
1.67594
1.44951
2.50111
2.49801
2.49274
2.48634
2.48042
2.4743
2.46856
2.46242
2.45617
2.44937
2.44215
2.4343
2.42593
2.41694
2.40731
2.39696
2.38588
2.3741
2.36164
2.34853
2.33485
2.32057
2.30567
2.29029
2.27457
2.25875
2.24288
2.22668
2.20968
2.19161
2.17341
2.15752
2.14723
2.14312
2.14068
2.12814
2.0875
1.96493
1.67594
1.4495
2.50111
2.49801
2.49274
2.48634
2.48042
2.4743
2.46856
2.46242
2.45617
2.44937
2.44215
2.4343
2.42593
2.41694
2.40731
2.39696
2.38588
2.3741
2.36164
2.34853
2.33485
2.32056
2.30567
2.29028
2.27457
2.25874
2.24288
2.22668
2.20968
2.19161
2.17341
2.15752
2.14723
2.14312
2.14068
2.12814
2.0875
1.96494
1.67595
1.44951
2.50111
2.49801
2.49274
2.48634
2.48042
2.4743
2.46856
2.46242
2.45617
2.44937
2.44215
2.4343
2.42593
2.41694
2.40731
2.39696
2.38588
2.3741
2.36164
2.34853
2.33485
2.32056
2.30567
2.29029
2.27457
2.25875
2.24288
2.22668
2.20968
2.19161
2.17341
2.15752
2.14723
2.14312
2.14068
2.12814
2.0875
1.96493
1.67594
1.44951
2.50111
2.49801
2.49274
2.48634
2.48042
2.4743
2.46856
2.46242
2.45617
2.44937
2.44215
2.4343
2.42593
2.41694
2.40731
2.39696
2.38588
2.3741
2.36164
2.34853
2.33485
2.32057
2.30567
2.29029
2.27457
2.25875
2.24288
2.22668
2.20968
2.19161
2.17341
2.15752
2.14723
2.14312
2.14068
2.12814
2.0875
1.96493
1.67594
1.4495
2.50111
2.49801
2.49274
2.48634
2.48042
2.4743
2.46856
2.46242
2.45617
2.44937
2.44215
2.4343
2.42593
2.41694
2.40731
2.39696
2.38588
2.3741
2.36164
2.34854
2.33485
2.32057
2.30567
2.29029
2.27457
2.25875
2.24288
2.22668
2.20968
2.19161
2.17341
2.15753
2.14723
2.14312
2.14068
2.12814
2.0875
1.96493
1.67594
1.44951
2.50111
2.49801
2.49274
2.48634
2.48042
2.4743
2.46856
2.46242
2.45617
2.44937
2.44215
2.4343
2.42593
2.41694
2.40731
2.39696
2.38588
2.3741
2.36164
2.34853
2.33485
2.32056
2.30567
2.29028
2.27457
2.25874
2.24288
2.22668
2.20968
2.1916
2.17341
2.15752
2.14723
2.14312
2.14068
2.12814
2.08749
1.96492
1.67591
1.44948
2.50112
2.49803
2.49275
2.48636
2.48043
2.47432
2.46858
2.46244
2.45619
2.44939
2.44217
2.43432
2.42596
2.41697
2.40733
2.39698
2.38591
2.37413
2.36167
2.34856
2.33488
2.32059
2.3057
2.29031
2.27459
2.25877
2.24291
2.22671
2.20971
2.19163
2.17343
2.15755
2.14727
2.14317
2.14072
2.12816
2.08744
1.96468
1.67538
1.44901
)
;
}
bottom
{
type symmetryPlane;
}
top
{
type symmetryPlane;
}
obstacle
{
type zeroGradient;
}
defaultFaces
{
type empty;
}
}
// ************************************************************************* //
| [
"benroque94@gmail.com"
] | benroque94@gmail.com | |
7170046e727c071eb8effab641909db7b47832d8 | 9eb2e626d0ee126d88be75ced35bf5097649a583 | /Source/NetworkA/NetworkACharacter.cpp | 19b4eeb772500e2a4ca0a32bba9591ce3d6cf4f8 | [] | no_license | tjrdud9665/NetworkAA | 770ea671da85e05391a423d05a122d18ff00e7d0 | c610599fd5940d47601436eaa7b851b063d210b5 | refs/heads/master | 2021-09-01T14:48:22.756421 | 2017-12-27T15:03:43 | 2017-12-27T15:03:43 | 115,531,376 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,277 | cpp | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#include "NetworkACharacter.h"
#include "HeadMountedDisplayFunctionLibrary.h"
#include "Camera/CameraComponent.h"
#include "Components/CapsuleComponent.h"
#include "Components/InputComponent.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "GameFramework/Controller.h"
#include "GameFramework/SpringArmComponent.h"
//////////////////////////////////////////////////////////////////////////
// ANetworkACharacter
ANetworkACharacter::ANetworkACharacter()
{
// Set size for collision capsule
GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);
// set our turn rates for input
BaseTurnRate = 45.f;
BaseLookUpRate = 45.f;
// Don't rotate when the controller rotates. Let that just affect the camera.
bUseControllerRotationPitch = false;
bUseControllerRotationYaw = false;
bUseControllerRotationRoll = false;
// Configure character movement
GetCharacterMovement()->bOrientRotationToMovement = true; // Character moves in the direction of input...
GetCharacterMovement()->RotationRate = FRotator(0.0f, 540.0f, 0.0f); // ...at this rotation rate
GetCharacterMovement()->JumpZVelocity = 600.f;
GetCharacterMovement()->AirControl = 0.2f;
// Create a camera boom (pulls in towards the player if there is a collision)
CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
CameraBoom->SetupAttachment(RootComponent);
CameraBoom->TargetArmLength = 300.0f; // The camera follows at this distance behind the character
CameraBoom->bUsePawnControlRotation = true; // Rotate the arm based on the controller
// Create a follow camera
FollowCamera = CreateDefaultSubobject<UCameraComponent>(TEXT("FollowCamera"));
FollowCamera->SetupAttachment(CameraBoom, USpringArmComponent::SocketName); // Attach the camera to the end of the boom and let the boom adjust to match the controller orientation
FollowCamera->bUsePawnControlRotation = false; // Camera does not rotate relative to arm
// Note: The skeletal mesh and anim blueprint references on the Mesh component (inherited from Character)
// are set in the derived blueprint asset named MyCharacter (to avoid direct content references in C++)
}
//////////////////////////////////////////////////////////////////////////
// Input
void ANetworkACharacter::SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent)
{
// Set up gameplay key bindings
check(PlayerInputComponent);
PlayerInputComponent->BindAction("Jump", IE_Pressed, this, &ACharacter::Jump);
PlayerInputComponent->BindAction("Jump", IE_Released, this, &ACharacter::StopJumping);
PlayerInputComponent->BindAxis("MoveForward", this, &ANetworkACharacter::MoveForward);
PlayerInputComponent->BindAxis("MoveRight", this, &ANetworkACharacter::MoveRight);
// We have 2 versions of the rotation bindings to handle different kinds of devices differently
// "turn" handles devices that provide an absolute delta, such as a mouse.
// "turnrate" is for devices that we choose to treat as a rate of change, such as an analog joystick
PlayerInputComponent->BindAxis("Turn", this, &APawn::AddControllerYawInput);
PlayerInputComponent->BindAxis("TurnRate", this, &ANetworkACharacter::TurnAtRate);
PlayerInputComponent->BindAxis("LookUp", this, &APawn::AddControllerPitchInput);
PlayerInputComponent->BindAxis("LookUpRate", this, &ANetworkACharacter::LookUpAtRate);
// handle touch devices
PlayerInputComponent->BindTouch(IE_Pressed, this, &ANetworkACharacter::TouchStarted);
PlayerInputComponent->BindTouch(IE_Released, this, &ANetworkACharacter::TouchStopped);
// VR headset functionality
PlayerInputComponent->BindAction("ResetVR", IE_Pressed, this, &ANetworkACharacter::OnResetVR);
}
void ANetworkACharacter::OnResetVR()
{
UHeadMountedDisplayFunctionLibrary::ResetOrientationAndPosition();
}
void ANetworkACharacter::TouchStarted(ETouchIndex::Type FingerIndex, FVector Location)
{
Jump();
}
void ANetworkACharacter::TouchStopped(ETouchIndex::Type FingerIndex, FVector Location)
{
StopJumping();
}
void ANetworkACharacter::TurnAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerYawInput(Rate * BaseTurnRate * GetWorld()->GetDeltaSeconds());
}
void ANetworkACharacter::LookUpAtRate(float Rate)
{
// calculate delta for this frame from the rate information
AddControllerPitchInput(Rate * BaseLookUpRate * GetWorld()->GetDeltaSeconds());
}
void ANetworkACharacter::MoveForward(float Value)
{
if ((Controller != NULL) && (Value != 0.0f))
{
// find out which way is forward
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
// get forward vector
const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::X);
AddMovementInput(Direction, Value);
}
}
void ANetworkACharacter::MoveRight(float Value)
{
if ( (Controller != NULL) && (Value != 0.0f) )
{
// find out which way is right
const FRotator Rotation = Controller->GetControlRotation();
const FRotator YawRotation(0, Rotation.Yaw, 0);
// get right vector
const FVector Direction = FRotationMatrix(YawRotation).GetUnitAxis(EAxis::Y);
// add movement in that direction
AddMovementInput(Direction, Value);
}
}
| [
"tjrdud9665@gmail.com"
] | tjrdud9665@gmail.com |
98daad65e692770f5d5f42a989aa82abd58a6059 | dfba98800aeba93d39634118b6a0d53d4b9d0c63 | /ae-tpcc-silo-latency/masstree/kvthread.cc | b07e320a01c7010e349686a80e4425df3c488b56 | [
"MIT",
"W3C",
"LicenseRef-scancode-click-license",
"Apache-2.0"
] | permissive | gaoyuanning/Polyjuice | 039b4b818297dace3af4597f2e2660b78039f007 | f9b78845f2232250013e7c4919004fe349377fee | refs/heads/master | 2023-05-30T02:25:43.222618 | 2021-06-23T12:53:04 | 2021-06-23T12:53:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,584 | cc | /* Masstree
* Eddie Kohler, Yandong Mao, Robert Morris
* Copyright (c) 2012-2013 President and Fellows of Harvard College
* Copyright (c) 2012-2013 Massachusetts Institute of Technology
*
* 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, subject to the conditions
* listed in the Masstree LICENSE file. These conditions include: you must
* preserve this copyright notice, and you cannot mention the copyright
* holders in advertising related to the Software without their permission.
* The Software is provided WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED. This
* notice is a summary of the Masstree LICENSE file; the license in that file
* is legally binding.
*/
#include "kvthread.hh"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <new>
#include <sys/mman.h>
#if HAVE_SUPERPAGE && !NOSUPERPAGE
#include <sys/types.h>
#include <dirent.h>
#endif
threadinfo *threadinfo::allthreads;
pthread_key_t threadinfo::key;
#if HAVE_MEMDEBUG
void memdebug::landmark(char* buf, size_t size) const {
if (this->magic != magic_value && this->magic != magic_free_value)
snprintf(buf, size, "???");
else if (this->file)
snprintf(buf, size, "%s:%d", this->file, this->line);
else if (this->line)
snprintf(buf, size, "%d", this->line);
else
snprintf(buf, size, "0");
}
void
memdebug::hard_free_checks(const memdebug *m, size_t size, int freetype,
int after_rcu, const char *op) {
char buf[256];
m->landmark(buf, sizeof(buf));
if (m->magic == magic_free_value)
fprintf(stderr, "%s(%p): double free, was @%s\n",
op, m + 1, buf);
else if (m->magic != magic_value)
fprintf(stderr, "%s(%p): freeing unallocated pointer (%x)\n",
op, m + 1, m->magic);
assert(m->magic == magic_value);
if (freetype && m->freetype != freetype)
fprintf(stderr, "%s(%p): expected type %x, saw %x, "
"allocated %s\n", op, m + 1, freetype, m->freetype, buf);
if (!after_rcu && m->size != size)
fprintf(stderr, "%s(%p) @%d: expected size %lu, saw %lu, "
"allocated %s\n", op, m + 1,
(unsigned long) size, (unsigned long) m->size, buf);
if (m->after_rcu != after_rcu)
fprintf(stderr, "%s(%p) @%d: double free after rcu, allocated @%s\n",
op, m + 1, buf);
if (freetype)
assert(m->freetype == freetype);
if (!after_rcu)
assert(m->size == size);
assert(m->after_rcu == after_rcu);
}
void
memdebug::hard_assert_use(const void *ptr, memtag tag1, memtag tag2) {
const memdebug *m = reinterpret_cast<const memdebug *>(ptr) - 1;
char tagbuf[40], buf[256];
m->landmark(buf, sizeof(buf));
if (tag2 == (memtag) -1)
sprintf(buf, "%x", tag1);
else
sprintf(buf, "%x/%x", tag1, tag2);
if (m->magic == magic_free_value)
fprintf(stderr, "%p: use tag %s after free, allocated %s\n",
m + 1, tagbuf, buf);
else if (m->magic != magic_value)
fprintf(stderr, "%p: pointer is unallocated, not tag %s\n",
m + 1, tagbuf);
assert(m->magic == magic_value);
if (tag1 != 0 && (m->freetype >> 8) != tag1 && (m->freetype >> 8) != tag2)
fprintf(stderr, "%p: expected tag %s, got tag %x, allocated %s\n",
m + 1, tagbuf, m->freetype >> 8, buf);
if (tag1 != 0)
assert((m->freetype >> 8) == tag1 || (m->freetype >> 8) == tag2);
}
#endif
threadinfo *threadinfo::make(int purpose, int index)
{
threadinfo *ti = (threadinfo *) malloc(8192);
memset(ti, 0, sizeof(*ti));
ti->ti_next = allthreads;
ti->ti_purpose = purpose;
ti->ti_index = index;
ti->allthreads = ti;
ti->ts_ = 2;
void *limbo_space = ti->allocate(sizeof(limbo_group), memtag_limbo);
ti->mark(tc_limbo_slots, limbo_group::capacity);
ti->limbo_head_ = ti->limbo_tail_ = new(limbo_space) limbo_group;
return ti;
}
void threadinfo::refill_rcu()
{
if (limbo_head_ == limbo_tail_ && !limbo_tail_->next_
&& limbo_tail_->head_ == limbo_tail_->tail_)
limbo_tail_->head_ = limbo_tail_->tail_ = 0;
else if (!limbo_tail_->next_) {
void *limbo_space = allocate(sizeof(limbo_group), memtag_limbo);
mark(tc_limbo_slots, limbo_group::capacity);
limbo_tail_->next_ = new(limbo_space) limbo_group;
limbo_tail_ = limbo_tail_->next_;
} else
limbo_tail_ = limbo_tail_->next_;
}
void threadinfo::hard_rcu_quiesce()
{
uint64_t min_epoch = gc_epoch;
for (threadinfo *ti = allthreads; ti; ti = ti->ti_next) {
prefetch((const void *) ti->ti_next);
uint64_t ti_epoch = ti->gc_epoch;
if (ti_epoch && (int64_t) (ti_epoch - min_epoch) < 0)
min_epoch = ti_epoch;
}
limbo_group *lg = limbo_head_;
limbo_element *lb = &lg->e_[lg->head_];
limbo_element *le = &lg->e_[lg->tail_];
if (lb != le && (int64_t) (lb->epoch_ - min_epoch) < 0) {
while (1) {
free_rcu(lb->ptr_, lb->freetype_);
mark(tc_gc);
++lb;
if (lb == le && lg == limbo_tail_) {
lg->head_ = lg->tail_;
break;
} else if (lb == le) {
assert(lg->tail_ == lg->capacity && lg->next_);
lg->head_ = lg->tail_ = 0;
lg = lg->next_;
lb = &lg->e_[lg->head_];
le = &lg->e_[lg->tail_];
} else if (lb->epoch_ < min_epoch) {
lg->head_ = lb - lg->e_;
break;
}
}
if (lg != limbo_head_) {
// shift nodes in [limbo_head_, limbo_tail_) to be after
// limbo_tail_
limbo_group *old_head = limbo_head_;
limbo_head_ = lg;
limbo_group **last = &limbo_tail_->next_;
while (*last)
last = &(*last)->next_;
*last = old_head;
while (*last != lg)
last = &(*last)->next_;
*last = 0;
}
}
limbo_epoch_ = (lb == le ? 0 : lb->epoch_);
}
void threadinfo::report_rcu(void *ptr) const
{
for (limbo_group *lg = limbo_head_; lg; lg = lg->next_) {
int status = 0;
for (int i = 0; i < lg->capacity; ++i) {
if (i == lg->head_)
status = 1;
if (i == lg->tail_)
status = 0;
if (lg->e_[i].ptr_ == ptr)
fprintf(stderr, "thread %d: rcu %p@%d: %s as %x @%" PRIu64 "\n",
ti_index, lg, i, status ? "waiting" : "freed",
lg->e_[i].freetype_, lg->e_[i].epoch_);
}
}
}
void threadinfo::report_rcu_all(void *ptr)
{
for (threadinfo *ti = allthreads; ti; ti = ti->ti_next)
ti->report_rcu(ptr);
}
#if HAVE_SUPERPAGE && !NOSUPERPAGE
static size_t read_superpage_size() {
if (DIR* d = opendir("/sys/kernel/mm/hugepages")) {
size_t n = (size_t) -1;
while (struct dirent* de = readdir(d))
if (de->d_type == DT_DIR
&& strncmp(de->d_name, "hugepages-", 10) == 0
&& de->d_name[10] >= '0' && de->d_name[10] <= '9') {
size_t x = strtol(&de->d_name[10], 0, 10) << 10;
n = (x < n ? x : n);
}
closedir(d);
return n;
} else
return 2 << 20;
}
static size_t superpage_size = 0;
#endif
static void initialize_pool(void* pool, size_t sz, size_t unit) {
char* p = reinterpret_cast<char*>(pool);
char* pend = p + sz;
char** nextptr = reinterpret_cast<char**>(p);
while (p + unit <= pend) {
p += unit;
*nextptr = p;
nextptr = reinterpret_cast<char**>(p);
}
*nextptr = 0;
}
void threadinfo::refill_pool(int nl) {
assert(!pool_[nl - 1]);
void* pool = 0;
size_t pool_size = 0;
int r;
#if HAVE_SUPERPAGE && !NOSUPERPAGE
if (!superpage_size)
superpage_size = read_superpage_size();
if (superpage_size != (size_t) -1) {
pool_size = superpage_size;
# if MADV_HUGEPAGE
if ((r = posix_memalign(&pool, pool_size, pool_size)) != 0) {
fprintf(stderr, "posix_memalign superpage: %s\n", strerror(r));
pool = 0;
superpage_size = (size_t) -1;
} else if (madvise(pool, pool_size, MADV_HUGEPAGE) != 0) {
perror("madvise superpage");
superpage_size = (size_t) -1;
}
# elif MAP_HUGETLB
pool = mmap(0, pool_size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB, -1, 0);
if (pool == MAP_FAILED) {
perror("mmap superpage");
pool = 0;
superpage_size = (size_t) -1;
}
# else
superpage_size = (size_t) -1;
# endif
}
#endif
if (!pool) {
pool_size = 2 << 20;
if ((r = posix_memalign(&pool, CACHE_LINE_SIZE, pool_size)) != 0) {
fprintf(stderr, "posix_memalign: %s\n", strerror(r));
abort();
}
}
initialize_pool(pool, pool_size, nl * CACHE_LINE_SIZE);
pool_[nl - 1] = pool;
}
| [
"dingd2015@sjtu.edu.cn"
] | dingd2015@sjtu.edu.cn |
8e5dd112b6e4dda579205dd1bd26b8c6bf50d95f | 6b2a8dd202fdce77c971c412717e305e1caaac51 | /solutions_5631572862566400_0/C++/YanLiu/1A3.cpp | 02b9a779c0b0d124cae8dcb06e433fe2ca3a89aa | [] | no_license | alexandraback/datacollection | 0bc67a9ace00abbc843f4912562f3a064992e0e9 | 076a7bc7693f3abf07bfdbdac838cb4ef65ccfcf | refs/heads/master | 2021-01-24T18:27:24.417992 | 2017-05-23T09:23:38 | 2017-05-23T09:23:38 | 84,313,442 | 2 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 3,481 | cpp | #include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <vector>
using namespace std;
int main() {
ifstream input;
ofstream output;
input.open("./Downloads/C-small-attempt0.in");
output.open("result20160203");
unsigned T;
input >> T;
for (unsigned t = 0; t < T; t ++) {
unsigned N;
input >> N;
vector<int> map(N + 1, 0);
for (int i = 0; i < N; i ++) {
input >> map[i + 1];
}
int result = 0;
vector<int> s_mark(N + 1, 1);
vector<int> c_len(N + 1, 0);
for (int i = 1; i <= N; i ++) {
s_mark[map[i]] = 0;
if (c_len[i] == 0 && map[map[i]] == i) {
c_len[i] = 2;
c_len[map[i]] = 2;
}
}
for (int i = 1; i <= N; i ++) {
vector<int> mark(N + 1, 0);
int start = i;
int temp_res = 0;
while(mark[start] != 1) {
temp_res ++;
mark[start] = 1;
start = map[start];
}
if (start != i && start != map[map[start]]) {
continue;
}
if (start == map[map[start]] && s_mark[i] == 1) {
int left_t = 0;
for (int t = 0; t <= N; t ++) {
if (s_mark[t] == 1 && mark[t] == 0) {
vector<int> t_mark(N + 1, 0);
int n_start = t;
int new_temp = 0;
while(t_mark[n_start] != 1 && mark[n_start] != 1) {
t_mark[n_start] = 1;
n_start = map[n_start];
new_temp ++;
}
if (mark[n_start] == 1 && n_start == map[start] && new_temp > left_t) {
left_t = new_temp;
}
}
}
temp_res = temp_res + left_t;
if (c_len[start] < temp_res) {
c_len[start] = temp_res;
c_len[map[start]] = temp_res;
}
}
if (temp_res > result) {
result = temp_res;
}
}
int ac = 0;
for (int i = 1; i <= N; i ++) {
ac += c_len[i];
}
ac = ac / 2;
if (ac > result) {
result = ac;
}
output << "Case #" << t + 1 << ": " << result << endl;
}
return 0;
}
| [
"alexandra1.back@gmail.com"
] | alexandra1.back@gmail.com |
99a2f48694644c4b6858ceac885198f781cb115d | 454ea8966ef8c7b102c9419eb1f9107408c11c3a | /src/Test/Test.cpp | abe15e57415c059086eb163575fcd08d0468cc32 | [
"MIT"
] | permissive | i-saint/SmallFBX | 08bef8afd5cf6dc9519d1651c523953872fe355c | 5c969ac0a7a81af6054f2e0aacaf2b3642ba097d | refs/heads/master | 2023-07-08T08:35:52.145397 | 2021-08-10T02:07:43 | 2021-08-10T02:07:43 | 346,353,750 | 46 | 8 | MIT | 2021-08-10T02:07:43 | 2021-03-10T12:46:14 | C++ | UTF-8 | C++ | false | false | 4,382 | cpp | #include "pch.h"
#include "Test.h"
namespace test {
nanosec Now()
{
using namespace std::chrono;
return duration_cast<nanoseconds>(steady_clock::now().time_since_epoch()).count();
}
static std::string g_log;
std::string FormatImpl(const char* format, va_list args)
{
const int MaxBuf = 4096;
char buf[MaxBuf];
vsprintf(buf, format, args);
return buf;
}
std::string Format(const char* format, ...)
{
std::string ret;
va_list args;
va_start(args, format);
ret = FormatImpl(format, args);
va_end(args);
fflush(stdout);
return ret;
}
void PrintImpl(const char *format, ...)
{
va_list args;
va_start(args, format);
auto txt = FormatImpl(format, args);
g_log += txt;
#ifdef _WIN32
::OutputDebugStringA(txt.c_str());
#endif
printf("%s", txt.c_str());
va_end(args);
fflush(stdout);
}
void PutsImpl(const char* s)
{
#ifdef _WIN32
::OutputDebugStringA(s);
#endif
printf(s);
}
struct ArgEntry
{
std::string name;
std::string value;
template<class T> bool getValue(T& dst) const;
};
template<> bool ArgEntry::getValue(std::string& dst) const
{
dst = value;
return true;
}
template<> bool ArgEntry::getValue(bool& dst) const
{
if (value == "true" || std::atoi(value.c_str()) != 0) {
dst = true;
return true;
}
else if (value == "false" || value == "0") {
dst = false;
return true;
}
return false;
}
template<> bool ArgEntry::getValue(int& dst) const
{
dst = std::atoi(value.c_str());
return dst != 0;
}
template<> bool ArgEntry::getValue(float& dst) const
{
dst = (float)std::atof(value.c_str());
return dst != 0.0f;
}
static std::vector<ArgEntry>& GetArgs()
{
static std::vector<ArgEntry> s_instance;
return s_instance;
}
template<class T> bool GetArg(const char *name, T& dst)
{
auto& args = GetArgs();
auto it = std::find_if(args.begin(), args.end(), [name](auto& e) { return e.name == name; });
if (it != args.end())
return it->getValue(dst);
return false;
}
template bool GetArg(const char *name, std::string& dst);
template bool GetArg(const char* name, bool& dst);
template bool GetArg(const char* name, int& dst);
template bool GetArg(const char *name, float& dst);
struct TestInitializer
{
std::function<void()> initializer;
std::function<void()> finalizer;
};
struct TestEntry
{
std::string name;
std::function<void()> body;
};
static std::vector<TestInitializer>& GetInitializers()
{
static std::vector<TestInitializer> s_instance;
return s_instance;
}
static std::vector<TestEntry>& GetTests()
{
static std::vector<TestEntry> s_instance;
return s_instance;
}
void RegisterInitializer(const std::function<void()>& init, const std::function<void()>& fini)
{
GetInitializers().push_back({ init, fini });
}
void RegisterTestCaseImpl(const char *name, const std::function<void()>& body)
{
GetTests().push_back({name, body});
}
static void RunTestImpl(const TestEntry& v)
{
testPrint("%s begin\n", v.name.c_str());
auto begin = Now();
try {
v.body();
}
catch (const std::runtime_error& e) {
testPrint("*** failed: %s ***\n", e.what());
}
auto end = Now();
testPrint("%s end (%.2fms)\n\n", v.name.c_str(), NS2MS(end - begin));
}
} // namespace test
testExport const char* GetLogMessage()
{
return test::g_log.c_str();
}
testExport void RunTest(char *name)
{
test::g_log.clear();
for (auto& entry : test::GetTests()) {
if (entry.name == name) {
test::RunTestImpl(entry);
}
}
}
testExport void RunAllTests()
{
test::g_log.clear();
for (auto& entry : test::GetTests()) {
test::RunTestImpl(entry);
}
}
int main(int argc, char *argv[])
{
for (auto& i : test::GetInitializers())
i.initializer();
int run_count = 0;
for (int i = 1; i < argc; ++i) {
if (char *sep = std::strstr(argv[i], "=")) {
test::GetArgs().push_back({ std::string(argv[i], sep), std::string(sep + 1) });
}
}
for (int i = 1; i < argc; ++i) {
if (!std::strstr(argv[i], "=")) {
RunTest(argv[i]);
++run_count;
}
}
if (run_count == 0) {
RunAllTests();
}
for (auto& i : test::GetInitializers())
i.finalizer();
}
| [
"saint.skr@gmail.com"
] | saint.skr@gmail.com |
3eac1409aecb63e95c4c6c1c232123d63d341e73 | f1bd4d38d8a279163f472784c1ead12920b70be2 | /TestBed/Occlusion/_vector3d.h | 4eb4b797b0339767ea832a38e3ad1282560b1536 | [] | no_license | YURSHAT/stk_2005 | 49613f4e4a9488ae5e3fd99d2b60fd9c6aca2c83 | b68bbf136688d57740fd9779423459ef5cbfbdbb | refs/heads/master | 2023-04-05T16:08:44.658227 | 2021-04-18T09:08:18 | 2021-04-18T18:35:59 | 361,129,668 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,659 | h | #ifndef __V3D__
#define __V3D__
// Inline call
#ifndef IC
#define IC __forceinline
#endif
template <class T>
struct _vector {
public:
typedef T TYPE;
typedef _vector<T> Self;
typedef Self& SelfRef;
typedef const Self& SelfCRef;
public:
T x,y,z;
// access operators
IC T& operator[] (int i) { return *((T*)this + i); }
IC T& operator[] (int i) const { return *((T*)this + i); }
IC void set(T _x, T _y, T _z) { x = _x; y = _y; z = _z; };
IC void set(const _vector<float> &v) { x = T(v.x); y = T(v.y); z = T(v.z); };
IC void set(const _vector<double> &v) { x = T(v.x); y = T(v.y); z = T(v.z); };
IC void set(float* p) { x = p[0]; y = p[1]; z = p[2]; };
IC void set(double* p) { x = p[0]; y = p[1]; z = p[2]; };
IC void add(const Self &v) { x+=v.x; y+=v.y; z+=v.z; };
IC void add(T s) { x+=s; y+=s; z+=s; };
IC void add(const Self &a, const Self &v) { x=a.x+v.x;y=a.y+v.y; z=a.z+v.z; };
IC void add(const Self &a, T s) { x=a.x+s; y=a.y+s; z=a.z+s; };
IC void sub(const Self &v) { x-=v.x; y-=v.y; z-=v.z; };
IC void sub(T s) { x-=s; y-=s; z-=s; };
IC void sub(const Self &a, const Self &v) { x=a.x-v.x;y=a.y-v.y; z=a.z-v.z; };
IC void sub(const Self &a, T s) { x=a.x-s; y=a.y-s; z=a.z-s; };
IC void mul(const Self &v) { x*=v.x; y*=v.y; z*=v.z; };
IC void mul(T s) { x*=s; y*=s; z*=s; };
IC void mul(const Self &a, const Self &v) { x=a.x*v.x;y=a.y*v.y; z=a.z*v.z; };
IC void mul(const Self &a, T s) { x=a.x*s; y=a.y*s; z=a.z*s; };
IC void div(const Self &v) { x/=v.x; y/=v.y; z/=v.z; };
IC void div(T s) { x/=s; y/=s; z/=s; };
IC void div(const Self &a, const Self &v) { x=a.x/v.x;y=a.y/v.y; z=a.z/v.z; };
IC void div(const Self &a, T s) { x=a.x/s; y=a.y/s; z=a.z/s; };
IC void invert() { x=-x; y=-y; z=-z; }
IC void invert(const Self &a) { x=-a.x; y=-a.y; z=-a.z; }
IC void min(const Self &v1,const Self &v2) { x = _min(v1.x,v2.x); y = _min(v1.y,v2.y); z = _min(v1.z,v2.z); }
IC void min(const Self &v) { x = _min(x,v.x); y = _min(y,v.y); z = _min(z,v.z); }
IC void max(const Self &v1,const Self &v2) { x = _max(v1.x,v2.x); y = _max(v1.y,v2.y); z = _max(v1.z,v2.v.z); }
IC void max(const Self &v) { x = _max(x,v.x); y = _max(y,v.y); z = _max(z,v.z); }
IC void abs(const Self &v) { x = _abs(v.x); y=_abs(v.y); z=_abs(v.z); }
IC BOOL similar(const Self &v, T E=EPS_L) const { return _abs(x-v.x)<E && _abs(y-v.y)<E && _abs(z-v.z)<E;};
IC void set_length(T l){
mul(l/magnitude());
}
// Align vector3 by axis (!y)
IC void align() {
y = 0;
if (_abs(z)>=_abs(x)) { z /= _abs(z?z:1); x = 0; }
else { x /= _abs(x); z = 0; }
}
// Squeeze
IC void squeeze(T Epsilon){
if (_abs(x) < Epsilon) x = 0;
if (_abs(y) < Epsilon) y = 0;
if (_abs(z) < Epsilon) z = 0;
}
// Clamp vector3
IC void clamp(const Self &min, const Self max) {
::clamp(x,min.x,max.x);
::clamp(y,min.y,max.y);
::clamp(z,min.z,max.z);
}
IC void clamp(const Self &_v) {
Self v; v.x = _abs(_v.x); v.y = _abs(_v.y); v.z = _abs(_v.z);
::clamp(x,-v.x,v.x);
::clamp(y,-v.y,v.y);
::clamp(z,-v.z,v.z);
}
// Interpolate vectors (inertion)
IC void inertion(const Self &p, T v) {
T inv = 1.f-v;
x = v*x + inv*p.x;
y = v*y + inv*p.y;
z = v*z + inv*p.z;
}
IC void average(const Self &p) {
x = (x+p.x)*0.5f;
y = (y+p.y)*0.5f;
z = (z+p.z)*0.5f;
}
IC void average(const Self &p1, const Self &p2) {
x = (p1.x+p2.x)*0.5f;
y = (p1.y+p2.y)*0.5f;
z = (p1.z+p2.z)*0.5f;
}
IC void lerp(const Self &p1, const Self &p2, T t ){
T invt = 1.f-t;
x = p1.x*invt + p2.x*t;
y = p1.y*invt + p2.y*t;
z = p1.z*invt + p2.z*t;
}
// Direct vector3 from point P by dir D with length M
IC void mad(const Self &d, T m) {
x += d.x*m;
y += d.y*m;
z += d.z*m;
}
IC void mad(const Self &p, const Self &d, T m) {
x = p.x + d.x*m;
y = p.y + d.y*m;
z = p.z + d.z*m;
}
IC void mad(const Self& d, const Self& s) {
x += d.x*s.x;
y += d.y*s.y;
z += d.z*s.z;
}
IC void mad(const Self &p, const Self &d, const Self &s) {
x = p.x + d.x*s.x;
y = p.y + d.y*s.y;
z = p.z + d.z*s.z;
}
// SQ magnitude
IC T square_magnitude(void) const {
return x*x + y*y + z*z;
}
// magnitude
IC T magnitude(void) const {
return _sqrt(square_magnitude());
}
// Normalize
IC void normalize(void) {
VERIFY(square_magnitude() > std::numeric_limits<T>::min());
T mag=_sqrt(1/(x*x + y*y + z*z));
x *= mag;
y *= mag;
z *= mag;
}
// Safe-Normalize
IC void normalize_safe(void) {
T magnitude=x*x + y*y + z*z;
if (magnitude> std::numeric_limits<T>::min()) {
magnitude=sqrtf(1/magnitude);
x *= magnitude;
y *= magnitude;
z *= magnitude;
}
}
// Normalize
IC void normalize(const Self &v) {
VERIFY((v.x*v.x+v.y*v.y+v.z*v.z)>flt_zero);
T mag=_sqrt(1/(v.x*v.x + v.y*v.y + v.z*v.z));
x = v.x*mag;
y = v.y*mag;
z = v.z*mag;
}
// Safe-Normalize
IC void normalize_safe(const Self &v) {
T magnitude=v.x*v.x + v.y*v.y + v.z*v.z;
if (magnitude>std::numeric_limits<T>::min()) {
magnitude=_sqrt(1/magnitude);
x = v.x*magnitude;
y = v.y*magnitude;
z = v.z*magnitude;
}
}
IC void random_dir (CRandom& R = ::Random)
{
z = R.randF(-1,1);
T a = R.randF(PI_MUL_2);
T r = _sqrt(1-z*z);
T sa,ca; _sincos(a,sa,ca);
x = r * ca;
y = r * sa;
};
IC void random_dir (const Self& ConeAxis, float ConeAngle, CRandom& R = ::Random)
{
Self rnd;
rnd.random_dir (R);
mad (ConeAxis,rnd,R.randF(tanf(ConeAngle)));
normalize ();
}
IC void random_point (const Self& BoxSize, CRandom& R = ::Random)
{
x = R.randFs(BoxSize.x);
y = R.randFs(BoxSize.y);
z = R.randFs(BoxSize.z);
}
IC void random_point (T r, CRandom& R = ::Random)
{
random_dir (R);
mul (R.randF(r));
}
// DotProduct
IC T dotproduct(const Self &v) const // v1*v2
{ return x*v.x + y*v.y + z*v.z; }
// CrossProduct
IC void crossproduct(const Self &v1, const Self &v2) // (v1,v2) -> this
{
x = v1.y * v2.z - v1.z * v2.y ;
y = v1.z * v2.x - v1.x * v2.z ;
z = v1.x * v2.y - v1.y * v2.x ;
}
// Distance calculation
IC T distance_to_xz(const Self &v) const
{ return _sqrt( (x-v.x)*(x-v.x) + (z-v.z)*(z-v.z) ); }
// Distance calculation
IC T distance_to_sqr(const Self &v) const
{ return (x-v.x)*(x-v.x) + (y-v.y)*(y-v.y) + (z-v.z)*(z-v.z); }
// Distance calculation
IC T distance_to(const Self &v) const
{ return _sqrt(distance_to_sqr(v)); }
// Barycentric coords
IC void from_bary (const Self &V1, const Self &V2, const Self &V3, T u, T v, T w)
{
x = V1.x*u + V2.x*v + V3.x*w;
y = V1.y*u + V2.y*v + V3.y*w;
z = V1.z*u + V2.z*v + V3.z*w;
}
IC void from_bary (const Self &V1, const Self &V2, const Self &V3, const Self &B)
{ from_bary(V1,V2,V3,B.x,B.y,B.z); }
IC void from_bary4 (const Self &V1, const Self &V2, const Self &V3, const Self &V4, T u, T v, T w, T t)
{
x = V1.x*u + V2.x*v + V3.x*w + V4.x*t;
y = V1.y*u + V2.y*v + V3.y*w + V4.y*t;
z = V1.z*u + V2.z*v + V3.z*w + V4.z*t;
}
IC void mknormal_non_normalized (const Self &p0, const Self & p1, const Self &p2 )
{
_vector v01,v12;
v01.sub( p1, p0 );
v12.sub( p2, p1 );
crossproduct( v01, v12 );
};
IC void mknormal( const Self &p0, const Self &p1, const Self &p2 )
{
mknormal_non_normalized(p0,p1,p2);
normalize_safe();
};
IC void setHP (T h, T p)
{
T _ch, _cp, _sh, _sp;
_sincos(h,_sh,_ch);
_sincos(p,_sp,_cp);
x = -_cp*_sh;
y = _sp;
z = _cp*_ch;
}
IC void getHP (T& h, T& p) const
{
float hyp;
if (fis_zero(x)&& fis_zero(z)){
h = 0.0f;
if (!fis_zero(float(y))) p = (y>0.0f)?PI_DIV_2:-PI_DIV_2;
else p = 0.0f;
}else{
if (fis_zero(z)) h = (x>0.0f)?-PI_DIV_2:PI_DIV_2;
else if (z<0.0f) h = -(atanf(x/z)-PI);
else h = -atanf(x/z);
hyp = _sqrt(x*x+z*z);
if (fis_zero(float(hyp))) p = (y>0.0f)?PI_DIV_2:-PI_DIV_2;
else p = atanf(y/hyp);
}
}
IC void reflect(const Self& dir, const Self& norm){
mad(dir,norm,-2*dir.dotproduct(norm));
}
IC void slide(const Self& dir, const Self& norm){ // non normalized
mad(dir,norm,-dir.dotproduct(norm));
}
};
typedef _vector<float> Fvector;
typedef _vector<float> Fvector3;
typedef _vector<double> Dvector;
typedef _vector<double> Dvector3;
typedef _vector<s32> Ivector;
typedef _vector<s32> Ivector3;
#endif
| [
"loxotron@bk.ru"
] | loxotron@bk.ru |
c6ec8fa4e06436ce59e824782c125183e9dee555 | 5c87811a523d0b9e1ab968a3dcddf58af875fa84 | /engine/enginecode/src/platform/OpenGL/OpenGLIndexBuffer.cpp | 1da07ae44cb415e460fbf1720611abd1f01d5588 | [] | no_license | tinitis0/Game-Engine-Architecture | d548e314e0e37b7753227f457cdd10c0d8d65deb | 30339088ad7ac0c08acef4cb1fa6347bd5c9d06f | refs/heads/main | 2023-06-21T04:04:38.806144 | 2021-07-21T21:55:55 | 2021-07-21T21:55:55 | 388,253,458 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 675 | cpp | /*! \file OpenGLIndexBuffer.cpp */
#include "engine_pch.h"
#include <glad/glad.h>
#include "platform/OpenGL/OpenGLIndexBuffer.h"
namespace Engine
{
OpenGLIndexBuffer::OpenGLIndexBuffer(uint32_t * indices, uint32_t count) : m_count(count)
{
glCreateBuffers(1, &m_OpenGL_ID); //!< creates index buffer
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_OpenGL_ID); //!< binds the index buffer
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t) * count, indices, GL_STATIC_DRAW); //!< gets the index buffer data
}//!< OpenGL index buffers
OpenGLIndexBuffer::~OpenGLIndexBuffer()
{
glDeleteBuffers(1, &m_OpenGL_ID); //!< deletes the index buffer
} //!< deconstructor
} | [
"tinstirums@gmail.com"
] | tinstirums@gmail.com |
0bbee6f016299a93338e8b3b7f57c8138464b1f0 | 69e2ab49ab9942296f97f2aef73f20ec56171f30 | /253A.cpp | 41cf9abe420d8559d420b47b37d287f9ad3b463a | [] | no_license | hllj/Codeforces | f2957d8caa97e35772aa2f98ed84373a2fe11908 | 15b6c4a68168a7b5ec97c4056637587ca40e9f3e | refs/heads/master | 2020-03-28T10:55:23.523528 | 2019-11-02T16:00:49 | 2019-11-02T16:00:49 | 148,159,509 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 779 | cpp | #define _CRT_SECURE_NO_WARNINGS
#include <bits/stdc++.h>
using namespace std;
#define IO ios::sync_with_stdio(false); cin.tie(0);
#define all(v) (v).begin(), (v).end()
#define fi first
#define se second
typedef long long ll;
typedef pair<int, int> ii;
typedef pair<ll, int> li;
const int INF = (int) 1e9;
const ll LINF = (ll) 1e18;
int main() {
IO;
int n, m;
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
cin >> n >> m;
if (n >= m) {
for (int i = 1; i <= m; i++)
cout << "BG";
for (int i = 1; i <= n - m; i++)
cout << "B";
}
else {
for (int i = 1; i <= n; i++)
cout << "GB";
for (int i = 1; i <= m - n; i++)
cout << "G";
}
return 0;
}
| [
"vanhop3499@gmail.com"
] | vanhop3499@gmail.com |
f1209c0d997a0c5a70a4909fbe9ba7ee960ac067 | 78c90ea0138c86270d4698b77224b6d917d3b86d | /OptixScripts/tutorial.h | 4c20f1141959809939ed91bdf9dc36b5656a3e9b | [] | no_license | HungryBear/OptixCore | 74f54c959b4228d65daf4c62bb27e42ef9ea23dd | da3a7ff42745e4f2047f698a0eec5797ffe4b452 | refs/heads/master | 2022-12-11T06:08:37.780951 | 2021-01-04T14:57:48 | 2021-01-04T14:57:48 | 135,586,979 | 12 | 2 | null | 2022-12-07T18:41:27 | 2018-05-31T13:24:09 | C# | UTF-8 | C++ | false | false | 2,406 | h |
/*
* Copyright (c) 2008 - 2009 NVIDIA Corporation. All rights reserved.
*
* NVIDIA Corporation and its licensors retain all intellectual property and proprietary
* rights in and to this software, related documentation and any modifications thereto.
* Any use, reproduction, disclosure or distribution of this software and related
* documentation without an express license agreement from NVIDIA Corporation is strictly
* prohibited.
*
* TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED *AS IS*
* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS OR IMPLIED,
* INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS BE LIABLE FOR ANY
* SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT
* LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF
* BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
* INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGES
*/
#include <optix.h>
#include <optix_math.h>
// Used by all the tutorial cuda files
#include "commonStructs.h"
using namespace optix;
#define FLT_MAX 1e30;
__device__ __inline__ float3 exp( const float3& x )
{
return make_float3(exp(x.x), exp(x.y), exp(x.z));
}
__device__ __inline__ float step( float min, float value )
{
return value<min?0:1;
}
__device__ __inline__ float3 mix( float3 a, float3 b, float x )
{
return a*(1-x) + b*x;
}
__device__ __inline__ float3 schlick( float nDi, const float3& rgb )
{
float r = fresnel_schlick(nDi, 5, rgb.x, 1);
float g = fresnel_schlick(nDi, 5, rgb.y, 1);
float b = fresnel_schlick(nDi, 5, rgb.z, 1);
return make_float3(r, g, b);
}
__device__ __inline__ uchar4 make_color(const float3& c)
{
return make_uchar4( static_cast<unsigned char>(__saturatef(c.z)*255.99f), /* B */
static_cast<unsigned char>(__saturatef(c.y)*255.99f), /* G */
static_cast<unsigned char>(__saturatef(c.x)*255.99f), /* R */
255u); /* A */
}
struct PerRayData_radiance
{
float3 result;
float importance;
int depth;
};
struct PerRayData_shadow
{
float3 attenuation;
};
| [
"andrey.shegidevich@uptick.com"
] | andrey.shegidevich@uptick.com |
15a8f7bc29aaadd9de00130164b6f26a196dfb74 | 5ba6d92430f7eeb607b56159d764cc0f5f34be43 | /SharedPtr/test.cpp | b1587847725c63954ebaf44c235d81bc57a81333 | [] | no_license | liwooood/CppLang | 9e15ed21f78ea433d2f2b6a18c49fbea5cfeca0f | 8daf9e9075314a087ac45e27558eea83b5469184 | refs/heads/master | 2020-04-11T00:43:11.155347 | 2014-02-19T13:09:01 | 2014-02-19T13:09:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 554 | cpp | #include <memory>
#include <iostream>
class session
{
public:
~session()
{
std::cout << "~session\n";
}
void print()
{
}
};
void main()
{
std::shared_ptr<session> ses = std::make_shared<session>();
std::cout << "ses count = " << ses.use_count() << "\n";
auto two = ses;
std::cout << "ses count = " << ses.use_count() << "\n";
std::cout << "two count = " << two.use_count() << "\n";
auto& three = ses;
std::cout << "three count = " << three.use_count() << "\n";
ses.reset();
std::cout << "ses count = " << ses.use_count() << "\n";
} | [
"chenhf2010@qq.com"
] | chenhf2010@qq.com |
b8b7b66eaa5efb6dd7c9fa1440fea6720812f5d3 | b543703be27a6494e3664e2a5dcaeabe866b1a9a | /BattleTank/Source/BattleTank/TankPlayerController.h | c7c91f47ffc8a7b5e6b0b1e94a1274114dd1df81 | [] | no_license | SKulaGGin/BattleTank | 8651c7aa57c3e05da260e9ca8afe7776735d91a3 | d87443c70fcbcd0fbfb98fbc387f08842918d473 | refs/heads/main | 2023-03-23T19:12:03.706292 | 2021-03-21T20:39:51 | 2021-03-21T20:39:51 | 350,117,210 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,094 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/PlayerController.h"
#include "TankPlayerController.generated.h"
class ATank;
/**
*
*/
UCLASS()
class BATTLETANK_API ATankPlayerController : public APlayerController
{
GENERATED_BODY()
public:
virtual void BeginPlay() override;
virtual void Tick(float DeltaSeconds) override;
UPROPERTY(EditDefaultsOnly);
float CrosshairXLocation = 0.5;
UPROPERTY(EditDefaultsOnly);
float CrosshairYLocation = 0.3333;
UPROPERTY(EditDefaultsOnly)
float LineTraceRange = 1000000; // 10km
protected:
UFUNCTION(BlueprintCallable, Category = "Setup")
ATank* GetControlledTank() const;
private:
void AimTowardsCrosshair();
// Return an OUT parameter, true if hit landscape
bool GetSightRayHitLocation(FVector& OutHitLocation) const;
bool GetLookDirection(FVector2D ScreenLocation, FVector& LookDirection) const;
bool GetLookVectorHitLocation(const FVector& LookDirection, FVector& OutHitLocation) const;
};
| [
"sergeant.coolagin@gmail.com"
] | sergeant.coolagin@gmail.com |
2bf2246ebf8cbfd079de03c2ea38b19737f4bb07 | e02e0364cb8d7970f2b2ae5a9b580f70f55dd470 | /Texture.cpp | 0d9921277742c474d496dcdd17df152a8dd8b0ce | [] | no_license | MavethGH/Bad2DGameEngine | 958db370cceb26491ca22f18f66900d4c396dcd9 | dce928ea4478a2ffae58ab529a390168cfae0d45 | refs/heads/master | 2023-04-22T07:43:54.271856 | 2021-05-10T22:32:29 | 2021-05-10T22:32:29 | 361,264,252 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,679 | cpp | #include "Texture.h"
#include <SDL2/SDL_image.h>
Texture::Texture(const std::string& imageFilePath)
{
SDL_Surface* image = IMG_Load(imageFilePath.c_str());
init(image);
}
Texture::Texture(SDL_Surface* image)
{
init(image);
}
Texture::Texture(FT_Bitmap* image)
{
// Bitmap glyph image is tightly packed
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
// Create the OpenGL texture
glGenTextures(1, &id);
glBindTexture(GL_TEXTURE_2D, id);
// Using immutable texture storage, since it is recommended when not using mipmaps
glTexStorage2D(
GL_TEXTURE_2D,
1,
GL_RED,
image->width,
image->rows
);
glTexSubImage2D(
GL_TEXTURE_2D,
0,
0,
0,
image->width,
image->rows,
GL_RED,
GL_UNSIGNED_BYTE,
image->buffer
);
// Texture Params
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
void Texture::init(SDL_Surface* tex)
{
// Allow direct reading of the image pixels
SDL_LockSurface(tex);
// For convenience
w = tex->w;
h = tex->h;
// Flip image so OpenGL doesn't diplay it upside-down
flipSDLSurface(tex);
// Create the OpenGL texture from the loaded image
glGenTextures(1, &id);
glBindTexture(GL_TEXTURE_2D, id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0,
GL_RGBA, GL_UNSIGNED_BYTE, tex->pixels);
// Texture Params
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
// Mipmaps!
glGenerateMipmap(GL_TEXTURE_2D);
// Cleanup
SDL_UnlockSurface(tex);
}
// Note: surf is already locked when this is called
void Texture::flipSDLSurface(SDL_Surface* surf)
{
int pitch = surf->pitch;
char* temp = new char[pitch];
char* pixels = (char*)surf->pixels;
// Switch rows
for (int i = 0; i < h / 2; ++i)
{
char* top = pixels + i * pitch;
char* bot = pixels + (h - i - 1) * pitch;
// Top row to temp
memcpy(temp, top, pitch);
// Bottom row to top
memcpy(top, bot, pitch);
// Temp (top row) to bottom
memcpy(bot, temp, pitch);
}
// Don't leak!
delete[] temp;
}
| [
"65792235+MavethGH@users.noreply.github.com"
] | 65792235+MavethGH@users.noreply.github.com |
b58336efa2e25ad249170e0485e0f48bb8c4cd87 | 711e5c8b643dd2a93fbcbada982d7ad489fb0169 | /XPSP1/NT/printscan/faxsrv/src/admin/mmc/ppfaxserverinbox.cpp | 72b0b623664300253c2e770588fcb39bce1e40b3 | [] | no_license | aurantst/windows-XP-SP1 | 629a7763c082fd04d3b881e0d32a1cfbd523b5ce | d521b6360fcff4294ae6c5651c539f1b9a6cbb49 | refs/heads/master | 2023-03-21T01:08:39.870106 | 2020-09-28T08:10:11 | 2020-09-28T08:10:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 32,704 | cpp | /////////////////////////////////////////////////////////////////////////////
// FILE : ppFaxServerInbox.cpp //
// //
// DESCRIPTION : prop pages of Inbox archive //
// //
// AUTHOR : yossg //
// //
// HISTORY : //
// Oct 25 1999 yossg created //
// Nov 3 1999 yossg OnInitDialog, SetProps //
// Nov 15 1999 yossg Call RPC func //
// Nov 24 1999 yossg OnApply create call to all tabs from parent //
// Oct 17 2000 yossg //
// Dec 10 2000 yossg Update Windows XP //
// //
// Copyright (C) 1999 Microsoft Corporation All Rights Reserved //
// //
/////////////////////////////////////////////////////////////////////////////
#include "stdafx.h"
#include "MSFxsSnp.h"
#include "ppFaxServerInbox.h"
#include "FaxMMCGlobals.h"
#include "FaxServer.h"
#include "FaxServerNode.h"
#include "FxsValid.h"
#include "dlgutils.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
//
// Constructor
//
CppFaxServerInbox::CppFaxServerInbox(
LONG_PTR hNotificationHandle,
CSnapInItem *pNode,
BOOL fIsLocalServer,
HINSTANCE hInst)
: CPropertyPageExImpl<CppFaxServerInbox>(pNode, NULL)
{
m_pParentNode = static_cast <CFaxServerNode *> (pNode);
m_pFaxArchiveConfig = NULL;
m_fAllReadyToApply = FALSE;
m_fIsDialogInitiated = FALSE;
m_fIsDirty = FALSE;
m_fIsLocalServer = fIsLocalServer;
}
//
// Destructor
//
CppFaxServerInbox::~CppFaxServerInbox()
{
if (NULL != m_pFaxArchiveConfig)
{
FaxFreeBuffer( m_pFaxArchiveConfig );
}
}
/////////////////////////////////////////////////////////////////////////////
// CppFaxServerInbox message handlers
/*
- CppFaxServerInbox::InitRPC
-
* Purpose:
* Initiates the configuration structure from RPC get Call.
*
* Arguments:
*
* Return:
* OLE error code
*/
HRESULT CppFaxServerInbox::InitRPC( )
{
DEBUG_FUNCTION_NAME( _T("CppFaxServerInbox::InitRPC"));
HRESULT hRc = S_OK;
DWORD ec = ERROR_SUCCESS;
//
// get RPC Handle
//
if (!m_pFaxServer->GetFaxServerHandle())
{
ec= GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Failed to GetFaxServerHandle. (ec: %ld)"),
ec);
goto Error;
}
//
// Retrieve the fax Archive configuration
//
if (!FaxGetArchiveConfiguration(m_pFaxServer->GetFaxServerHandle(),
FAX_MESSAGE_FOLDER_INBOX,
&m_pFaxArchiveConfig))
{
ec = GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Fail to get inbox configuration. (ec: %ld)"),
ec);
if (IsNetworkError(ec))
{
DebugPrintEx(
DEBUG_ERR,
_T("Network Error was found. (ec: %ld)"),
ec);
m_pFaxServer->Disconnect();
}
goto Error;
}
//For max verification
ATLASSERT(m_pFaxArchiveConfig);
//
// Init specific members for set proprties follow-up
//
m_dwLastGoodSizeQuotaHighWatermark = m_pFaxArchiveConfig->dwSizeQuotaHighWatermark;
m_dwLastGoodSizeQuotaLowWatermark = m_pFaxArchiveConfig->dwSizeQuotaLowWatermark;
m_bstrLastGoodFolder = m_pFaxArchiveConfig->lpcstrFolder;
if (!m_bstrLastGoodFolder)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Failed to allocate string (m_bstrLastGoodFolder)."));
ec = ERROR_OUTOFMEMORY;
goto Error;
}
ATLASSERT(ERROR_SUCCESS == ec);
DebugPrintEx( DEBUG_MSG,
_T("Succeed to get inbox configuration."));
goto Exit;
Error:
ATLASSERT(ERROR_SUCCESS != ec);
hRc = HRESULT_FROM_WIN32(ec);
ATLASSERT(NULL != m_pParentNode);
m_pParentNode->NodeMsgBox(GetFaxServerErrorMsg(ec));
Exit:
return (hRc);
}
/*
- CppFaxServerInbox::OnInitDialog
-
* Purpose:
* Initiates all controls when dialog is called.
*
* Arguments:
*
* Return:
*
*/
LRESULT CppFaxServerInbox::OnInitDialog( UINT uiMsg, WPARAM wParam, LPARAM lParam, BOOL& fHandled )
{
DEBUG_FUNCTION_NAME( _T("CppFaxServerInbox::PageInitDialog"));
DWORD ec = ERROR_SUCCESS;
UNREFERENCED_PARAMETER( uiMsg );
UNREFERENCED_PARAMETER( wParam );
UNREFERENCED_PARAMETER( lParam );
UNREFERENCED_PARAMETER( fHandled );
int iLow,
iHigh,
iAgeLimit;
ATLASSERT(m_pFaxArchiveConfig);
//
// init controls
//
m_FolderBox.Attach(GetDlgItem(IDC_INBOX_FOLDER_EDIT));
m_FolderBox.SetLimitText(MAX_PATH-1);
m_HighWatermarkBox.Attach(GetDlgItem(IDC_HIGH_EDIT));
m_LowWatermarkBox.Attach(GetDlgItem(IDC_LOW_EDIT));
m_AutoDelBox.Attach(GetDlgItem(IDC_AUTODEL_EDIT));
m_HighWatermarkBox.SetLimitText(FXS_QUOTA_LENGTH);
m_LowWatermarkBox.SetLimitText(FXS_QUOTA_LENGTH);
m_AutoDelBox.SetLimitText(FXS_DIRTYDAYS_LENGTH);
m_HighWatermarkSpin.Attach(GetDlgItem(IDC_HIGH_SPIN));
m_LowWatermarkSpin.Attach(GetDlgItem(IDC_LOW_SPIN));
m_AutoDelSpin.Attach(GetDlgItem(IDC_AUTODEL_SPIN));
//
// FOLDER_EDIT
//
m_FolderBox.SetWindowText(m_pFaxArchiveConfig->lpcstrFolder);
//
// Disable Browse button for remote admin
//
if (!m_fIsLocalServer)
{
::EnableWindow(GetDlgItem(IDC_INBOX_BROWSE_BUTTON), FALSE);
}
//
// TO_ARCHIVE_CHECK
//
if (m_pFaxArchiveConfig->bUseArchive)
{
CheckDlgButton(IDC_TO_ARCHIVE_CHECK, BST_CHECKED) ;
}
else
{
CheckDlgButton(IDC_TO_ARCHIVE_CHECK, BST_UNCHECKED) ;
::EnableWindow(GetDlgItem(IDC_INBOX_FOLDER_EDIT), FALSE);
::EnableWindow(GetDlgItem(IDC_INBOX_BROWSE_BUTTON), FALSE);
}
//
// Quota size - Low
//
iLow = (int)m_pFaxArchiveConfig->dwSizeQuotaLowWatermark;
m_LowWatermarkSpin.SetRange(FXS_QUOTA_LOW_LOWER, FXS_QUOTA_LOW_UPPER);
m_LowWatermarkSpin.SetPos(iLow);
//
// Quota size - High
//
iHigh = (int)m_pFaxArchiveConfig->dwSizeQuotaHighWatermark;
m_HighWatermarkSpin.SetRange(FXS_QUOTA_HIGH_LOWER, FXS_QUOTA_HIGH_UPPER);
m_HighWatermarkSpin.SetPos(iHigh);// Set Position
//
//Generate event log warning
//
if (m_pFaxArchiveConfig->bSizeQuotaWarning)
{
CheckDlgButton(IDC_GENERATE_WARNING_CHECK, BST_CHECKED) ;
}
else
{
CheckDlgButton(IDC_GENERATE_WARNING_CHECK, BST_UNCHECKED) ;
::EnableWindow(GetDlgItem(IDC_HIGH_EDIT), FALSE);
::EnableWindow(GetDlgItem(IDC_HIGH_SPIN), FALSE);
::EnableWindow(GetDlgItem(IDC_LOW_EDIT), FALSE);
::EnableWindow(GetDlgItem(IDC_LOW_SPIN), FALSE);
}
//
// message life-time (dirty days)
//
iAgeLimit = (int)m_pFaxArchiveConfig->dwAgeLimit;
m_AutoDelSpin.SetRange(FXS_DIRTYDAYS_LOWER, FXS_DIRTYDAYS_UPPER);
m_AutoDelSpin.SetPos(iAgeLimit);
//
// Auto Delete
//
if (FXS_DIRTYDAYS_ZERO == iAgeLimit)
{
CheckDlgButton(IDC_AUTODEL_CHECK, BST_UNCHECKED);
::EnableWindow(GetDlgItem(IDC_AUTODEL_EDIT), FALSE);
::EnableWindow(GetDlgItem(IDC_AUTODEL_SPIN), FALSE);
}
else
{
CheckDlgButton(IDC_AUTODEL_CHECK, BST_CHECKED);
}
m_fIsDialogInitiated = TRUE;
return (1);
}
/*
- CppFaxServerInbox::SetProps
-
* Purpose:
* Sets properties on apply.
*
* Arguments:
* pCtrlFocus - focus pointer (int)
*
* Return:
* OLE error code
*/
HRESULT CppFaxServerInbox::SetProps(int *pCtrlFocus, UINT * puIds)
{
DEBUG_FUNCTION_NAME( _T("CppFaxServerInbox::SetProps"));
HRESULT hRc = S_OK;
DWORD ec = ERROR_SUCCESS;
HINSTANCE hInst = _Module.GetResourceInstance();
CComBSTR bstrFolder = L"";
BOOL fSkipMessage = FALSE;
FAX_ARCHIVE_CONFIG FaxArchiveConfig;
ATLASSERT(TRUE == m_fAllReadyToApply);
m_fAllReadyToApply = FALSE;
//
// Collect all data and init the structure's fields
// uses Copy() to copy and also allocate before
//
ZeroMemory (&FaxArchiveConfig, sizeof(FAX_ARCHIVE_CONFIG));
//
// Size of struct.
//
FaxArchiveConfig.dwSizeOfStruct = sizeof(FAX_ARCHIVE_CONFIG);
//
// IDC_TO_ARCHIVE_CHECK
//
if (IsDlgButtonChecked(IDC_TO_ARCHIVE_CHECK) == BST_CHECKED)
{
FaxArchiveConfig.bUseArchive = TRUE;
//IDC_INBOX_FOLDER_EDIT
if ( !m_FolderBox.GetWindowText(&bstrFolder))
{
*pCtrlFocus = IDC_INBOX_FOLDER_EDIT;
DebugPrintEx(
DEBUG_ERR,
TEXT("Failed to GetWindowText(&bstrFolder)"));
ec = ERROR_OUTOFMEMORY;
goto Error;
}
if (!IsNotEmptyString(bstrFolder))
{
*pCtrlFocus = IDC_INBOX_FOLDER_EDIT;
*puIds = IDS_INBOX_ARCHIVE_PATH_EMPTY;
DebugPrintEx( DEBUG_ERR,
_T("Archive path string is empty or includes spaces only."));
fSkipMessage = TRUE;
ec = ERROR_INVALID_DATA;
goto Error;
}
FaxArchiveConfig.lpcstrFolder = bstrFolder;
//
// follow-up for an OnApply following submition
// with unchecked IDC_TO_ARCHIVE_CHECK
//
m_bstrLastGoodFolder = bstrFolder;
if (!m_bstrLastGoodFolder)
{
*pCtrlFocus = IDC_INBOX_FOLDER_EDIT;
DebugPrintEx(
DEBUG_ERR,
TEXT("Failed to allocate string (m_bstrLastGoodFolder)."));
ec = ERROR_OUTOFMEMORY;
goto Error;
}
}
else
{
FaxArchiveConfig.bUseArchive = FALSE;
FaxArchiveConfig.lpcstrFolder = m_bstrLastGoodFolder;
}
//
// IDC_GENERATE_WARNING_CHECK
//
if (IsDlgButtonChecked(IDC_GENERATE_WARNING_CHECK) == BST_CHECKED)
{
FaxArchiveConfig.bSizeQuotaWarning = TRUE;
int iHigh = m_HighWatermarkSpin.GetPos();
FaxArchiveConfig.dwSizeQuotaHighWatermark = (DWORD) iHigh;
int iLow = m_LowWatermarkSpin.GetPos();
FaxArchiveConfig.dwSizeQuotaLowWatermark = (DWORD) iLow;
if (iHigh <= iLow)
{
*pCtrlFocus = IDC_SENT_HIGH_EDIT;
*puIds = IDS_INBOX_WATERMARK_HI_LOW;
DebugPrintEx( DEBUG_ERR,
_T("Watermark High < Low."));
fSkipMessage = TRUE;
ec = ERROR_INVALID_DATA;
goto Error;
}
//
// follow-up for an OnApply following submition
// with unchecked IDC_SENT_GENERATE_WARNING_CHECK
//
m_dwLastGoodSizeQuotaHighWatermark = (DWORD)iHigh;
m_dwLastGoodSizeQuotaLowWatermark = (DWORD)iLow;
}
else
{
FaxArchiveConfig.bSizeQuotaWarning = FALSE;
FaxArchiveConfig.dwSizeQuotaHighWatermark = m_dwLastGoodSizeQuotaHighWatermark;
FaxArchiveConfig.dwSizeQuotaLowWatermark = m_dwLastGoodSizeQuotaLowWatermark;
}
//
// IDC_AUTODEL_CHECK - AutoDelete Messages
//
if (IsDlgButtonChecked(IDC_AUTODEL_CHECK) == BST_CHECKED)
{
int iAgeLimit = m_AutoDelSpin.GetPos();
FaxArchiveConfig.dwAgeLimit = (DWORD) iAgeLimit;
}
else
{
FaxArchiveConfig.dwAgeLimit = (DWORD)FXS_DIRTYDAYS_ZERO;
}
//
// get RPC Handle
//
if (!m_pFaxServer->GetFaxServerHandle())
{
ec= GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Failed to GetFaxServerHandle. (ec: %ld)"),
ec);
goto Error;
}
//
// Set Config
//
if (!FaxSetArchiveConfiguration(
m_pFaxServer->GetFaxServerHandle(),
FAX_MESSAGE_FOLDER_INBOX,
&FaxArchiveConfig))
{
ec = GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Fail to Set inbox configuration. (ec: %ld)"),
ec);
DWORD dwIDS = 0;
switch (ec)
{
case ERROR_PATH_NOT_FOUND:
DebugPrintEx( DEBUG_ERR, _T("ERROR_PATH_NOT_FOUND == ec"));
dwIDS = IDS_INBOX_ERROR_PATH_NOT_FOUND;
break;
case ERROR_DISK_FULL:
DebugPrintEx( DEBUG_ERR, _T("ERROR_DISK_FULL == ec"));
dwIDS = IDS_INBOX_ERROR_DISK_FULL;
break;
case FAX_ERR_FILE_ACCESS_DENIED:
DebugPrintEx( DEBUG_ERR, _T("FAX_ERR_FILE_ACCESS_DENIED == ec"));
dwIDS = IDS_INBOX_FAX_ERR_FILE_ACCESS_DENIED;
break;
case FAX_ERR_NOT_NTFS:
DebugPrintEx( DEBUG_ERR, _T("FAX_ERR_NOT_NTFS == ec"));
dwIDS = IDS_INBOX_FAX_ERR_NOT_NTFS;
break;
}
if ( 0 != dwIDS )
{
if (PropSheet_SetCurSelByID( GetParent(), IDD) )
{
PageError(dwIDS, m_hWnd);
GotoDlgCtrl(GetDlgItem(IDC_INBOX_FOLDER_EDIT));
}
fSkipMessage = TRUE;
goto Error;
}
if (IsNetworkError(ec))
{
DebugPrintEx(
DEBUG_ERR,
_T("Network Error was found. (ec: %ld)"),
ec);
m_pFaxServer->Disconnect();
}
goto Error;
}
ATLASSERT(S_OK == hRc);
m_fIsDirty = FALSE;
DebugPrintEx( DEBUG_MSG,
_T("Succeed to set inbox configuration."));
goto Exit;
Error:
ATLASSERT(ERROR_SUCCESS != ec);
hRc = HRESULT_FROM_WIN32(ec);
if (!fSkipMessage)
{
PropSheet_SetCurSelByID( GetParent(), IDD);
ATLASSERT(::IsWindow(m_hWnd));
PageError(GetFaxServerErrorMsg(ec),m_hWnd);
}
Exit:
return(hRc);
}
/*
- CppFaxServerInbox::PreApply
-
* Purpose:
* Checks properties before apply.
*
* Arguments:
*
* Return:
* OLE error code
*/
HRESULT CppFaxServerInbox::PreApply(int *pCtrlFocus, UINT * puIds)
{
HRESULT hRc = S_OK;
//
// PreApply Checks
//
if (!AllReadyToApply(/*fSilent =*/ FALSE, pCtrlFocus , puIds))
{
m_fAllReadyToApply = FALSE;
SetModified(FALSE);
hRc = E_FAIL ;
}
else
{
m_fAllReadyToApply = TRUE;
SetModified(TRUE);
}
return(hRc);
}
/*
- CppFaxServerInbox::ToArchiveCheckboxClicked
-
* Purpose:
* Gray/Ungray the folder edit box and the
* browse button. Enable apply button.
*
* Arguments:
*
* Return:
* 1
*/
LRESULT CppFaxServerInbox::ToArchiveCheckboxClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
BOOL State;
if (!m_fIsDialogInitiated) //event receieved in too early stage
{
return 0;
}
else
{
m_fIsDirty = TRUE;
}
State = ( IsDlgButtonChecked(IDC_TO_ARCHIVE_CHECK) == BST_CHECKED );
::EnableWindow(GetDlgItem(IDC_INBOX_FOLDER_EDIT), State);
::EnableWindow(GetDlgItem(IDC_INBOX_BROWSE_BUTTON), State && m_fIsLocalServer);
if (m_fAllReadyToApply)//only last change should be considered
{
if ( !m_FolderBox.GetWindowTextLength() )
{
m_fAllReadyToApply = FALSE;
SetModified(FALSE);
}
}
else //m_fAllReadyToApply == FALSE
{
if (AllReadyToApply(TRUE))
{
m_fAllReadyToApply = TRUE;
SetModified(TRUE);
}
}
return 1;
}
/*
- CppFaxServerInbox::GenerateEventLogCheckboxClicked
-
* Purpose:
* Gray/Ungray the spin buttons and edit boxes
* Enable apply button.
*
* Arguments:
*
* Return:
* 1
*/
LRESULT CppFaxServerInbox::GenerateEventLogCheckboxClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
BOOL State;
if (!m_fIsDialogInitiated) //event receieved in too early stage
{
return 0;
}
else
{
m_fIsDirty = TRUE;
}
State = ( IsDlgButtonChecked(IDC_GENERATE_WARNING_CHECK) == BST_CHECKED );
::EnableWindow(GetDlgItem(IDC_HIGH_EDIT), State);
::EnableWindow(GetDlgItem(IDC_HIGH_SPIN), State);
::EnableWindow(GetDlgItem(IDC_QUOTA_HIGH_STATIC), State);
::EnableWindow(GetDlgItem(IDC_MB1_STATIC), State);
::EnableWindow(GetDlgItem(IDC_LOW_EDIT), State);
::EnableWindow(GetDlgItem(IDC_LOW_SPIN), State);
::EnableWindow(GetDlgItem(IDC_QUOTA_LOW_STATIC), State);
::EnableWindow(GetDlgItem(IDC_MB2_STATIC), State);
if (m_fAllReadyToApply)//only last change should be considered
{
if ( !m_HighWatermarkBox.GetWindowTextLength() )
{
m_fAllReadyToApply = FALSE;
SetModified(FALSE);
}
else if ( 0 != HIWORD( m_HighWatermarkSpin.GetPos() ) ) //occures for out of range such zero. MSDN UDM_GETPOS
{
m_fAllReadyToApply = FALSE;
SetModified(FALSE);
}
else if ( !m_LowWatermarkBox.GetWindowTextLength() )
{
m_fAllReadyToApply = FALSE;
SetModified(FALSE);
}
}
else //m_fAllReadyToApply == FALSE
{
if (AllReadyToApply(TRUE))
{
m_fAllReadyToApply = TRUE;
SetModified(TRUE);
}
}
return(1);
}
/*
- CppFaxServerInbox::AutoDelCheckboxClicked
-
* Purpose:
* Gray/Ungray the spin button and edit box
* and enable apply button after Auto Delete Checkbox
* status was changed.
*
* Arguments:
*
* Return:
* 1
*/
LRESULT CppFaxServerInbox::AutoDelCheckboxClicked(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
BOOL State;
if (!m_fIsDialogInitiated) //event receieved in too early stage
{
return 0;
}
else
{
m_fIsDirty = TRUE;
}
State = ( IsDlgButtonChecked(IDC_AUTODEL_CHECK) == BST_CHECKED );
::EnableWindow(GetDlgItem(IDC_AUTODEL_EDIT), State);
::EnableWindow(GetDlgItem(IDC_AUTODEL_SPIN), State);
if (m_fAllReadyToApply)//only last change should be considered
{
if (State)
{
if ( !m_AutoDelBox.GetWindowTextLength() )
{
m_fAllReadyToApply = FALSE;
SetModified(FALSE);
}
else if ( 0 != HIWORD( m_AutoDelSpin.GetPos() ) ) //occures for out of range such zero. MSDN UDM_GETPOS
{
m_fAllReadyToApply = FALSE;
SetModified(FALSE);
}
}
}
else //m_fAllReadyToApply == FALSE
{
if (AllReadyToApply(TRUE))
{
m_fAllReadyToApply = TRUE;
SetModified(TRUE);
}
}
return(1);
}
/*
+ Routine Description:
+
* Browse for a directory
*
* Arguments:
*
* hwndDlg - Specifies the dialog window on which the Browse button is displayed
*
* Return Value:
*
* TRUE if successful, FALSE if the user presses Cancel
-
-
*/
BOOL
CppFaxServerInbox::BrowseForDirectory( WORD wNotifyCode, WORD wID, HWND hwndDlg, BOOL& bHandled )
{
UNREFERENCED_PARAMETER( wNotifyCode );
UNREFERENCED_PARAMETER( wID );
UNREFERENCED_PARAMETER( hwndDlg );
UNREFERENCED_PARAMETER( bHandled );
DEBUG_FUNCTION_NAME( _T("CppFaxServerInbox::BrowseForDirectory"));
BOOL fResult = FALSE;
WCHAR szBrowseFolder[MAX_PATH];
WCHAR szBrowseDlgTitle[FXS_MAX_TITLE_LEN];
CComBSTR bstrOldPath;
unsigned int len;
unsigned long ulBrowseFlags;
//
// Collecting the browse dialog headline
//
if (!LoadString( _Module.GetResourceInstance(),
IDS_GET_ARCHIVE_DIRECTORY,
szBrowseDlgTitle,
FXS_MAX_TITLE_LEN))
{
DWORD ec;
ec = GetLastError();
if (ec == ERROR_NOT_ENOUGH_MEMORY)
{
DebugPrintEx(
DEBUG_ERR,
_T("Out of Memory - fail to load string."));
DlgMsgBox(this, IDS_MEMORY);
return fResult;
}
DebugPrintEx(
DEBUG_ERR,
_T("Failed to load titile string - unexpected behavior."));
szBrowseDlgTitle[0] = 0;
}
//
// Collecting the old path from the calling dialog edit box
//
if(! GetDlgItemText( IDC_INBOX_FOLDER_EDIT, bstrOldPath.m_str))
{
DebugPrintEx(
DEBUG_ERR,
_T("Failed to collect old path from the property page edit box."));
szBrowseFolder[0] = 0;
}
else
{
len = bstrOldPath.Length();
if ( len > MAX_PATH )
{
DebugPrintEx(
DEBUG_ERR,
_T("Old Path Length is bigger then alowed maximal path."));
szBrowseFolder[0] = 0;
}
else
{
wcsncpy(szBrowseFolder,bstrOldPath,MAX_PATH);
szBrowseFolder[MAX_PATH-1]=L'\0';
}
}
//
// Preparing the browse dialog style flags.
//
ulBrowseFlags = BIF_RETURNONLYFSDIRS |
BIF_STATUSTEXT |
BIF_USENEWUI |
BIF_VALIDATE;
//
// Invoke the browse dialog with a function based on
// Shell functions.
//
if (InvokeBrowseDialog(
(unsigned short *)&szBrowseFolder,
(const unsigned short *)&szBrowseDlgTitle,
ulBrowseFlags,
this))
{
SetDlgItemText(IDC_INBOX_FOLDER_EDIT, szBrowseFolder);
fResult = TRUE;
}
return fResult;
}
/*
- CppFaxServerInbox::OnApply
-
* Purpose:
* Calls PreApply and SetProp to Apply changes.
*
* Arguments:
*
* Return:
* TRUE or FALSE
*/
BOOL CppFaxServerInbox::OnApply()
{
DEBUG_FUNCTION_NAME( _T("CppFaxServerInbox::OnApply"));
HRESULT hRc = S_OK;
int CtrlFocus = 0;
UINT uIds = 0;
if (!m_fIsDirty)
{
return TRUE;
}
hRc = PreApply(&CtrlFocus, &uIds);
if (FAILED(hRc))
{
if (PropSheet_SetCurSelByID( GetParent(), IDD) )
{
PageError(uIds, m_hWnd, _Module.GetResourceInstance());
if (CtrlFocus)
{
GotoDlgCtrl(GetDlgItem(CtrlFocus));
}
}
return FALSE;
}
else //(Succeeded(hRc))
{
hRc = SetProps(&CtrlFocus, &uIds);
if (FAILED(hRc))
{
if (uIds)
{
if (PropSheet_SetCurSelByID( GetParent(), IDD) )
{
PageError(uIds, m_hWnd, _Module.GetResourceInstance());
if (CtrlFocus)
{
GotoDlgCtrl(GetDlgItem(CtrlFocus));
}
}
}
//else Error Msg by called func.
return FALSE;
}
else //(Succeeded(hRc))
{
return TRUE;
}
}
}
/*
- CppFaxServerInbox::EditChanged
-
* Purpose:
* set Apply buttom modified.
*
* Arguments:
*
* Return:
* 1
*/
LRESULT CppFaxServerInbox::EditChanged(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if (!m_fIsDialogInitiated)
{
return 1;
}
else
{
m_fIsDirty = TRUE;
}
if (m_fAllReadyToApply) //only last change should be considered
{
switch (wID)
{
case IDC_INBOX_FOLDER_EDIT:
if ( !m_FolderBox.GetWindowTextLength() )
{
SetModified(FALSE);
m_fAllReadyToApply = FALSE;
}
break;
case IDC_HIGH_EDIT:
if ( !m_HighWatermarkBox.GetWindowTextLength() )
{
SetModified(FALSE);
m_fAllReadyToApply = FALSE;
}
else if ( 0 != HIWORD( m_HighWatermarkSpin.GetPos() ) ) //occures for out of range such zero. MSDN UDM_GETPOS
{
SetModified(FALSE);
m_fAllReadyToApply = FALSE;
}
break;
case IDC_LOW_EDIT:
if ( !m_LowWatermarkBox.GetWindowTextLength() )
{
SetModified(FALSE);
m_fAllReadyToApply = FALSE;
}
break;
case IDC_AUTODEL_EDIT:
if ( !m_AutoDelBox.GetWindowTextLength() )
{
SetModified(FALSE);
m_fAllReadyToApply = FALSE;
}
else if ( 0 != HIWORD( m_AutoDelSpin.GetPos() ) ) //occures for out of range such zero. MSDN UDM_GETPOS
{
m_fAllReadyToApply = FALSE;
SetModified(FALSE);
}
break;
default:
return 1;
}
}
else //m_fAllReadyToApply == FALSE
{
if (AllReadyToApply(TRUE))
{
m_fAllReadyToApply = TRUE;
SetModified(TRUE);
}
}
return 1;
}
/*
- CppFaxServerInbox::AllReadyToApply
-
* Purpose:
* This function validate that no zero length strings
* are found data areas that should be saved.
*
* Arguments:
* [in] fSilent - boolean who defines if to pop up messages (FALSE)
* or not.(TRUE)
*
* Return:
* BOOOLEAN
*/
BOOL CppFaxServerInbox::AllReadyToApply(BOOL fSilent, int *pCtrlFocus, UINT *pIds)
{
DEBUG_FUNCTION_NAME( _T("CppFaxServerInbox::AllReadyToApply"));
DWORD ec = ERROR_SUCCESS;
HINSTANCE hInst = _Module.GetResourceInstance();
if (IsDlgButtonChecked(IDC_TO_ARCHIVE_CHECK) == BST_CHECKED)
{
if ( !m_FolderBox.GetWindowTextLength() )
{
ec = GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Zero text length - m_FolderBox. (ec: %ld)"),
ec);
if (!fSilent)
{
*pIds = IDS_INBOX_ARCHIVE_PATH_EMPTY;
*pCtrlFocus = IDC_INBOX_FOLDER_EDIT;
}
return FALSE;
}
}
if (IsDlgButtonChecked(IDC_GENERATE_WARNING_CHECK) == BST_CHECKED)
{
if ( !m_HighWatermarkBox.GetWindowTextLength() )
{
ec = GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Zero text length - m_HighWatermarkBox. (ec: %ld)"),
ec);
if (!fSilent)
{
*pIds = IDS_INBOX_WATERMARK_EMPTY;
*pCtrlFocus = IDC_HIGH_EDIT;
}
return FALSE;
}
else if ( 0 != HIWORD( m_HighWatermarkSpin.GetPos() ) ) //occures for out of range such zero. MSDN UDM_GETPOS
{
DebugPrintEx(
DEBUG_ERR,
_T("Zero value - m_HighWatermarkBox. (ec: %ld)"));
if (!fSilent)
{
*pIds = IDS_INBOX_HIGH_WATERMARK_ZERO;
*pCtrlFocus = IDC_HIGH_EDIT;
}
return FALSE;
}
if ( !m_LowWatermarkBox.GetWindowTextLength() )
{
ec = GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Zero text length - m_LowWatermarkBox. (ec: %ld)"),
ec);
if (!fSilent)
{
*pIds = IDS_INBOX_WATERMARK_EMPTY;
*pCtrlFocus = IDC_SENT_LOW_EDIT;
}
return FALSE;
}
}
if (IsDlgButtonChecked(IDC_AUTODEL_CHECK) == BST_CHECKED)
{
if ( !m_AutoDelBox.GetWindowTextLength() )
{
ec = GetLastError();
DebugPrintEx(
DEBUG_ERR,
_T("Zero text length - m_AutoDelBox. (ec: %ld)"),
ec);
if (!fSilent)
{
*pIds = IDS_INBOX_AUTODEL_EMPTY;
*pCtrlFocus = IDC_AUTODEL_EDIT;
}
return FALSE;
}
else if ( 0 != HIWORD( m_AutoDelSpin.GetPos() ) ) //occures for out of range such zero. MSDN UDM_GETPOS
{
DebugPrintEx(
DEBUG_ERR,
_T("Zero value - m_AutoDelBox."));
if (!fSilent)
{
*pIds = IDS_INBOX_AUTODEL_EMPTY;
*pCtrlFocus = IDC_AUTODEL_EDIT;
}
return FALSE;
}
}
ATLASSERT(ERROR_SUCCESS == ec);
//
// Cheers!
// ...every thing ready to apply now.
//
return TRUE;
}
//////////////////////////////////////////////////////////////////////////////
/*++
CppFaxServerInbox::OnHelpRequest
This is called in response to the WM_HELP Notify
message and to the WM_CONTEXTMENU Notify message.
WM_HELP Notify message.
This message is sent when the user presses F1 or <Shift>-F1
over an item or when the user clicks on the ? icon and then
presses the mouse over an item.
WM_CONTEXTMENU Notify message.
This message is sent when the user right clicks over an item
and then clicks "What's this?"
--*/
/////////////////////////////////////////////////////////////////////////////
LRESULT
CppFaxServerInbox::OnHelpRequest(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
{
DEBUG_FUNCTION_NAME(_T("CppFaxServerInbox::OnHelpRequest"));
HELPINFO* helpinfo;
DWORD dwHelpId;
switch (uMsg)
{
case WM_HELP:
helpinfo = (HELPINFO*)lParam;
if (helpinfo->iContextType == HELPINFO_WINDOW)
{
::WinHelp(
(HWND) helpinfo->hItemHandle,
FXS_ADMIN_HLP_FILE,
HELP_CONTEXTPOPUP,
(DWORD) helpinfo->dwContextId
);
}
break;
case WM_CONTEXTMENU:
dwHelpId = ::GetWindowContextHelpId((HWND)wParam);
if (dwHelpId)
{
::WinHelp
(
(HWND)wParam,
FXS_ADMIN_HLP_FILE,
HELP_CONTEXTPOPUP,
dwHelpId
);
}
break;
}
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
| [
"112426112@qq.com"
] | 112426112@qq.com |
1e17e9334836b735f7028b5684a20bc9e6f848be | 34a745cee268f3985579a84328d36fdc42848875 | /AYT_wd/Exercise/build/source/recipe.cpp | 0d1f6eb1dc1b503517be1e11229b86dba56512e4 | [] | no_license | gastald88/AIROYoung_Tutorial | ce2c6cfa5ebbc738ebd9727738c5674cf46c8580 | cfd5bdc0f9b5e01d34eae0fce918571fc65c34ca | refs/heads/master | 2023-08-31T12:44:22.108542 | 2023-08-29T18:47:12 | 2023-08-29T18:47:12 | 214,660,493 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 963 | cpp | #include "recipe.h"
Recipe::Recipe() : Recipe("")
{
}
Recipe::Recipe(string _name) : butter_g(0), milk_ml(0), flour_g(0), chocolate_g(0), eggs(0), name(_name), conservation(Anywhere), cooking(Pot), cooking_duration()
{
}
bool Recipe::operator==(const Recipe & r) const
{
return this->name == r.name;
}
bool Recipe::cooksSlowerThan(Recipe & r) const
{
return this->cooking_duration < r.cooking_duration;
}
int Recipe::numCommonIngredients(Recipe & r1, Recipe & r2)
{
int i = 0;
if (r1.butter_g > 0 and r2.butter_g > 0)
i++;
if (r1.milk_ml > 0 and r2.milk_ml > 0)
i++;
if (r1.flour_g > 0 and r2.flour_g > 0)
i++;
if (r1.chocolate_g > 0 and r2.chocolate_g > 0)
i++;
if (r1.eggs > 0 and r2.eggs > 0)
i++;
return i;
}
void Recipe::python()
{
//expose enumerative types
//expose operator<<
//watch static methods
using namespace boost::python;
}
ostream & operator<<(ostream & out, const Recipe & r)
{
out << r.name;
return out;
}
| [
"gastald88@gmail.com"
] | gastald88@gmail.com |
097ec7c50bf15c56ba4a37fa778d175283181ea5 | 39a734a4bd8e27aa11e59dfcd12fefdc14e447e0 | /HitTraderApiDlg.h | e97f1d7488e30c6cb8697bea538a2a0d47523aaf | [] | no_license | paulwuzhenjun/StrategyWithCTP_shipan | 2b8c39d5ce67d1f878c032a136965dcc09fecd0c | 781b03616d6fc3eb3839b8a13ca16dc1e62a26f2 | refs/heads/master | 2023-04-23T02:26:32.710374 | 2021-04-21T04:08:10 | 2021-04-21T04:08:10 | 360,021,782 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,581 | h | // TestTraderApiDlg.h : header file
//
#pragma once
#include "afxwin.h"
#include "MyThread.h"
#include "InsertOrderDlg.h"
#include "OrdersMgrDlg.h"
#include "ParamsMgrDlg.h"
#include "PositionsMgrDlg.h"
#include "LocalCLMgrDlg.h"
#include "TradesDisplayDlg.h"
#include "MdDlg.h"
//#include "StrategyRecoverDlg.h"
#define WM_PUBMSG WM_USER+22
// CHitTraderApiDlg dialog
class CHitTraderApiDlg : public CDialog
{
// Construction
public:
CHitTraderApiDlg(CWnd* pParent = NULL); // standard constructor
virtual ~CHitTraderApiDlg();
CInsertOrderDlg* insertOrderDlg;
MdDlg* mMdDlg;
CString m_testString;
// Dialog Data
enum { IDD = 102 };
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
void ReSize();
POINT old;
// Implementation
protected:
HICON m_hIcon;
LRESULT OnPubmsg(WPARAM wParam, LPARAM lParam);
// Generated message map functions
virtual BOOL OnInitDialog();
virtual BOOL PreTranslateMessage(MSG* pMsg);
afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
afx_msg void OnPaint();
afx_msg HCURSOR OnQueryDragIcon();
afx_msg void OnTimer(UINT_PTR nIDEvent);
afx_msg void OnSize(UINT nType, int cx, int cy);
DECLARE_MESSAGE_MAP()
public:
afx_msg void OnLbnSelchangeList1();
CListBox m_ctrlPublisMsg;
CImageList m_imageList;
CTreeCtrl m_webTree;
CTabCtrl m_tab;
int m_CurSelTab;
ParamsMgrDlg m_ParamsMgrPage;
OrdersMgrDlg m_OrdersMgrPage;
PositionsMgrDlg m_PositionsMgrPage;
LocalCLMgrDlg m_LocalCLMgrDlgPage;
TradesDisplayDlg m_TradesDisplayDlgPage;
//StrategyRecoverDlg m_StrategyRecoverDlg;
void StrategyResetAction();
void StrategyInitAction();
CDialog* pDialog[5];
HANDLE mfile_handle;
bool MdStarted;
bool TraderStarted;
bool StrategyStarted;
void CheckAndCreateDirectory(CString csDirectionName);
int Split(CString source, CString ch, CStringArray& strarr);
//void UpLoadAcctValue(char* time);
afx_msg void OnBnOK();
afx_msg void OnBnCancel();
afx_msg void OnBnClickedConnect();
afx_msg void OnBnClickedStartStrategy();
afx_msg void OnBnClickedStopStrategy();
afx_msg void OnMenuInsertOrder();
//afx_msg void OnBnClickedExportOrders();
afx_msg void OnBnClickedRefreshAvailMoney();
//afx_msg void OnBnClickedScheduleBtn();
afx_msg void OnMenuOptions();
afx_msg void OnTvnSelchangedStrategyTree(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnTcnSelchangeMaintab(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnBnClickedSetPositionLimitBtn();
afx_msg void OnMenuProfitAnalyze();
afx_msg void OnReconnectTd();
afx_msg void OnMdDlg();
afx_msg void OnStRecover();
};
| [
"1072830517@qq.com"
] | 1072830517@qq.com |
3116c40b6a88d021555a204395172c578347fc7e | 6ed33be5f3ad900a0936d2f2e1481cea7a1f15f5 | /Day-18.cpp | 56f84dfaa8e7f45f3be0179c97a1dfcf56a7948a | [] | no_license | sejalsingh417/30DaysOfCoding | 194c82317e54965374e11ac997c1f0ecce7d8035 | 270f24553a6feb52caedd058860603c8a047a9ef | refs/heads/main | 2023-07-14T04:14:32.959025 | 2021-08-24T13:03:05 | 2021-08-24T13:03:05 | 397,263,958 | 2 | 1 | null | 2021-08-18T14:29:50 | 2021-08-17T13:17:20 | C++ | UTF-8 | C++ | false | false | 1,392 | cpp | #include <iostream>
#include <queue>
#include <stack>
using namespace std;
class Solution
{
public:
void pushCharacter(const char c_) { _s.push(c_); }
void enqueueCharacter(const char c_) { _q.push(c_); }
char popCharacter()
{
char c = _s.top();
_s.pop();
return c;
}
char dequeueCharacter()
{
char c = _q.front();
_q.pop();
return c;
}
private:
queue<char> _q;
stack<char> _s;
};
int main()
{
// read the string s.
string s;
getline(cin, s);
// create the Solution class object p.
Solution obj;
// push/enqueue all the characters of string s to stack.
for (int i = 0; i < s.length(); i++)
{
obj.pushCharacter(s[i]);
obj.enqueueCharacter(s[i]);
}
bool isPalindrome = true;
// pop the top character from stack.
// dequeue the first character from queue.
// compare both the characters.
for (int i = 0; i < s.length() / 2; i++)
{
if (obj.popCharacter() != obj.dequeueCharacter())
{
isPalindrome = false;
break;
}
}
// finally print whether string s is palindrome or not.
if (isPalindrome)
{
cout << "The word, " << s << ", is a palindrome.";
}
else
{
cout << "The word, " << s << ", is not a palindrome.";
}
return 0;
} | [
"sejalsingh417@gmail.com"
] | sejalsingh417@gmail.com |
35ceb012a6e4e85fb8f22caec206110e0b36202a | 0c5dd1b89b686d23b536c9f51b30b2f5e69ff399 | /dates/test.cpp | 80dbda2bc5b00309ce9b3bcb49acb77f048189ab | [] | no_license | blazprog/codesnips | 23fc57233fc197866c8c539df280d8792de098a4 | 1c307b74b5a00cbe339c86b3e37b101ad0921fcb | refs/heads/master | 2021-01-21T10:45:48.507153 | 2018-11-19T11:32:58 | 2018-11-19T11:32:58 | 101,984,521 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 72 | cpp | #include <iostream>
int main() {
int i = 30;
std::cout << i;
}
| [
"blaz.korosec@mentis.si"
] | blaz.korosec@mentis.si |
489b3fe154ae7d8fb25e0ea347e48157ee9e972e | 67f988dedfd8ae049d982d1a8213bb83233d90de | /external/chromium/chrome/browser/extensions/image_loading_tracker.cc | d519878ff34bd363acfc887ed9ab4d9b2a10fc21 | [
"BSD-3-Clause"
] | permissive | opensourceyouthprogramming/h5vcc | 94a668a9384cc3096a365396b5e4d1d3e02aacc4 | d55d074539ba4555e69e9b9a41e5deb9b9d26c5b | refs/heads/master | 2020-04-20T04:57:47.419922 | 2019-02-12T00:56:14 | 2019-02-12T00:56:14 | 168,643,719 | 1 | 1 | null | 2019-02-12T00:49:49 | 2019-02-01T04:47:32 | C++ | UTF-8 | C++ | false | false | 13,851 | cc | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/extensions/image_loading_tracker.h"
#include <string>
#include <vector>
#include "base/bind.h"
#include "base/file_util.h"
#include "base/threading/sequenced_worker_pool.h"
#include "chrome/browser/extensions/image_loader.h"
#include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
#include "chrome/common/chrome_notification_types.h"
#include "chrome/common/extensions/extension.h"
#include "chrome/common/extensions/extension_constants.h"
#include "chrome/common/extensions/extension_file_util.h"
#include "chrome/common/extensions/extension_resource.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/notification_service.h"
#include "skia/ext/image_operations.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/gfx/image/image.h"
#include "ui/gfx/image/image_skia_rep.h"
#include "webkit/glue/image_decoder.h"
using content::BrowserThread;
using extensions::Extension;
namespace {
bool ShouldResizeImageRepresentation(
ImageLoadingTracker::ImageRepresentation::ResizeCondition resize_method,
const gfx::Size& decoded_size,
const gfx::Size& desired_size) {
switch (resize_method) {
case ImageLoadingTracker::ImageRepresentation::ALWAYS_RESIZE:
return decoded_size != desired_size;
case ImageLoadingTracker::ImageRepresentation::RESIZE_WHEN_LARGER:
return decoded_size.width() > desired_size.width() ||
decoded_size.height() > desired_size.height();
default:
NOTREACHED();
return false;
}
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
// ImageLoadingTracker::Observer
ImageLoadingTracker::Observer::~Observer() {}
////////////////////////////////////////////////////////////////////////////////
// ImageLoadingTracker::ImageRepresentation
ImageLoadingTracker::ImageRepresentation::ImageRepresentation(
const ExtensionResource& resource,
ResizeCondition resize_method,
const gfx::Size& desired_size,
ui::ScaleFactor scale_factor)
: resource(resource),
resize_method(resize_method),
desired_size(desired_size),
scale_factor(scale_factor) {
}
ImageLoadingTracker::ImageRepresentation::~ImageRepresentation() {
}
////////////////////////////////////////////////////////////////////////////////
// ImageLoadingTracker::PendingLoadInfo
ImageLoadingTracker::PendingLoadInfo::PendingLoadInfo()
: extension(NULL),
cache(CACHE),
pending_count(0) {
}
ImageLoadingTracker::PendingLoadInfo::~PendingLoadInfo() {}
////////////////////////////////////////////////////////////////////////////////
// ImageLoadingTracker::ImageLoader
// A RefCounted class for loading bitmaps/image reps on the File thread and
// reporting back on the UI thread.
class ImageLoadingTracker::ImageLoader
: public base::RefCountedThreadSafe<ImageLoader> {
public:
explicit ImageLoader(ImageLoadingTracker* tracker)
: tracker_(tracker) {
CHECK(BrowserThread::GetCurrentThreadIdentifier(&callback_thread_id_));
DCHECK(!BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
}
// Lets this class know that the tracker is no longer interested in the
// results.
void StopTracking() {
tracker_ = NULL;
}
// Instructs the loader to load a task on the blocking pool.
void LoadImage(const ImageRepresentation& image_info, int id) {
DCHECK(BrowserThread::CurrentlyOn(callback_thread_id_));
BrowserThread::PostBlockingPoolTask(
FROM_HERE,
base::Bind(&ImageLoader::LoadOnBlockingPool, this, image_info, id));
}
void LoadOnBlockingPool(const ImageRepresentation& image_info, int id) {
DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
// Read the file from disk.
std::string file_contents;
FilePath path = image_info.resource.GetFilePath();
if (path.empty() || !file_util::ReadFileToString(path, &file_contents)) {
ReportBack(NULL, image_info, gfx::Size(), id);
return;
}
// Decode the bitmap using WebKit's image decoder.
const unsigned char* data =
reinterpret_cast<const unsigned char*>(file_contents.data());
webkit_glue::ImageDecoder decoder;
scoped_ptr<SkBitmap> decoded(new SkBitmap());
// Note: This class only decodes bitmaps from extension resources. Chrome
// doesn't (for security reasons) directly load extension resources provided
// by the extension author, but instead decodes them in a separate
// locked-down utility process. Only if the decoding succeeds is the image
// saved from memory to disk and subsequently used in the Chrome UI.
// Chrome is therefore decoding bitmaps here that were generated by Chrome.
*decoded = decoder.Decode(data, file_contents.length());
if (decoded->empty()) {
ReportBack(NULL, image_info, gfx::Size(), id);
return; // Unable to decode.
}
gfx::Size original_size(decoded->width(), decoded->height());
*decoded = ResizeIfNeeded(*decoded, image_info);
ReportBack(decoded.release(), image_info, original_size, id);
}
// Instructs the loader to load a resource on the UI thread.
void LoadResource(const ImageRepresentation& image_info,
int id,
int resource_id) {
DCHECK(BrowserThread::CurrentlyOn(callback_thread_id_));
if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
LoadResourceOnUIThread(image_info, id, resource_id);
return;
}
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&ImageLoader::LoadResourceOnUIThread, this, image_info,
id, resource_id));
}
void LoadResourceOnUIThread(const ImageRepresentation& image_info,
int id,
int resource_id) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
// Bundled image resources is only safe to be loaded on UI thread.
gfx::ImageSkia* image =
ResourceBundle::GetSharedInstance().GetImageSkiaNamed(resource_id);
image->MakeThreadSafe();
BrowserThread::PostBlockingPoolTask(
FROM_HERE,
base::Bind(&ImageLoader::ResizeOnBlockingPool, this, image_info,
id, *image));
}
void ResizeOnBlockingPool(const ImageRepresentation& image_info,
int id,
const gfx::ImageSkia& image) {
DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
// TODO(xiyuan): Clean up to use SkBitmap here and in LoadOnBlockingPool.
scoped_ptr<SkBitmap> bitmap(new SkBitmap);
gfx::Size original_size(image.width(), image.height());
*bitmap = ResizeIfNeeded(*image.bitmap(), image_info);
ReportBack(bitmap.release(), image_info, original_size, id);
}
void ReportBack(const SkBitmap* bitmap, const ImageRepresentation& image_info,
const gfx::Size& original_size, int id) {
DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
BrowserThread::PostTask(
callback_thread_id_, FROM_HERE,
base::Bind(&ImageLoader::ReportOnCallingThread, this,
bitmap, image_info, original_size, id));
}
void ReportOnCallingThread(const SkBitmap* bitmap,
const ImageRepresentation& image_info,
const gfx::Size& original_size,
int id) {
DCHECK(BrowserThread::CurrentlyOn(callback_thread_id_));
if (tracker_)
tracker_->OnBitmapLoaded(bitmap, image_info, original_size, id, true);
if (bitmap)
delete bitmap;
}
private:
friend class base::RefCountedThreadSafe<ImageLoader>;
~ImageLoader() {}
SkBitmap ResizeIfNeeded(const SkBitmap& bitmap,
const ImageRepresentation& image_info) {
gfx::Size original_size(bitmap.width(), bitmap.height());
if (ShouldResizeImageRepresentation(image_info.resize_method,
original_size,
image_info.desired_size)) {
return skia::ImageOperations::Resize(
bitmap, skia::ImageOperations::RESIZE_LANCZOS3,
image_info.desired_size.width(), image_info.desired_size.height());
}
return bitmap;
}
// The tracker we are loading the bitmap for. If NULL, it means the tracker is
// no longer interested in the reply.
ImageLoadingTracker* tracker_;
// The thread that we need to call back on to report that we are done.
BrowserThread::ID callback_thread_id_;
DISALLOW_COPY_AND_ASSIGN(ImageLoader);
};
////////////////////////////////////////////////////////////////////////////////
// ImageLoadingTracker
ImageLoadingTracker::ImageLoadingTracker(Observer* observer)
: observer_(observer),
next_id_(0) {
registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
content::NotificationService::AllSources());
}
ImageLoadingTracker::~ImageLoadingTracker() {
// The loader is created lazily and is NULL if the tracker is destroyed before
// any valid image load tasks have been posted.
if (loader_)
loader_->StopTracking();
}
void ImageLoadingTracker::LoadImage(const Extension* extension,
const ExtensionResource& resource,
const gfx::Size& max_size,
CacheParam cache) {
std::vector<ImageRepresentation> info_list;
info_list.push_back(ImageRepresentation(
resource,
ImageRepresentation::RESIZE_WHEN_LARGER,
max_size,
ui::SCALE_FACTOR_100P));
LoadImages(extension, info_list, cache);
}
void ImageLoadingTracker::LoadImages(
const Extension* extension,
const std::vector<ImageRepresentation>& info_list,
CacheParam cache) {
PendingLoadInfo load_info;
load_info.extension = extension;
load_info.cache = cache;
load_info.extension_id = extension->id();
load_info.pending_count = info_list.size();
int id = next_id_++;
load_map_[id] = load_info;
for (std::vector<ImageRepresentation>::const_iterator it = info_list.begin();
it != info_list.end(); ++it) {
// If we don't have a path we don't need to do any further work, just
// respond back.
if (it->resource.relative_path().empty()) {
OnBitmapLoaded(NULL, *it, it->desired_size, id, false);
continue;
}
DCHECK(extension->path() == it->resource.extension_root());
// See if the extension has the bitmap already.
if (extension->HasCachedImage(it->resource, it->desired_size)) {
SkBitmap bitmap = extension->GetCachedImage(it->resource,
it->desired_size);
OnBitmapLoaded(&bitmap, *it, it->desired_size, id, false);
continue;
}
// Instruct the ImageLoader to load this on the File thread. LoadImage and
// LoadResource do not block.
if (!loader_)
loader_ = new ImageLoader(this);
int resource_id = -1;
if (extension->location() == Extension::COMPONENT &&
extensions::ImageLoader::IsComponentExtensionResource(
extension->path(), it->resource.relative_path(), &resource_id)) {
loader_->LoadResource(*it, id, resource_id);
} else {
loader_->LoadImage(*it, id);
}
}
}
void ImageLoadingTracker::OnBitmapLoaded(
const SkBitmap* bitmap,
const ImageRepresentation& image_info,
const gfx::Size& original_size,
int id,
bool should_cache) {
LoadMap::iterator load_map_it = load_map_.find(id);
DCHECK(load_map_it != load_map_.end());
PendingLoadInfo* info = &load_map_it->second;
// Save the pending results.
DCHECK_GT(info->pending_count, 0u);
info->pending_count--;
if (bitmap) {
info->image_skia.AddRepresentation(gfx::ImageSkiaRep(*bitmap,
image_info.scale_factor));
}
// Add to the extension's bitmap cache if requested.
DCHECK(info->cache != CACHE || info->extension);
if (should_cache && info->cache == CACHE && !image_info.resource.empty() &&
!info->extension->HasCachedImage(image_info.resource, original_size)) {
info->extension->SetCachedImage(image_info.resource,
bitmap ? *bitmap : SkBitmap(),
original_size);
}
// If all pending bitmaps are done then report back.
if (info->pending_count == 0) {
gfx::Image image;
std::string extension_id = info->extension_id;
if (!info->image_skia.isNull()) {
info->image_skia.MakeThreadSafe();
image = gfx::Image(info->image_skia);
}
load_map_.erase(load_map_it);
// ImageLoadingTracker might be deleted after the callback so don't do
// anything after this statement.
observer_->OnImageLoaded(image, extension_id, id);
}
}
void ImageLoadingTracker::Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) {
DCHECK(type == chrome::NOTIFICATION_EXTENSION_UNLOADED);
const Extension* extension =
content::Details<extensions::UnloadedExtensionInfo>(details)->extension;
// Remove reference to this extension from all pending load entries. This
// ensures we don't attempt to cache the bitmap when the load completes.
for (LoadMap::iterator i = load_map_.begin(); i != load_map_.end(); ++i) {
PendingLoadInfo* info = &i->second;
if (info->extension == extension) {
info->extension = NULL;
info->cache = DONT_CACHE;
}
}
}
| [
"rjogrady@google.com"
] | rjogrady@google.com |
7306f794473c94afaace2e378d2ce193faddd1b1 | 38fca4aab1e7f9639668c640cff98b47a5f4b2b0 | /SEM-VI/Crypto-CSS/1 Product-Cypher/Single-Columnar-Cypher.hxx | 71581e4a675950d3dd7b4ea6cc2927dca596ff89 | [] | no_license | pratikpc/College | f74fae658b32364ed274ca6ec91dbe259582fe30 | a0eb705c7e8b4ffefab3ac7f1490a446b8e94e18 | refs/heads/master | 2023-06-11T00:40:19.483443 | 2020-11-28T20:25:49 | 2020-11-28T20:26:29 | 141,829,712 | 0 | 0 | null | 2023-05-23T20:13:02 | 2018-07-21T16:39:46 | C | UTF-8 | C++ | false | false | 1,779 | hxx | #include <string>
#include <numeric>
#include <vector>
template<typename T>
std::vector<std::size_t> tag_sort (const T& v)
{
std::vector<std::size_t> result (v.size ());
std::iota (std::begin (result), std::end (result), 0);
std::sort (std::begin (result), std::end (result),
[&v](const auto& lhs, const auto& rhs)
{
return v[lhs] < v[rhs];
}
);
return result;
}
std::string SingleColumnarCypher (std::string p_text, const std::string key)
{
auto const pad = (p_text.size () / key.size () + 1) * key.size ();
p_text.reserve (pad);
for (std::size_t i = p_text.size(); i < pad; ++i)
p_text.push_back(' ');
std::string c_text;
c_text.reserve (p_text.size ());
auto const sorted_indexes = tag_sort (key);
for (std::size_t i = 0; i < key.size (); ++i)
{
auto const column = sorted_indexes[i];
for (std::size_t j = 0; j < ((p_text.size () / key.size ()) + 1); j += 1)
{
auto const row_col = j * key.size () + column;
if (row_col >= p_text.size ())
break;
c_text.push_back (p_text[row_col]);
}
}
return c_text;
}
std::string SingleColumnarDecypher (const std::string& c_text, const std::string& key)
{
std::string p_text;
p_text.resize (c_text.size ());
auto const sorted_indexes = tag_sort (key);
for (std::size_t column = 0; column < key.size (); ++column)
{
for (std::size_t j = 0; j < c_text.size () / key.size (); j += 1)
{
auto const row_col_ins = j * key.size () + sorted_indexes[column];
auto const row_col = column * c_text.size () / key.size () + j;
if (row_col >= c_text.size ())
break;
p_text[row_col_ins] = (c_text[row_col]);
}
}
return p_text;
} | [
"pratikc@live.co.uk"
] | pratikc@live.co.uk |
ffa4f7c6e8f55a3137b0f9a53f2498060580badf | 1330f6f76426c67b68bf8da5efc77861630b4da6 | /dlls/pymod/py_engine.cpp | 94340424d0c0a11676ee6f52a411930b4221b0b8 | [
"MIT"
] | permissive | Hing-s/HL_PyMod | c30dd078d1789c04410c6f58565228ea17028c89 | 62628e48996fe1062e17d91f9bd05d9aa50f396c | refs/heads/master | 2022-11-29T11:19:12.820133 | 2020-07-27T07:58:18 | 2020-07-27T07:58:18 | 281,605,702 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,475 | cpp | #include "pymod/py_engine.h"
#include "cbase.h"
int msgs_count = 0;
msg_t MSGS[197];
#define REG(F, H) PyRegister(#F, &F, H)
#define IS(val) (!strcmp(var, #val))
#define PY_RETURN_ENT(pEnt) if(!FNullEnt(pEnt)) return Py_BuildValue("(ii)", ENTINDEX(pEnt), pEnt->serialnumber); else { Py_XINCREF(Py_None); return Py_None; }
FUNC(AlertMessage)
{
const char *message;
int type;
if(!PyArg_ParseTuple(args, "is", &type, &message))
return NULL;
ALERT((ALERT_TYPE)type, message);
Py_XDECREF(args);
Py_RETURN_NONE;
}
FUNC(send_message) {
PyObject *msg;
int dest, msg_type;
PyObject *origin, *owner;
if(!PyArg_ParseTuple(args, "iiOOO", &dest, &msg_type, &origin, &owner, &msg))
return NULL;
if(msg_type == -1) {
ALERT(at_error, "Passed unregistered msg! Return.\n");
Py_XDECREF(args);
Py_RETURN_NONE;
}
if(PyObject_Size(msg) > 0) {
Vector VecOrigin;
edict_t *pEntOwner = ParseEnt(owner);
if(SetVector(VecOrigin, origin))
MESSAGE_BEGIN(dest, msg_type, VecOrigin, pEntOwner);
else
MESSAGE_BEGIN(dest, msg_type);
for(int i = 0; i < PyObject_Size(msg); i++) {
PyObject *index = PyLong_FromLong(i);
PyObject *data = PyObject_GetItem(msg, index);
const char *type;
PyObject *value;
if(!PyArg_ParseTuple(data, "sO", &type, &value)) {
MESSAGE_END();
return NULL;
}
if(!strcmp("byte", type))
WRITE_BYTE(PyLong_AsLong(value));
else if(!strcmp("char", type))
WRITE_CHAR(PyLong_AsLong(value));
else if(!strcmp("short", type))
WRITE_SHORT(PyLong_AsLong(value));
else if(!strcmp("long", type))
WRITE_LONG(PyLong_AsLong(value));
else if(!strcmp("angle", type))
WRITE_ANGLE((float)PyFloat_AsDouble(value));
else if(!strcmp("coord", type))
WRITE_COORD((float)PyLong_AsLong(value));
else if(!strcmp("string", type))
WRITE_STRING(PyUnicode_AsUTF8(value));
else if(!strcmp("entity", type))
{
edict_t *pEnt = ParseEnt(value);
if(pEnt)
WRITE_ENTITY(ENTINDEX(pEnt));
}
Py_DECREF(data);
Py_DECREF(index);
Py_DECREF(origin);
Py_DECREF(owner);
}
MESSAGE_END();
}
Py_XDECREF(msg);
Py_RETURN_NONE;
}
FUNC(GetPlayerAuthId) {
PyObject *ent;
if(!PyArg_ParseTuple(args, "O", &ent))
return NULL;
edict_t *pEnt = ParseEnt(ent);
if(pEnt)
return PyUnicode_FromString(g_engfuncs.pfnGetPlayerAuthId(pEnt));
return PyLong_FromLong(-1);
}
FUNC(GetPlayerWONId) {
PyObject *ent;
if(!PyArg_ParseTuple(args, "O", &ent))
return NULL;
edict_t *pEnt = ParseEnt(ent);
if(pEnt)
return PyLong_FromLong(g_engfuncs.pfnGetPlayerWONId(pEnt));
return PyLong_FromLong(-1);
}
FUNC(get_msg_id) {
const char *msg;
if(!PyArg_ParseTuple(args, "s", &msg))
return NULL;
return PyLong_FromLong(GET_MSG_ID(msg));
}
FUNC(find_entity_by_classname)
{
PyObject *StartEnt;
const char *classname;
if(!PyArg_ParseTuple(args, "Os", &StartEnt, &classname))
return NULL;
edict_t *pStartEnt = NULL;
edict_t *pentEntity;
if(PyObject_IsTrue(StartEnt))
pStartEnt = ParseEnt(StartEnt);
if(pStartEnt)
pentEntity = FIND_ENTITY_BY_STRING(pStartEnt, "classname", classname);
else
pentEntity = FIND_ENTITY_BY_STRING(NULL, "classname", classname);
if(!FNullEnt(pentEntity))
PY_RETURN_ENT(pentEntity);
Py_RETURN_NONE;
}
FUNC(CvarSetFloat) {
const char *cvar;
float value;
if(!PyArg_ParseTuple(args, "sf", &cvar, &value))
return NULL;
CVAR_SET_FLOAT(cvar, value);
Py_XDECREF(args);
Py_RETURN_NONE;
}
FUNC(CvarSetString) {
const char *cvar, *value;
if(!PyArg_ParseTuple(args, "ss", &cvar, &value))
return NULL;
CVAR_SET_STRING(cvar, value);
Py_XDECREF(args);
Py_RETURN_NONE;
}
FUNC(FindEntityInSphere) {
PyObject *StartEnt, *origin;
float radius;
if(!PyArg_ParseTuple(args, "OOf", &StartEnt, &origin, &radius))
return NULL;
edict_t *pStartEnt = NULL;
edict_t *pentEntity;
Vector VecOrigin;
if(PyObject_IsTrue(StartEnt))
pStartEnt = ParseEnt(StartEnt);
if(!SetVector(VecOrigin, origin))
{
Py_XDECREF(args);
Py_RETURN_NONE;
}
edict_t *pEnt = FIND_ENTITY_IN_SPHERE(pStartEnt, VecOrigin, radius);
PY_RETURN_ENT(pEnt);
}
FUNC(SetOrigin) {
PyObject *ent, *origin;
if(!PyArg_ParseTuple(args, "OO", &ent, &origin))
return NULL;
edict_t *entity = ParseEnt(ent);
if(entity) {
Vector VecOrigin = g_vecZero;
if(SetVector(VecOrigin, origin))
SET_ORIGIN(entity, VecOrigin);
}
Py_RETURN_NONE;
}
FUNC(CreateNamedEntity) {
const char *entity;
PyObject *origin, *angles, *owner;
if(!PyArg_ParseTuple(args, "sOOO", &entity, &origin, &angles, &owner))
return Py_None;
edict_t *pEnt = CREATE_NAMED_ENTITY(MAKE_STRING(entity));
if(pEnt) {
SetVector(pEnt->v.origin, origin);
SetVector(pEnt->v.angles, angles);
if(owner != Py_None) {
edict_t *pEntOwner = ParseEnt(owner);
if(pEntOwner != NULL)
pEnt->v.owner = pEntOwner;
}
//DispatchSpawn(pEnt);
PyObject *RetEnt = Py_BuildValue("(ii)", ENTINDEX(pEnt), pEnt->serialnumber);
Py_XDECREF(args);
Py_XINCREF(RetEnt);
return RetEnt;
}
Py_XDECREF(args);
Py_RETURN_NONE;
}
FUNC(RemoveEntity) {
PyObject *ent;
if(!PyArg_ParseTuple(args, "O", &ent))
return NULL;
edict_t *entity = ParseEnt(ent);
if(entity)
REMOVE_ENTITY(entity);
Py_RETURN_NONE;
}
FUNC(PrecacheModel)
{
const char *model;
if(!PyArg_ParseTuple(args, "s", &model))
return NULL;
PRECACHE_MODEL(model);
Py_RETURN_NONE;
}
FUNC(PrecacheSound)
{
const char *sound;
if(!PyArg_ParseTuple(args, "s", &sound))
return NULL;
PRECACHE_SOUND(sound);
Py_RETURN_NONE;
}
FUNC(SetModel)
{
const char *model;
PyObject *ent;
if(!PyArg_ParseTuple(args, "Os", &ent, &model))
return NULL;
edict_t *entity = ParseEnt(ent);
if(entity)
SET_MODEL(entity, model);
Py_RETURN_NONE;
}
FUNC(ent_get)
{
const char *var;
PyObject *ent;
if(!PyArg_ParseTuple(args, "Os", &ent, &var))
Py_RETURN_NONE;
edict_t *entity = ParseEnt(ent);
if(entity)
{
if IS(health)
return PyFloat_FromDouble((double)entity->v.health);
else if IS(origin)
return GetVector(entity->v.origin);
else if IS(size)
return GetVector(entity->v.size);
else if IS(velocity)
return GetVector(entity->v.velocity);
else if IS(v_angle)
return GetVector(entity->v.v_angle);
else if IS(absmin)
return GetVector(entity->v.absmin);
else if IS(absmax)
return GetVector(entity->v.absmax);
else if IS(armor)
return PyFloat_FromDouble((double)entity->v.armorvalue);
else if IS(view_ofs)
return GetVector(entity->v.view_ofs);
else if IS(classname)
return PyUnicode_FromString(STRING(entity->v.classname));
else if IS(punchangle)
return GetVector(entity->v.punchangle);
else if IS(netname)
return PyUnicode_FromString(STRING(entity->v.netname));
else if IS(nextthink)
return PyFloat_FromDouble((double)entity->v.nextthink);
else if IS(solid)
return PyLong_FromLong(entity->v.solid);
else if IS(movetype)
return PyLong_FromLong(entity->v.movetype);
else if IS(modelindex)
return PyLong_FromLong(entity->v.modelindex);
else if IS(effects)
return PyLong_FromLong(entity->v.effects);
else if IS(button)
return PyLong_FromLong(entity->v.button);
else if IS(model)
return PyUnicode_FromString(STRING(entity->v.model));
else if IS(aiment)
{
if(entity->v.aiment)
return Py_BuildValue("(ii)", ENTINDEX(entity->v.aiment), entity->v.aiment->serialnumber);
else
Py_RETURN_NONE;
}
else if IS(aiment)
{
if(entity->v.aiment)
return Py_BuildValue("(ii)", ENTINDEX(entity->v.owner), entity->v.owner->serialnumber);
else
Py_RETURN_NONE;
}
}
Py_RETURN_NONE;
}
FUNC(ent_set)
{
const char *var;
PyObject *value;
PyObject *ent;
Py_XINCREF(Py_None);
if(!PyArg_ParseTuple(args, "OsO", &ent, &var, &value))
Py_RETURN_NONE;
edict_t *entity = ParseEnt(ent);
if(entity)
{
if IS(health)
entity->v.health = (float)PyFloat_AsDouble(value);
else if IS(size)
SetVector(entity->v.size, value);
else if IS(origin)
SetVector(entity->v.origin, value);
else if IS(velocity)
SetVector(entity->v.velocity, value);
else if IS(v_angle)
SetVector(entity->v.v_angle, value);
else if IS(absmin)
SetVector(entity->v.absmin, value);
else if IS(absmax)
SetVector(entity->v.absmax, value);
else if IS(armor)
entity->v.armorvalue = (float)PyFloat_AsDouble(value);
else if IS(view_ofs)
SetVector(entity->v.view_ofs, value);
else if IS(classname)
entity->v.classname = MAKE_STRING(PyUnicode_AsUTF8(value));
else if IS(punchangle)
SetVector(entity->v.punchangle, value);
else if IS(nextthink)
entity->v.nextthink = (float)PyFloat_AsDouble(value);
else if IS(solid)
entity->v.solid = PyLong_AsLong(value);
else if IS(movetype)
entity->v.movetype = PyLong_AsLong(value);
else if IS(modelindex)
entity->v.modelindex = PyLong_AsLong(value);
else if IS(effects)
entity->v.effects = PyLong_AsLong(value);
else if IS(model)
entity->v.model = MAKE_STRING(PyUnicode_AsUTF8(value));
else if IS(button)
entity->v.button = PyLong_AsLong(value);
else if IS(owner)
{
edict_t *owner = ParseEnt(value);
if(owner)
entity->v.owner = owner;
}
else if IS(aiment)
{
edict_t *aiment = ParseEnt(value);
if(aiment)
entity->v.aiment = aiment;
}
}
Py_RETURN_NONE;
}
FUNC(MakeVector) {
PyObject *coords;
if(!PyArg_ParseTuple(args, "O", &coords))
Py_RETURN_FALSE;
Vector Vec;
if(SetVector(Vec, coords))
{
MAKE_VECTORS(Vec);
Py_XDECREF(args);
Py_RETURN_TRUE;
}
Py_XDECREF(args);
Py_RETURN_FALSE;
}
FUNC(get_player_by_name) {
const char *name;
if(!PyArg_ParseTuple(args, "s", &name))
return NULL;
for(int i = 0; i < gpGlobals->maxClients; i++)
{
CBaseEntity *pPlayer = UTIL_PlayerByIndex(i);
if(pPlayer && !strcmp(name, STRING(pPlayer->pev->netname)))
{
edict_t *pEnt = pPlayer->edict();
return Py_BuildValue("(ii)", ENTINDEX(pEnt), pEnt->serialnumber);
}
}
return Py_None;
}
FUNC(ServerCmd) {
const char *cmd;
if(!PyArg_ParseTuple(args, "s", &cmd))
return NULL;
SERVER_COMMAND(cmd);
return Py_None;
}
FUNC(ClientCmd) {
PyObject *ent;
const char *cmd;
if(!PyArg_ParseTuple(args, "Os", &ent, &cmd))
return NULL;
edict_t *entity = ParseEnt(ent);
if(entity)
CLIENT_COMMAND(entity, cmd);
Py_RETURN_NONE;
}
FUNC(CreateEntity) {
Py_DECREF(args);
edict_t *pEnt = CREATE_ENTITY();
if(pEnt)
return Py_BuildValue("(ii)", ENTINDEX(pEnt), pEnt->serialnumber);
Py_RETURN_NONE;
}
FUNC(SetSize) {
PyObject *ent, *min, *max;
if(!PyArg_ParseTuple(args, "OOO", &ent, &min, &max))
return NULL;
edict_t *pEnt = ParseEnt(ent);
Vector VecMin, VecMax;
if(pEnt && SetVector(VecMin, min), SetVector(VecMax, max))
UTIL_SetSize(VARS(pEnt), VecMin, VecMax);
Py_XDECREF(args);
Py_RETURN_NONE;
}
FUNC(is_player) {
PyObject *ent;
if(!PyArg_ParseTuple(args, "O", &ent))
return NULL;
edict_t *entity = ParseEnt(ent);
if(entity)
return PyBool_FromLong(CBaseEntity::Instance(entity)->IsPlayer());
Py_RETURN_FALSE;
}
FUNC(is_valid)
{
PyObject *ent;
if(!PyArg_ParseTuple(args, "O", &ent))
return NULL;
edict_t *entity = ParseEnt(ent);
Py_XDECREF(args);
if(entity)
Py_RETURN_TRUE;
Py_RETURN_FALSE;
}
FUNC(globals_get) {
const char *var;
if(!PyArg_ParseTuple(args, "s", &var))
Py_RETURN_NONE;
Py_XDECREF(args);
if IS(time)
return PyFloat_FromDouble((double)gpGlobals->time);
else if IS(v_forward)
return GetVector(gpGlobals->v_forward);
else if IS(v_up)
return GetVector(gpGlobals->v_up);
else if IS(v_right)
return GetVector(gpGlobals->v_right);
Py_RETURN_NONE;
}
FUNC(dispatch_spawn) {
PyObject *ent;
if(!PyArg_ParseTuple(args, "O", &ent))
return NULL;
edict_t *entity = ParseEnt(ent);
if(entity)
(*other_gFunctionTable.pfnSpawn)(entity);
Py_RETURN_NONE;
}
FUNC(dispatch_touch) {
PyObject *ent, *other;
if(!PyArg_ParseTuple(args, "OO", &ent, &other))
return NULL;
edict_t *pEnt = ParseEnt(ent);
edict_t *pEntOther = ParseEnt(other);
Py_XDECREF(ent);
Py_XDECREF(other);
if(pEnt && pEntOther)
(*other_gFunctionTable.pfnTouch)(pEnt, pEntOther);
Py_RETURN_NONE;
}
FUNC(dispatch_use) {
PyObject *ent, *other;
if(!PyArg_ParseTuple(args, "OO", &ent, &other))
return NULL;
edict_t *pEnt = ParseEnt(ent);
edict_t *pEntOther = ParseEnt(other);
if(pEnt && pEntOther)
(*other_gFunctionTable.pfnUse)(pEnt, pEntOther);
Py_RETURN_NONE;
}
FUNC(dispatch_think) {
PyObject *ent;
if(!PyArg_ParseTuple(args, "O", &ent))
return NULL;
edict_t *pEnt = ParseEnt(ent);
if(pEnt)
(*other_gFunctionTable.pfnThink)(pEnt);
Py_RETURN_NONE;
}
FUNC(get_entity_by_index) {
int index;
if(!PyArg_ParseTuple(args, "i", &index))
return NULL;
edict_t *pEnt = INDEXENT(index);
if(pEnt)
return Py_BuildValue("(ii)", ENTINDEX(pEnt), pEnt->serialnumber);
Py_RETURN_NONE;
}
void CreateEngineModule() {
PyObject *builtins = PyImport_ImportModule("builtins");
PyModuleDef eng_funcs = {PyModuleDef_HEAD_INIT, "eng", NULL, -1, methods, NULL, NULL, NULL, NULL};
PyObject *eng = PyModule_Create(&eng_funcs);
PyObject_SetAttrString(builtins, "eng", eng);;
}
void PyInitEngine() {
REG(AlertMessage, "");
REG(PrecacheModel, "");
REG(PrecacheSound, "");
REG(SetModel, "");
REG(ent_set, "");
REG(ent_get, "");
REG(CreateNamedEntity, "");
REG(RemoveEntity, "");
REG(get_player_by_name, "");
REG(ServerCmd, "");
REG(ClientCmd, "");
REG(SetOrigin, "");
REG(CvarSetFloat, "");
REG(CvarSetString, "");
REG(find_entity_by_classname, "");
REG(get_msg_id, "");
REG(send_message, "");
REG(is_player, "");
REG(is_valid, "");
REG(globals_get, "");
REG(MakeVector, "");
REG(GetPlayerAuthId, "");
REG(GetPlayerWONId, "");
REG(CreateEntity, "");
REG(dispatch_spawn, "");
REG(get_entity_by_index, "");
REG(dispatch_touch, "");
REG(dispatch_use, "");
REG(SetSize, "");
REG(FindEntityInSphere, "");
CreateEngineModule();
}
| [
"brtumbotbot@gmail.com"
] | brtumbotbot@gmail.com |
73ec91a2e2e412ceb2c4ce9e58477e997e138e8f | 4000e7fc82df36d483db739db5714ab144d8a5b2 | /DOTplatformio/packages/framework-arduinopsoc5/cores/CY8CKIT-059-SpeeduinoWBO2/USBUARTClass.cpp | 7c4f358a21cd4bb4ec80b96b6a5ff61995db60a0 | [] | no_license | J-f-Jensen/PSOC5 | db25f742be4ed95f41d8bf5a679f6335042cf040 | d99e58413b8fbd5f772649497b402754f93f1c77 | refs/heads/master | 2021-05-02T09:15:01.170635 | 2018-02-08T22:38:45 | 2018-02-08T22:38:45 | 120,818,692 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,270 | cpp | /*
Copyright (c) 2011 Arduino. All right reserved.
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "Arduino.h"
#include "USBUARTClass.h"
extern "C" {
#include <project.h>
}
// Wait for PC to configure USB for CONFIG_DELAY * CONFIG_LOOPS milliseconds
#define CONFIG_DELAY 10
#define CONFIG_LOOPS 200
bool USBUARTClass::_hasBegun = false;
//Required to load the class
USBUARTClass Serial(1);
// Public Methods //////////////////////////////////////////////////////////////
USBUARTClass::USBUARTClass(int)
{
}
void USBUARTClass::begin(const uint32_t dwBaudRate)
{
if (_hasBegun)
{
return;
}
_hasBegun = true;
_enableUSBCDC();
}
void USBUARTClass::end( void )
{
//Not implemented
}
int USBUARTClass::available( void )
{
buffer();
return _appBuffSize;
}
int USBUARTClass::peek( void )
{
buffer();
if (_appBuffSize > 0)
{
return _appBuffer[_appBuffIndex];
}
else
{
return -1;
}
}
int USBUARTClass::read( void )
{
buffer();
if (_appBuffSize > 0)
{
int temp = _appBuffer[_appBuffIndex++];
if (_appBuffIndex == _appBuffSize)
{
_appBuffIndex = 0;
_appBuffSize = 0;
}
return temp;
}
else
{
return -1;
}
}
void USBUARTClass::flush( void )
{
// Not implemented
}
uint8_t USBUARTClass::buffer( void )
{
uint8_t dataBufferSize = _usb_serial_CustomGetCount();
if (dataBufferSize > 0)
{
// We need to check if there is space in the buffer to recive data, if not then we have to wait until the buffer is read
if ((_appBuffSize + dataBufferSize) < 63)
{
USBUART_GetData((_appBuffer+_appBuffSize), dataBufferSize);
_appBuffSize += dataBufferSize;
}
}
return _appBuffSize;
}
size_t USBUARTClass::write( const uint8_t uc_data )
{
uint8_t delayCounter = 0;
/* wait for the port to be ready */
while (USBUART_CDCIsReady() == 0)
{
CyDelay(1);
delayCounter++;
if (delayCounter > 2000)
{
return 0;
}
}
/* Send data */
USBUART_PutChar(uc_data);
return 1;
}
// Private Methods //////////////////////////////////////////////////////////////
bool USBUARTClass::_enableUSBCDC()
{
_appBuffSize = 0;
_appBuffIndex = 0;
_timeout = 10;
USBUART_Start(0, USBUART_5V_OPERATION);
uint8_t delayCounter = 0;
/* It's important that we not loop forever here, or we'll never leave in
* cases where the device isn't plugged into a PC. We do, however, want to
* provide enough time for the PC to do its thing. */
while(USBUART_GetConfiguration() == 0)
{
CyDelay(100);
delayCounter++;
if (delayCounter > 20)
{
return false;
}
}
USBUART_CDC_Init();
return true;
}
size_t USBUARTClass::_usb_serial_readBuffer(const uint8_t* buffer, uint16_t size) // Read buffer methode
{
return 1;
}
size_t USBUARTClass::_usb_serial_write( const uint8_t* buffer, uint16_t size )
{
uint8_t retVal = 0;
uint16 internalTimeout = 2000;
uint8 packetsSent = 0;
uint8 numPackets = size/64;
uint8 lastPacketSize = size%64;
/* The sending loop. There are two limits on this:
1. We can't send data until the prior data transmission is done, so we have
to wait until USBUART_CDCIsReady() returns a non-zero value.
2. We can only send 64 bytes at a go.
*/
while (internalTimeout > 0)
{
if (USBUART_CDCIsReady() == 0)
{
CyDelay(1);
--internalTimeout;
continue;
}
/* Once here, we can send out our packets one at a time. There are three
cases:
1. More than 64 bytes to send, so do numPackets of 64 bytes followed by one
packet of lastPacketSize bytes.
2. 64 bytes to send, so do one packet of 64 bytes, then one packet of zero.
3. Less than 64 bytes, so do one packet of lastPacketSize bytes.
*/
else
{
if (numPackets > 0)
{
USBUART_PutData((buffer+(packetsSent*64)), 64);
++packetsSent;
--numPackets;
}
else if (numPackets == 0)
{
USBUART_PutData((buffer+(packetsSent*64)), lastPacketSize);
retVal = 1;
break;
}
}
}
return retVal;
}
int16_t USBUARTClass::_usb_serial_CustomGetCount()
{
uint16 internalTimeout = 15;
// loop to check for data more than once
while (internalTimeout > 0)
{
if (USBUART_DataIsReady() == 0)
{
CyDelay(1);
--internalTimeout;
continue;
}
else
{
return USBUART_GetCount();
}
}
// If we reach this then no data where recived
return 0;
} | [
"jens@2stroke4fun.dk"
] | jens@2stroke4fun.dk |
0910a844a94fe38fa8afa0b3059ac895bf58b0c4 | 52af73ad0ebdca6773b584ecf41afdff1cf2e4d9 | /game/source/hex/Coords.hpp | 0b68e0534777cf590c16c0466e8889c4960c5dfb | [
"MIT"
] | permissive | king-numsgil/project-callisto | 5cab8ffe96e2633c7c1acd7871ed3818bbcdd28c | d31b2e35efad132c09f0a633b162974b7763e97e | refs/heads/master | 2023-06-28T01:11:05.367546 | 2021-08-03T18:06:17 | 2021-08-03T18:06:17 | 239,848,771 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,476 | hpp | #pragma once
#include "../Types.hpp"
namespace hex
{
constexpr bool FLAT_TOPPED = false;
constexpr f32 RADIUS = 50.5f;
struct Axial;
struct Cubic;
struct Axial
{
Axial(Axial const&) noexcept = default;
Axial& operator=(Axial const&) noexcept = default;
Axial(Axial&&) noexcept = default;
Axial& operator=(Axial&&) noexcept = default;
inline Axial(i32 Q, i32 R) : data{Q, R}
{}
explicit Axial(Cubic const&);
explicit operator Cubic() const;
inline bool operator==(Axial const& other) const
{ return data == other.data; }
inline i32& q()
{ return data.x(); }
inline i32 q() const
{ return data.x(); }
inline i32& r()
{ return data.y(); }
inline i32 r() const
{ return data.y(); }
[[nodiscard]] f32vec2 to_position() const;
static Axial from_position(f32vec2 const& position);
i32vec2 data;
};
struct Cubic
{
Cubic(Cubic const&) noexcept = default;
Cubic& operator=(Cubic const&) noexcept = default;
Cubic(Cubic&&) noexcept = default;
Cubic& operator=(Cubic&&) noexcept = default;
inline Cubic(i32 X, i32 Y, i32 Z) : data{X, Y, Z}
{}
explicit Cubic(Axial const&);
explicit operator Axial() const;
inline bool operator==(Cubic const& other) const
{ return data == other.data; }
inline i32& x()
{ return data.x(); }
inline i32 x() const
{ return data.x(); }
inline i32& y()
{ return data.y(); }
inline i32 y() const
{ return data.y(); }
inline i32& z()
{ return data.z(); }
inline i32 z() const
{ return data.z(); }
i32vec3 data;
};
inline Debug& operator<<(Debug& debug, Axial const& value)
{
return debug << "hex.Axial("
<< Debug::nospace << value.q()
<< Debug::nospace << ","
<< Debug::nospace << value.r()
<< Debug::nospace << ")";
}
inline Debug& operator<<(Debug& debug, Cubic const& value)
{
return debug << "hex.Cubic("
<< Debug::nospace << value.x()
<< Debug::nospace << ","
<< Debug::nospace << value.y()
<< Debug::nospace << ","
<< Debug::nospace << value.z()
<< Debug::nospace << ")";
}
}
template<>
struct std::hash<hex::Axial>
{
hash() = default;
std::size_t operator()(hex::Axial const& key) const
{
std::size_t hash = 0;
hash_combine(hash, key.q());
hash_combine(hash, key.r());
return hash;
}
};
template<>
struct std::hash<hex::Cubic>
{
std::size_t operator()(hex::Cubic const& key) const
{
std::hash<hex::Axial> hasher;
return hasher(hex::Axial{key});
}
};
| [
"king@numsgil.co"
] | king@numsgil.co |
79c488f4c6e2ee7407e93655fa54de67bdc83a99 | 7033bdd7e67d1dc1e9547692dd9158d4ee0a3901 | /DataStructures/week6/bst_hard/main.cpp | 23abdd8a78529d4072463072ee1fb9fb844e3f8e | [] | no_license | anjanik012/CourseraDataStructureSpecialization | bc853cfe5b34dfcddf38270ee4826dfe3c07fd13 | 9c3ecbe8e8c1a1cddf3349d80964a792061b1d2c | refs/heads/master | 2021-01-04T06:21:00.205527 | 2020-02-14T04:31:45 | 2020-02-14T04:31:45 | 240,427,405 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,043 | cpp | #include <iostream>
#include <vector>
struct node_val {
int64_t key;
int left_child;
int right_child;
};
class binary_tree {
private:
struct node {
int64_t key;
node *left_child;
node *right_child;
};
node *nodes;
node *root;
int64_t temp;
bool is_bst = true;
public:
binary_tree(const int &n, const std::vector<node_val> &values) {
nodes = new node[n];
root = &nodes[0];
temp = INT64_MIN;
const int k = values[0].key;
for (int i = 0; i < n; ++i) {
nodes[i].key = values[i].key;
if (values[i].left_child >= 0)
nodes[i].left_child = &nodes[values[i].left_child];
else
nodes[i].left_child = nullptr;
if (values[i].right_child >= 0)
nodes[i].right_child = &nodes[values[i].right_child];
else
nodes[i].right_child = nullptr;
}
}
// void in_order_left(const node *r) {
// if (r == nullptr)
// return;
// in_order_left(r->left_child);
//
// if (!is_bst)
// return;
//
// if (r->key > temp) {
// temp = r->key;
// } else {
// is_bst = false;
// return;
// }
// in_order_left(r->right_child);
// }
//
// void in_order_right(const node *r) {
// if (r == nullptr)
// return;
// in_order_right(r->left_child);
//
// if (!is_bst)
// return;
//
// if (r->left_child != nullptr){
// if (r->key <= temp){
// is_bst = false;
// return;
// }
// }
//
// if (r->key >= temp){
// temp = r->key;
// } else{
// is_bst = false;
// return;
// }
// in_order_right(r->right_child);
// }
int64_t in_order_left(node *r) {
if (r->left_child == nullptr && r->right_child == nullptr)
return r->key;
int64_t r_max, l_min;
r_max = in_order_left(r->left_child);
temp = r->key;
if (temp <= r_max) {
is_bst = false;
return INT64_MIN;
}
l_min = in_order_right(r->right_child);
return r_max;
}
int64_t in_order_right(node *r) {
}
bool is_bst_f() {
in_order_left(root->left_child);
if (!is_bst)
return false;
if (root->key > temp)
temp = root->key;
else
return false;
in_order_right(root->right_child);
return is_bst;
}
};
int main() {
int n;
std::cin >> n;
if (n == 0) {
std::cout << "CORRECT";
return 0;
}
std::vector<node_val> val(n);
for (int i = 0; i < n; ++i) {
std::cin >> val[i].key >> val[i].left_child >> val[i].right_child;
}
binary_tree tree(n, val);
if (tree.is_bst_f())
std::cout << "CORRECT";
else
std::cout << "INCORRECT";
return 0;
} | [
"anjanik012@gmail.com"
] | anjanik012@gmail.com |
8d3bd034a6f9e61e59cbaf2128f71aaf4f4586f3 | 89510ae111005fba86f9aa2bc20ea9ba8cd0a6f0 | /Vjezbe_12/Analyzer.cpp | 78ca39d7b2c8ff0ed27f81e781dd813c72f54d0b | [] | no_license | IvnaBakovic/AnalizaHEP_Vjezbe | 276cb97b6d78a1f92a0b653db7f31223ed1c0b18 | b299b0611926b0df5375395be1316f46618fe2dc | refs/heads/master | 2021-08-08T04:00:56.674810 | 2020-09-01T05:59:05 | 2020-09-01T05:59:05 | 215,956,102 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,771 | cpp | #define Analyzer_cxx
#include "Analyzer.h"
#include <TH2.h>
#include <TStyle.h>
#include <TCanvas.h>
void Analyzer::Loop()
{
TLegend *legend;
TCanvas *c = new TCanvas("c", "c", 900, 900);
histoSignal[0] = new TH1F("0","",50,0,100.);
histoSignal[1] = new TH1F("1","",50,-1.5,3);
histoSignal[2] = new TH1F("3","",50,0.,0.1);
histoSignal[3] = new TH1F("3","",50,0.,5.);
histoSignal[4] = new TH1F("4","",50,0.,1.);
histoSignal[5] = new TH1F("5","",50,0.,5.);
histoSignal[6] = new TH1F("6","",50,0.,5.);
histoSignal[7] = new TH1F("7","",100,0,10);
histoBackground[0] = new TH1F("8","",50,0.,100.);
histoBackground[1] = new TH1F("9","",50,-1.5,3);
histoBackground[2] = new TH1F("10","",50,0,0.5);
histoBackground[3] = new TH1F("11","",50,0.,1.);
histoBackground[4] = new TH1F("12","",50,0.,1.);
histoBackground[5] = new TH1F("13","",50,0.,5.);
histoBackground[6] = new TH1F("14","",50,0.,5.);
histoBackground[7] = new TH1F("15","",100,0,10);
//ele_pt, scl_eta, ele_hadronicOverEm, ele_gsfchi2, ele_fbrem, ele_ep, ele_eelepout i ele_pfChargedHadIso
Init(signal);
Long64_t nentries = fChain->GetEntriesFast();
Long64_t nbytes = 0, nb = 0;
for (Long64_t jentry=0; jentry<nentries;jentry++) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
nb = fChain->GetEntry(jentry); nbytes += nb;
histoSignal[0]->Fill(ele_pt);
histoSignal[1]->Fill(scl_eta);
histoSignal[2]->Fill(ele_hadronicOverEm);
histoSignal[3]->Fill(ele_gsfchi2);
histoSignal[4]->Fill(ele_fbrem);
histoSignal[5]->Fill(ele_ep);
histoSignal[6]->Fill(ele_eelepout);
histoSignal[7]->Fill(ele_pfChargedHadIso);
}
Init(background);
nentries = fChain->GetEntriesFast();
nbytes = 0, nb = 0;
for (Long64_t jentry=0; jentry<nentries;jentry++) {
Long64_t ientry = LoadTree(jentry);
if (ientry < 0) break;
nb = fChain->GetEntry(jentry); nbytes += nb;
// if (Cut(ientry) < 0) continue;
histoBackground[0]->Fill(ele_pt);
histoBackground[1]->Fill(scl_eta);
histoBackground[2]->Fill(ele_hadronicOverEm);
histoBackground[3]->Fill(ele_gsfchi2);
histoBackground[4]->Fill(ele_fbrem);
histoBackground[5]->Fill(ele_ep);
histoBackground[6]->Fill(ele_eelepout);
histoBackground[7]->Fill(ele_pfChargedHadIso);
}
for(int i = 0; i < 8; i++)
{
histoSignal[i]->SetStats(0);
histoBackground[i]->SetStats(0);
}
c->Divide(2,4);
c->cd(1);
gPad->SetLeftMargin(0.2);
gPad->SetBottomMargin(0.2);
histoBackground[0]->SetLineColor(kRed);
histoSignal[0]->GetXaxis()->SetTitle("ele_pt");
histoSignal[0]->GetYaxis()->SetTitle("Events");
histoSignal[0]->GetYaxis()->SetTitleOffset(1.8);
if ( histoBackground[0]->GetMaximum() > histoSignal[0]->GetMaximum()) histoSignal[0]->SetMaximum(1.3*histoBackground[0]->GetMaximum());
histoSignal[0]->Draw();
histoBackground[0]->Draw("SAME");
legend = CreateLegend(histoSignal[0],histoBackground[0]);
legend->Draw();
c->cd(2);
gPad->SetLeftMargin(0.2);
gPad->SetBottomMargin(0.2);
histoBackground[1]->SetLineColor(kRed);
histoSignal[1]->GetXaxis()->SetTitle("scl_eta");
histoSignal[1]->GetYaxis()->SetTitle("Events");
histoSignal[1]->GetYaxis()->SetTitleOffset(1.8);
if ( histoBackground[1]->GetMaximum() > histoSignal[1]->GetMaximum()) histoSignal[1]->SetMaximum(1.3*histoBackground[1]->GetMaximum());
histoSignal[1]->Draw();
histoBackground[1]->Draw("SAME");
legend = CreateLegend(histoSignal[0],histoBackground[0]);
legend->Draw();
c->cd(3);
gPad->SetLeftMargin(0.2);
gPad->SetBottomMargin(0.2);
histoBackground[2]->SetLineColor(kRed);
histoSignal[2]->GetXaxis()->SetTitle("ele_hadronicOverEm");
histoSignal[2]->GetYaxis()->SetTitle("Events");
histoSignal[2]->GetYaxis()->SetTitleOffset(1.8);
if ( histoBackground[2]->GetMaximum() > histoSignal[2]->GetMaximum()) histoSignal[2]->SetMaximum(1.3*histoBackground[2]->GetMaximum());
histoSignal[2]->Draw();
histoBackground[2]->Draw("SAME");
legend = CreateLegend(histoSignal[0],histoBackground[0]);
legend->Draw();
c->cd(4);
gPad->SetLeftMargin(0.2);
gPad->SetBottomMargin(0.2);
histoBackground[3]->SetLineColor(kRed);
histoSignal[3]->GetXaxis()->SetTitle("ele_gsfchi2)");
histoSignal[3]->GetYaxis()->SetTitle("Events");
histoSignal[3]->GetYaxis()->SetTitleOffset(1.8);
if ( histoBackground[3]->GetMaximum() > histoSignal[3]->GetMaximum()) histoSignal[3]->SetMaximum(1.3*histoBackground[3]->GetMaximum());
histoSignal[3]->Draw();
histoBackground[3]->Draw("SAME");
legend = CreateLegend(histoSignal[0],histoBackground[0]);
legend->Draw();
c->cd(5);
gPad->SetLeftMargin(0.2);
gPad->SetBottomMargin(0.2);
histoBackground[4]->SetLineColor(kRed);
histoSignal[4]->GetXaxis()->SetTitle("ele_fbrem");
histoSignal[4]->GetYaxis()->SetTitle("Events");
histoSignal[4]->GetYaxis()->SetTitleOffset(1.8);
if ( histoBackground[4]->GetMaximum() > histoSignal[4]->GetMaximum()) histoSignal[4]->SetMaximum(1.3*histoBackground[4]->GetMaximum());
histoSignal[4]->Draw();
histoBackground[4]->Draw("SAME");
legend = CreateLegend(histoSignal[0],histoBackground[0]);
legend->Draw();
c->cd(6);
gPad->SetLeftMargin(0.2);
gPad->SetBottomMargin(0.2);
histoBackground[5]->SetLineColor(kRed);
histoSignal[5]->GetXaxis()->SetTitle("ele_ep");
histoSignal[5]->GetYaxis()->SetTitle("Events");
histoSignal[5]->GetYaxis()->SetTitleOffset(1.8);
if ( histoBackground[5]->GetMaximum() > histoSignal[5]->GetMaximum()) histoSignal[5]->SetMaximum(1.3*histoBackground[5]->GetMaximum());
histoSignal[5]->Draw();
histoBackground[5]->Draw("SAME");
legend = CreateLegend(histoSignal[0],histoBackground[0]);
legend->Draw();
c->cd(7);
gPad->SetLeftMargin(0.2);
gPad->SetBottomMargin(0.2);
histoBackground[6]->SetLineColor(kRed);
histoSignal[6]->GetXaxis()->SetTitle("ele_eelepout");
histoSignal[6]->GetYaxis()->SetTitle("Events");
histoSignal[6]->GetYaxis()->SetTitleOffset(1.8);
if ( histoBackground[6]->GetMaximum() > histoSignal[6]->GetMaximum()) histoSignal[6]->SetMaximum(1.3*histoBackground[6]->GetMaximum());
histoSignal[6]->Draw();
histoBackground[6]->Draw("SAME");
legend = CreateLegend(histoSignal[0],histoBackground[0]);
legend->Draw();
c->cd(8);
gPad->SetLeftMargin(0.2);
gPad->SetBottomMargin(0.2);
histoBackground[7]->SetLineColor(kRed);
histoSignal[7]->GetXaxis()->SetTitle("ele_pfChargedHadIso");
histoSignal[7]->GetYaxis()->SetTitle("Events");
histoSignal[7]->GetYaxis()->SetTitleOffset(1.8);
if ( histoBackground[7]->GetMaximum() > histoSignal[7]->GetMaximum()) histoSignal[7]->SetMaximum(1.3*histoBackground[7]->GetMaximum());
histoSignal[7]->Draw();
histoBackground[7]->Draw("SAME");
legend = CreateLegend(histoSignal[0],histoBackground[0]);
legend->Draw();
c->SaveAs("elektronskeVarijable.pdf");
}
TLegend* Analyzer::CreateLegend(TH1F *histo1, TH1F *histo2)
{
TLegend *leg;
leg = new TLegend(0.7,0.7,0.9,0.9);
leg->AddEntry(histo1, "Signal", "f");
leg->AddEntry(histo2, "Background", "f");
leg->SetTextSize(0.03);
return leg;
}
void Analyzer::MVATraining(TString metoda)
{
TMVA::Tools::Instance();
// Here the preparation phase begins
// Read training and test data
// (it is also possible to use ASCII format as input -> see TMVA Users Guide)
TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject("/home/public/data/ElectronTraining/Electrons.root");
if (!f || !f->IsOpen()) {
f = new TFile("/home/public/data/ElectronTraining/Electrons.root");
}
TTree *signalTree ;
TTree *background ;
f->GetObject("signal",signalTree);
Init(signalTree);
f->GetObject("background",background);
Init(background);
// Create a ROOT output file where TMVA will store ntuples, histograms, etc.
TString outfileName( "TMVA.root" );
TFile* outputFile = TFile::Open( outfileName, "RECREATE" );
// Create the factory object. Later you can choose the methods
// whose performance you'd like to investigate. The factory is
// the only TMVA object you have to interact with
//
// The first argument is the base of the name of all the
// weightfiles in the directory weight/
//
// The second argument is the output file for the training results
// All TMVA output can be suppressed by removing the "!" (not) in
// front of the "Silent" argument in the option string
TMVA::Factory *factory = new TMVA::Factory( "TMVAClassification", outputFile,
"!V:!Silent:Color:DrawProgressBar:Transformations=I;D;P;G,D:AnalysisType=Classification" );
TMVA::DataLoader *dataloader=new TMVA::DataLoader("dataset");
// If you wish to modify default settings
// (please check "src/Config.h" to see all available global options)
//
// (TMVA::gConfig().GetVariablePlotting()).fTimesRMS = 8.0;
// (TMVA::gConfig().GetIONames()).fWeightFileDir = "myWeightDirectory";
// Define the input variables that shall be used for the MVA training
// note that you may also use variable expressions, such as: "3*var1/var2*abs(var3)"
// [all types of expressions that can also be parsed by TTree::Draw( "expression" )]
dataloader->AddVariable( "ele_pt","var_1","", 'F' );
dataloader->AddVariable( "scl_eta", "var_2", "", 'F' );
dataloader->AddVariable( "ele_fbrem", "var_3", "", 'F' );
// You can add an arbitrary number of signal or background trees
dataloader->AddSignalTree ( signalTree, 1. );
dataloader->AddBackgroundTree( background, 1. );
dataloader->PrepareTrainingAndTestTree( "","",
"nTrain_Signal=1000:nTrain_Background=1000:SplitMode=Random:NormMode=NumEvents:!V" );
if (metoda=="MLP")
factory->BookMethod( dataloader, TMVA::Types::kMLP, "MLP", "H:!V:NeuronType=tanh:VarTransform=N:NCycles=600:HiddenLayers=N+5:TestRate=5:!UseRegulator" );
if (metoda=="BDTG") // Gradient Boost
factory->BookMethod( dataloader, TMVA::Types::kBDT, "BDTG",
"!H:!V:NTrees=1000:MinNodeSize=2.5%:BoostType=Grad:Shrinkage=0.10:UseBaggedBoost:BaggedSampleFraction=0.5:nCuts=20:MaxDepth=2" );
// For an example of the category classifier usage, see: TMVAClassificationCategory
//
// --------------------------------------------------------------------------------------------------
// Now you can optimize the setting (configuration) of the MVAs using the set of training events
// STILL EXPERIMENTAL and only implemented for BDT's !
//
// factory->OptimizeAllMethods("SigEffAt001","Scan");
// factory->OptimizeAllMethods("ROCIntegral","FitGA");
//
// --------------------------------------------------------------------------------------------------
// Now you can tell the factory to train, test, and evaluate the MVAs
//
// Train MVAs using the set of training events
factory->TrainAllMethods();
// Evaluate all MVAs using the set of test events
factory->TestAllMethods();
// Evaluate and compare performance of all configured MVAs
factory->EvaluateAllMethods();
// --------------------------------------------------------------
// Save the output
outputFile->Close();
std::cout << "==> Wrote root file: " << outputFile->GetName() << std::endl;
std::cout << "==> TMVAClassification is done!" << std::endl;
delete factory;
delete dataloader;
// Launch the GUI for the root macros
//if (!gROOT->IsBatch()) TMVA::TMVAGui( outfileName );
//return 0;
}
| [
"ibakovic@pmfst.hr"
] | ibakovic@pmfst.hr |
e0ce44c0f4923981d481cb5b1f9d5af805a9e246 | b29fc0fe77aa7ae6d2a3c2bc316528d9711c459d | /lab8.1/sleeper.cpp | 900bba289d848b5d44545d4d6d21bfb5be478190 | [] | no_license | Joe-Marchesini/CSI-230 | b5759e50a7d992725f7e9769978c952a771154e9 | df56cfe1f81340cf8b774f48d64b9c3b79919a06 | refs/heads/master | 2023-01-24T06:46:43.537795 | 2020-12-14T09:26:10 | 2020-12-14T09:26:10 | 299,462,842 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,771 | cpp | //Code copyed from geeksforgeeks.org
//Edited by: Joseph Marchesini
// CPP program to create a timer
#include <iomanip>
#include <iostream>
#include <stdlib.h>
#include <unistd.h>
using namespace std;
// hours, minutes, seconds of timer
int hours = 0;
int minutes = 0;
int seconds = 0;
// function to display the timer
void displayClock()
{
// system call to clear the screen
//system("clear");
cout << setfill(' ') << setw(55) << " TIMER \n";
cout << setfill(' ') << setw(55) << " --------------------------\n";
cout << setfill(' ') << setw(29);
cout << "| " << setfill('0') << setw(2) << hours << " hrs | ";
cout << setfill('0') << setw(2) << minutes << " min | ";
cout << setfill('0') << setw(2) << seconds << " sec |" << endl;
cout << setfill(' ') << setw(55) << " --------------------------\n";
}
void timer()
{
// infinte loop because timer will keep
// counting. To kill the process press
// Ctrl+D. If it does not work ask
// ubuntu for other ways.
while (true) {
// display the timer
displayClock();
// sleep system call to sleep
// for 1 second
sleep(30);
// increment seconds
seconds++;
// if seconds reaches 60
if (seconds == 60) {
// increment minutes
minutes++;
// if minutes reaches 60
if (minutes == 60) {
// increment hours
hours++;
minutes = 0;
}
seconds = 0;
}
}
}
// Driver Code
int main()
{
// start timer from 00:00:00
timer();
return 0;
}
| [
"joe@pop-os.localdomain"
] | joe@pop-os.localdomain |
190ae0b849f19ce6f8918a3ffed19a6cf2229278 | aa1bc5421bc961c9adb4bddb12bd1f85d851f7f7 | /Plancha 2/tags/nachOS/code/userprog/exception.cc | db736ae89580cb79a8f8b8742b6790b345c1c51d | [] | no_license | flor-rovere/nachOS | 9b5c313bc51081068402992b31e9c86faa71b09b | d28bc0eaaf7d0e07dc47a3a74cab897f5e37f916 | refs/heads/master | 2020-04-30T13:04:16.484048 | 2019-04-21T21:55:46 | 2019-04-21T21:55:46 | 119,183,056 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,089 | cc | /// Entry point into the Nachos kernel from user programs.
///
/// There are two kinds of things that can cause control to transfer back to
/// here from user code:
///
/// * System calls: the user code explicitly requests to call a procedure in
/// the Nachos kernel. Right now, the only function we support is `Halt`.
///
/// * Exceptions: the user code does something that the CPU cannot handle.
/// For instance, accessing memory that does not exist, arithmetic errors,
/// etc.
///
/// Interrupts (which can also cause control to transfer from user code into
/// the Nachos kernel) are handled elsewhere.
///
/// For now, this only handles the `Halt` system call. Everything else core
/// dumps.
///
/// Copyright (c) 1992-1993 The Regents of the University of California.
/// 2016-2017 Docentes de la Universidad Nacional de Rosario.
/// All rights reserved. See `copyright.h` for copyright notice and
/// limitation of liability and disclaimer of warranty provisions.
#include "syscall.h"
#include "threads/system.hh"
/// Entry point into the Nachos kernel. Called when a user program is
/// executing, and either does a syscall, or generates an addressing or
/// arithmetic exception.
///
/// For system calls, the following is the calling convention:
///
/// * system call code in `r2`;
/// * 1st argument in `r4`;
/// * 2nd argument in `r5`;
/// * 3rd argument in `r6`;
/// * 4th argument in `r7`;
/// * the result of the system call, if any, must be put back into `r2`.
///
/// And do not forget to increment the pc before returning. (Or else you will
/// loop making the same system call forever!)
///
/// * `which` is the kind of exception. The list of possible exceptions is
/// in `machine.hh`.
void
ExceptionHandler(ExceptionType which)
{
int type = machine->ReadRegister(2);
if (which == SYSCALL_EXCEPTION && type == SC_Halt) {
DEBUG('a', "Shutdown, initiated by user program.\n");
interrupt->Halt();
} else {
printf("Unexpected user mode exception %d %d\n", which, type);
ASSERT(false);
}
}
| [
"flor.rovere@gmail.com"
] | flor.rovere@gmail.com |
47d1e342ae30ecf31312296afe0a8701ffee66c8 | 0f95d79bc2c8160f19df05436c014ac35ff0f0be | /src/SQLInterpreter.cpp | 6981e1c51dec564f74f34fdc747351e2173ac603 | [] | no_license | houliang428/Database-Management-System | a4bc0454e770aced3c8788b234f99341cb1c25f1 | 37dcc80af9c8dfb2fbc01a363a55bef998b85fea | refs/heads/master | 2020-06-04T09:31:14.381131 | 2020-02-01T01:00:42 | 2020-02-01T01:00:42 | 191,967,569 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,437 | cpp | //
// SQLInterpreter.cpp
// Datatabase4
//
#include "SQLInterpreter.hpp"
#include "RGTokenizer.hpp"
#include "Storage.hpp"
#include "Statement.hpp"
#include "keywords.hpp"
#include "Database.hpp"
#include "Attribute.hpp"
#include "SQLStatement.hpp"
#include "Entity.hpp"
#include "RecordsView.hpp"
#include "EntityDescriptionView.hpp"
namespace ECE141 {
SQLInterpreter::SQLInterpreter(IInterpreter *aNext) : CommandProcessor(aNext) {}
SQLInterpreter::~SQLInterpreter() {}
// Final:----------------------------------------------------
StatusResult SQLInterpreter::alterTable(const std::string &aName,
const Attribute &anAttribute,
const std::string action) {
if(Database *theDatabase=getActiveDatabase()) {
if(Entity *theEntity=theDatabase->getEntity(aName)) {
return theDatabase->alterTable(*theEntity, anAttribute, action);
}
}
return StatusResult{unknownDatabase};
}
// USE: -----------------------------------------------------
StatusResult SQLInterpreter::createTable(Entity *anEntity) {
if(Database *theDatabase=getActiveDatabase()) {
if(anEntity) {
StatusResult theResult = theDatabase->createTable(anEntity);
if(theResult) {
std::cout << "tabled created\n";
return theResult;
}
return StatusResult{invalidCommand};
}
}
return StatusResult{unknownDatabase};
}
// USE: called when user requests rows to be deleted....
StatusResult SQLInterpreter::deleteRows(const std::string &aName, const Filters &aFilters) {
if(Database *theDatabase=getActiveDatabase()) {
if(Entity *theEntity=theDatabase->getEntity(aName)){
theDatabase->deleteRows(*theEntity, aFilters);
}
return StatusResult{noError};
}
return StatusResult{unknownDatabase};
}
StatusResult SQLInterpreter::describeTable(const std::string &aName, std::ostream &anOutput) {
if(Database *theDatabase=getActiveDatabase()) {
if(Entity *theEntity=theDatabase->getEntity(aName)) {
View *theView = new EntityDescriptionView(*theEntity);
theView->show(anOutput);
delete theView;
return StatusResult{noError};
}
return StatusResult{unknownTable};
}
return StatusResult{unknownDatabase};
}
// USE: -----------------------------------------------------
StatusResult SQLInterpreter::dropTable(const std::string &aName) {
if(Database *theDatabase=getActiveDatabase()) {
StatusResult theResult = theDatabase->dropTable(aName);
if(theResult) {
std::cout << "table dropped\n";
return theResult;
}
}
return StatusResult{unknownDatabase};
}
// USE: -----------------------------------------------------
StatusResult SQLInterpreter::insertRow(const Row &aRow, const std::string &aTableName) {
if(Database *theDatabase=getActiveDatabase()) {
return theDatabase->insertRow(aRow, aTableName);
}
return StatusResult{unknownDatabase};
}
// USE: called when user requests rows to be selected....
StatusResult SQLInterpreter::selectRows(const std::string &aName, const Filters &aFilters,
const PropertyList &anOrderBy) {
if(Database *theDatabase=getActiveDatabase()) {
if(Entity *theEntity=theDatabase->getEntity(aName)) {
RowCollection theCollection;
StatusResult theResult=theDatabase->selectRows(theCollection, *theEntity, aFilters);
if(anOrderBy.size()) {
theCollection.reorder(anOrderBy,*theEntity);
}
if(View *theView=new RecordsView(*theEntity, theCollection )) {
theView->show(std::cout);
delete theView;
}
return theResult;
}
}
return StatusResult{unknownDatabase};
}
StatusResult SQLInterpreter::updateRows(const std::string &aName, const KeyValues &aKeyValues,
const Filters &aFilters) {
StatusResult theResult{unknownDatabase};
if(Database *theDatabase=getActiveDatabase()) {
if(Entity *theEntity=theDatabase->getEntity(aName)) {
RowCollection theCollection;
if((theResult=theDatabase->selectRows(theCollection, *theEntity, aFilters))) {
RowList& theRows=theCollection.getRows();
for(auto *theRow : theRows) {
theResult=theDatabase->updateRow(*theRow, aKeyValues, *theEntity);
if(!theResult) break;
}
}
}
}
return theResult;
}
// USE: -----------------------------------------------------
StatusResult SQLInterpreter::showTables() {
if(Database *theDatabase=getActiveDatabase()) {
return theDatabase->showTables(std::cout);
}
return StatusResult{unknownDatabase};
}
//=========================================
// USE: called when a SQLStatement is parsed and runnable ------
StatusResult SQLInterpreter::interpret(const Statement &aStatement) {
return aStatement.run(std::cout);
}
// USE: retrieve a statement based on given text input...
Statement* SQLInterpreter::getStatement(Tokenizer &aTokenizer) {
Statement *theResult=nullptr;
if(aTokenizer.remaining()) {
Token theToken = aTokenizer.current();
switch(theToken.keyword) {
case Keywords::create_kw : theResult = new CreateTableStatement(*this); break;
case Keywords::drop_kw : theResult = new DropTableStatement(*this); break;
case Keywords::insert_kw : theResult = new InsertStatement(*this); break;
case Keywords::delete_kw : theResult = new DeleteStatement(*this); break;
case Keywords::update_kw : theResult = new UpdateStatement(*this); break;
case Keywords::select_kw : theResult = new SelectStatement(*this); break;
case Keywords::describe_kw: theResult = new DescribeStatement(*this); break;
case Keywords::show_kw: theResult = new ShowTablesStatement(*this); break;
//final
case Keywords::alter_kw : theResult = new AlterTableStatement(*this); break;
default: break;
}
if(theResult) {
StatusResult theError = theResult->parse(aTokenizer);
if(!theError) {
delete theResult;
theResult=nullptr;
}
}
}
return theResult;
}
}
| [
"houliang428@vip.qq.com"
] | houliang428@vip.qq.com |
70daa6c2522a13525b3ef48e30b8590256bb6c12 | 4c39da55f95234462f361199c6d857db2f38b035 | /xtd/text/utf8_codepoint.h | d21b3e20115f68c12e5285cb81d49ea3578b8def | [
"MIT"
] | permissive | tlawlor/gtoolbox | 7e804411a09c91f5fa756366343f7fd692a9f25d | 7174b41ef450ab99ce4071c60226e4fd48649f3c | refs/heads/master | 2020-12-30T23:22:26.471070 | 2014-12-30T18:47:10 | 2014-12-30T18:47:10 | 28,737,560 | 0 | 0 | null | 2015-01-03T07:08:40 | 2015-01-03T07:08:39 | null | UTF-8 | C++ | false | false | 4,391 | h | #pragma once
#include <zna/source/thirdParty/gtoolbox/xtd/text/utf32_codepoint.h>
namespace xtd {
class utf8_codepoint
{
char _data[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
size_t _size = 0;
public: // structors
utf8_codepoint() = default;
public: // operators
bool operator () (const char32_t);
bool operator () (const char32_t*&);
bool operator () (const char16_t*&);
bool operator () (const char*&);
const char& operator [] (size_t i) const { return _data[i]; }
template <typename Stream>
auto operator << (Stream& s)
-> decltype(s << 0) const
{ return s.write(_data, _size); }
public: // properties
const char* data() const { return _data; }
bool is_valid() const
{
return (_size > 0) & is_valid_codepoint(_data);
}
size_t size() const { return _size; }
public: // iterators
const char* begin() const { return _data; }
const char* end() const { return _data + _size; }
};
//--------------------------------------------------------------------------
inline bool utf8_codepoint::operator()(const char32_t c)
{
const bool c_le_0x0000007F = (c <= 0x0000007F);
const bool c_le_0x000007FF = (c <= 0x000007FF);
const bool c_le_0x0000FFFF = (c <= 0x0000FFFF);
const bool c_le_0x0010FFFF = (c <= 0x0010FFFF);
const bool is_size_1 = c_le_0x0000007F;
const bool is_size_2 = c_le_0x000007FF & not c_le_0x0000007F;
const bool is_size_3 = c_le_0x0000FFFF & not c_le_0x000007FF;
const bool is_size_4 = c_le_0x0010FFFF & not c_le_0x0000FFFF;
const size_t size =
(is_size_1 * 1) +
(is_size_2 * 2) +
(is_size_3 * 3) +
(is_size_4 * 4);
const bool is_legible = (size > 0);
_data[0] =
(is_size_1 * (c)) +
(is_size_2 * (0xC0 + (c >> 6))) +
(is_size_3 * (0xE0 + (c >> 12))) +
(is_size_4 * (0xF0 + (c >> 18)));
_data[1] =
(is_size_2 * (0x80 + (0x3F & (c)))) +
(is_size_3 * (0x80 + (0x3F & (c >> 6)))) +
(is_size_4 * (0x80 + (0x3F & (c >> 12))));
_data[2] =
(is_size_3 * (0x80 + (0x3F & (c)))) +
(is_size_4 * (0x80 + (0x3F & (c >> 6))));
_data[3] =
(is_size_4 * (0x80 + (0x3F & (c))));
_size = size;
return is_legible;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
inline bool utf8_codepoint::operator()(const char32_t*& p)
{
const char32_t c = p[0];
const bool is_legible = operator()(c);
p += is_legible;
return is_legible;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
inline bool utf8_codepoint::operator()(const char16_t*& p)
{
char32_t c;
const size_t utf16_size = to_codepoint(c, p);
const bool is_legible_utf16 = (utf16_size > 0);
const bool is_legible_utf32 = operator()(c);
const bool is_legible = is_legible_utf16 & is_legible_utf32;
_size *= is_legible;
p += is_legible * utf16_size;
return is_legible;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
inline bool utf8_codepoint::operator()(const char*& p)
{
const char c0 = p[0];
const char c1 = p[1];
const char c2 = p[2];
const char c3 = p[3];
const bool is_size_1 = ((c0 & 0x80) == 0x00); // 0xxx xxxx
const bool is_size_2 = ((c0 & 0xE0) == 0xC0); // 110x xxxx
const bool is_size_3 = ((c0 & 0xF0) == 0xE0); // 1110 xxxx
const bool is_size_4 = ((c0 & 0xF8) == 0xF0); // 1111 0xxx
const size_t size =
(is_size_1 * 1) +
(is_size_2 * 2) +
(is_size_3 * 3) +
(is_size_4 * 4);
const bool is_legible = (size > 0);
_data[0] = (size >= 1) * c0;
_data[1] = (size >= 2) * c1;
_data[2] = (size >= 3) * c2;
_data[3] = (size >= 4) * c3;
_size = size;
p += size;
return is_legible;
}
//--------------------------------------------------------------------------
} // namespace xtd
| [
"garett@z2live.com"
] | garett@z2live.com |
707628f05f48aef6acc2a04c6a3a48121daeefd9 | 6c6adb4ca7cad1db844d1126e41850630398e3df | /src/test/rpc_wallet_tests.cpp | 8280314442656f5e67848c84fc4896a555b7bc8c | [
"MIT"
] | permissive | LordSoylent/qynocoin | b56b29f66f73ce52d424ef4dbbad5b079cb03bd2 | 26769d233e34499282bf469915fdc5c46ef3d22c | refs/heads/master | 2020-03-28T11:30:51.764327 | 2018-08-12T18:23:49 | 2018-08-12T18:23:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,514 | cpp | // Copyright (c) 2013-2015 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "rpc/server.h"
#include "rpc/client.h"
#include "base58.h"
#include "validation.h"
#include "wallet/wallet.h"
#include "test/test_qyno.h"
#include <boost/algorithm/string.hpp>
#include <boost/test/unit_test.hpp>
#include <univalue.h>
using namespace std;
extern UniValue createArgs(int nRequired, const char* address1 = NULL, const char* address2 = NULL);
extern UniValue CallRPC(string args);
extern CWallet* pwalletMain;
BOOST_FIXTURE_TEST_SUITE(rpc_wallet_tests, TestingSetup)
BOOST_AUTO_TEST_CASE(rpc_addmultisig)
{
rpcfn_type addmultisig = tableRPC["addmultisigaddress"]->actor;
// old, 65-byte-long:
const char address1Hex[] = "0434e3e09f49ea168c5bbf53f877ff4206923858aab7c7e1df25bc263978107c95e35065a27ef6f1b27222db0ec97e0e895eaca603d3ee0d4c060ce3d8a00286c8";
// new, compressed:
const char address2Hex[] = "0388c2037017c62240b6b72ac1a2a5f94da790596ebd06177c8572752922165cb4";
UniValue v;
CBitcoinAddress address;
BOOST_CHECK_NO_THROW(v = addmultisig(createArgs(1, address1Hex), false));
address.SetString(v.get_str());
BOOST_CHECK(address.IsValid() && address.IsScript());
BOOST_CHECK_NO_THROW(v = addmultisig(createArgs(1, address1Hex, address2Hex), false));
address.SetString(v.get_str());
BOOST_CHECK(address.IsValid() && address.IsScript());
BOOST_CHECK_NO_THROW(v = addmultisig(createArgs(2, address1Hex, address2Hex), false));
address.SetString(v.get_str());
BOOST_CHECK(address.IsValid() && address.IsScript());
BOOST_CHECK_THROW(addmultisig(createArgs(0), false), runtime_error);
BOOST_CHECK_THROW(addmultisig(createArgs(1), false), runtime_error);
BOOST_CHECK_THROW(addmultisig(createArgs(2, address1Hex), false), runtime_error);
BOOST_CHECK_THROW(addmultisig(createArgs(1, ""), false), runtime_error);
BOOST_CHECK_THROW(addmultisig(createArgs(1, "NotAValidPubkey"), false), runtime_error);
string short1(address1Hex, address1Hex + sizeof(address1Hex) - 2); // last byte missing
BOOST_CHECK_THROW(addmultisig(createArgs(2, short1.c_str()), false), runtime_error);
string short2(address1Hex + 1, address1Hex + sizeof(address1Hex)); // first byte missing
BOOST_CHECK_THROW(addmultisig(createArgs(2, short2.c_str()), false), runtime_error);
}
BOOST_AUTO_TEST_CASE(rpc_wallet)
{
// Test RPC calls for various wallet statistics
UniValue r;
CPubKey demoPubkey;
CBitcoinAddress demoAddress;
UniValue retValue;
string strAccount = "walletDemoAccount";
CBitcoinAddress setaccountDemoAddress;
{
LOCK(pwalletMain->cs_wallet);
demoPubkey = pwalletMain->GenerateNewKey(0, false);
demoAddress = CBitcoinAddress(CTxDestination(demoPubkey.GetID()));
string strPurpose = "receive";
BOOST_CHECK_NO_THROW({ /*Initialize Wallet with an account */
CWalletDB walletdb(pwalletMain->strWalletFile);
CAccount account;
account.vchPubKey = demoPubkey;
pwalletMain->SetAddressBook(account.vchPubKey.GetID(), strAccount, strPurpose);
walletdb.WriteAccount(strAccount, account);
});
CPubKey setaccountDemoPubkey = pwalletMain->GenerateNewKey(0, false);
setaccountDemoAddress = CBitcoinAddress(CTxDestination(setaccountDemoPubkey.GetID()));
}
/*********************************
* setaccount
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("setaccount " + setaccountDemoAddress.ToString() + " nullaccount"));
/* XnhQgp2Y11hPGWaCB7rdGF5xLxjf2kBZCb is not owned by the test wallet. */
BOOST_CHECK_THROW(CallRPC("setaccount XnhQgp2Y11hPGWaCB7rdGF5xLxjf2kBZCb nullaccount"), runtime_error);
BOOST_CHECK_THROW(CallRPC("setaccount"), runtime_error);
/* XnhQgp2Y11hPGWaCB7rdGF5xLxjf2kBZC (33 chars) is an illegal address (should be 34 chars) */
BOOST_CHECK_THROW(CallRPC("setaccount XnhQgp2Y11hPGWaCB7rdGF5xLxjf2kBZC nullaccount"), runtime_error);
/*********************************
* getbalance
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("getbalance"));
BOOST_CHECK_NO_THROW(CallRPC("getbalance " + demoAddress.ToString()));
/*********************************
* listunspent
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("listunspent"));
BOOST_CHECK_THROW(CallRPC("listunspent string"), runtime_error);
BOOST_CHECK_THROW(CallRPC("listunspent 0 string"), runtime_error);
BOOST_CHECK_THROW(CallRPC("listunspent 0 1 not_array"), runtime_error);
BOOST_CHECK_THROW(CallRPC("listunspent 0 1 [] extra"), runtime_error);
BOOST_CHECK_NO_THROW(r = CallRPC("listunspent 0 1 []"));
BOOST_CHECK(r.get_array().empty());
/*********************************
* listreceivedbyaddress
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaddress"));
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaddress 0"));
BOOST_CHECK_THROW(CallRPC("listreceivedbyaddress not_int"), runtime_error);
BOOST_CHECK_THROW(CallRPC("listreceivedbyaddress 0 not_bool"), runtime_error);
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaddress 0 true"));
BOOST_CHECK_THROW(CallRPC("listreceivedbyaddress 0 true extra"), runtime_error);
/*********************************
* listreceivedbyaccount
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaccount"));
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaccount 0"));
BOOST_CHECK_THROW(CallRPC("listreceivedbyaccount not_int"), runtime_error);
BOOST_CHECK_THROW(CallRPC("listreceivedbyaccount 0 not_bool"), runtime_error);
BOOST_CHECK_NO_THROW(CallRPC("listreceivedbyaccount 0 true"));
BOOST_CHECK_THROW(CallRPC("listreceivedbyaccount 0 true extra"), runtime_error);
/*********************************
* listsinceblock
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("listsinceblock"));
/*********************************
* listtransactions
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("listtransactions"));
BOOST_CHECK_NO_THROW(CallRPC("listtransactions " + demoAddress.ToString()));
BOOST_CHECK_NO_THROW(CallRPC("listtransactions " + demoAddress.ToString() + " 20"));
BOOST_CHECK_NO_THROW(CallRPC("listtransactions " + demoAddress.ToString() + " 20 0"));
BOOST_CHECK_THROW(CallRPC("listtransactions " + demoAddress.ToString() + " not_int"), runtime_error);
/*********************************
* listlockunspent
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("listlockunspent"));
/*********************************
* listaccounts
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("listaccounts"));
/*********************************
* listaddressgroupings
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("listaddressgroupings"));
/*********************************
* getrawchangeaddress
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("getrawchangeaddress"));
/*********************************
* getnewaddress
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("getnewaddress"));
BOOST_CHECK_NO_THROW(CallRPC("getnewaddress getnewaddress_demoaccount"));
/*********************************
* getaccountaddress
*********************************/
BOOST_CHECK_NO_THROW(CallRPC("getaccountaddress \"\""));
BOOST_CHECK_NO_THROW(CallRPC("getaccountaddress accountThatDoesntExists")); // Should generate a new account
BOOST_CHECK_NO_THROW(retValue = CallRPC("getaccountaddress " + strAccount));
BOOST_CHECK(CBitcoinAddress(retValue.get_str()).Get() == demoAddress.Get());
/*********************************
* getaccount
*********************************/
BOOST_CHECK_THROW(CallRPC("getaccount"), runtime_error);
BOOST_CHECK_NO_THROW(CallRPC("getaccount " + demoAddress.ToString()));
/*********************************
* signmessage + verifymessage
*********************************/
BOOST_CHECK_NO_THROW(retValue = CallRPC("signmessage " + demoAddress.ToString() + " mymessage"));
BOOST_CHECK_THROW(CallRPC("signmessage"), runtime_error);
/* Should throw error because this address is not loaded in the wallet */
BOOST_CHECK_THROW(CallRPC("signmessage Xywgfc872nn5CKtpATCoAjZCc4v96pJczy mymessage"), runtime_error);
/* missing arguments */
BOOST_CHECK_THROW(CallRPC("verifymessage " + demoAddress.ToString()), runtime_error);
BOOST_CHECK_THROW(CallRPC("verifymessage " + demoAddress.ToString() + " " + retValue.get_str()), runtime_error);
/* Illegal address */
BOOST_CHECK_THROW(CallRPC("verifymessage XnhQgp2Y11hPGWaCB7rdGF5xLxjf2kBZC " + retValue.get_str() + " mymessage"), runtime_error);
/* wrong address */
BOOST_CHECK(CallRPC("verifymessage XnhQgp2Y11hPGWaCB7rdGF5xLxjf2kBZCb " + retValue.get_str() + " mymessage").get_bool() == false);
/* Correct address and signature but wrong message */
BOOST_CHECK(CallRPC("verifymessage " + demoAddress.ToString() + " " + retValue.get_str() + " wrongmessage").get_bool() == false);
/* Correct address, message and signature*/
BOOST_CHECK(CallRPC("verifymessage " + demoAddress.ToString() + " " + retValue.get_str() + " mymessage").get_bool() == true);
/*********************************
* getaddressesbyaccount
*********************************/
BOOST_CHECK_THROW(CallRPC("getaddressesbyaccount"), runtime_error);
BOOST_CHECK_NO_THROW(retValue = CallRPC("getaddressesbyaccount " + strAccount));
UniValue arr = retValue.get_array();
BOOST_CHECK(arr.size() > 0);
BOOST_CHECK(CBitcoinAddress(arr[0].get_str()).Get() == demoAddress.Get());
/*********************************
* fundrawtransaction
*********************************/
BOOST_CHECK_THROW(CallRPC("fundrawtransaction 28z"), runtime_error);
BOOST_CHECK_THROW(CallRPC("fundrawtransaction 01000000000180969800000000001976a91450ce0a4b0ee0ddeb633da85199728b940ac3fe9488ac00000000"), runtime_error);
}
BOOST_AUTO_TEST_SUITE_END()
| [
"contact@qyno.org"
] | contact@qyno.org |
f57b55a3bf6e65631c47a10396b4a7373118ef1c | ba0cbdae81c171bd4be7b12c0594de72bd6d625a | /MyToontown/Panda3D-1.9.0/include/loaderFileType.h | 3445edba2663b169fd765711887f0c9302c04730 | [
"BSD-3-Clause",
"BSD-2-Clause"
] | permissive | sweep41/Toontown-2016 | 65985f198fa32a832e762fa9c59e59606d6a40a3 | 7732fb2c27001264e6dd652c057b3dc41f9c8a7d | refs/heads/master | 2021-01-23T16:04:45.264205 | 2017-06-04T02:47:34 | 2017-06-04T02:47:34 | 93,279,679 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,559 | h | // Filename: loaderFileType.h
// Created by: drose (20Jun00)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University. All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license. You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
#ifndef LOADERFILETYPE_H
#define LOADERFILETYPE_H
#include "pandabase.h"
#include "typedObject.h"
#include "filename.h"
#include "pandaNode.h"
#include "pointerTo.h"
#include "dSearchPath.h"
class LoaderOptions;
class BamCacheRecord;
////////////////////////////////////////////////////////////////////
// Class : LoaderFileType
// Description : This is the base class for a family of scene-graph
// file types that the Loader supports. Each kind of
// loader that's available should define a corresponding
// LoaderFileType object and register itself.
////////////////////////////////////////////////////////////////////
class EXPCL_PANDA_PGRAPH LoaderFileType : public TypedObject {
protected:
LoaderFileType();
public:
virtual ~LoaderFileType();
PUBLISHED:
virtual string get_name() const=0;
virtual string get_extension() const=0;
virtual string get_additional_extensions() const;
virtual bool supports_compressed() const;
virtual bool get_allow_disk_cache(const LoaderOptions &options) const;
virtual bool get_allow_ram_cache(const LoaderOptions &options) const;
virtual bool supports_load() const;
virtual bool supports_save() const;
public:
virtual PT(PandaNode) load_file(const Filename &path, const LoaderOptions &options,
BamCacheRecord *record) const;
virtual bool save_file(const Filename &path, const LoaderOptions &options,
PandaNode *node) const;
protected:
int _no_cache_flags;
public:
static TypeHandle get_class_type() {
return _type_handle;
}
static void init_type() {
TypedObject::init_type();
register_type(_type_handle, "LoaderFileType",
TypedObject::get_class_type());
}
virtual TypeHandle get_type() const {
return get_class_type();
}
virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
private:
static TypeHandle _type_handle;
};
#endif
| [
"sweep14@gmail.com"
] | sweep14@gmail.com |
5216acec00a97d149946ad55dbcf9da5259c9763 | 0611b1cc08b15d329057595365359947c20fcd59 | /2020xls/HDU/7/Increasing and Decreasing.cpp | 7fccd9cc56a299c373cf52829832b40f776ace02 | [] | no_license | Lan-ce-lot/overflow | c9a7167edaeeaa1f9f1e92624726b1d964289798 | ae76120e328a5a2991eb6ef7f1ae5e279374e15c | refs/heads/master | 2023-04-08T04:24:49.614146 | 2021-04-25T05:33:06 | 2021-04-25T05:33:06 | 279,082,035 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 724 | cpp | #include<bits/stdc++.h>
#include<iostream>
#include<string.h>
#include<algorithm>
#include<stdio.h>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<time.h>
#include<climits>
#define debug(a) cout << "*" << a << "*" << endl
#define ls (k << 1)
#define rs ((k << 1) | 1)
#define mid ((l + r) >> 1)
using namespace std;
typedef long long ll;
int t, n, x, y;
int a[100005];
int main()
{
scanf("%d", &t);
while (t--){
scanf("%d%d%d", &n, &x, &y);
if (x + y > n + 1 || y <= (n - y) / (x))
puts("NO");
else {
puts("YES");
for (int i = 1; i < n; i++) {
}
for (int i = 1; i <= n; i ++) {
if (i == 1) printf("%d", a[i]);
else printf(" %d", a[i]);
}
puts("");
}
}
}
| [
"1984737645@qq.com"
] | 1984737645@qq.com |
ee647ee9684f01e984967a3fa891c9d942abc03e | e87e29a33de4101aad17eb0bee6cdbdee246c864 | /4_1.cpp | 4c50d51e6a459ddfdf1eb8377f80abe6ea9dd9b5 | [] | no_license | PengyanQin/cracking-the-coding-interview | dffb485308ebb032f48af457d47528f32e544dac | fdbe989fa2231c195920117438fc0cc70775b90a | refs/heads/master | 2021-01-10T16:06:40.972952 | 2015-10-20T00:12:12 | 2015-10-20T00:12:12 | 44,566,524 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,220 | cpp | //
// 4_1.cpp
//
//
// Created by Pengyan Qin on 6/25/15.
//
//
#include <iostream>
#include <cmath>
using namespace std;
struct node{
int data;
node* left;
node* right;
node() {}
node(int data_in):data(data_in), left(nullptr), right(nullptr){}
};
void insert(node* &root, int dat){
if(root == nullptr){
node *n = new node(dat);
root = n;
return;
}
if(dat < root->data){
insert(root->left, dat);
}
else{
insert(root->right, dat);
}
}
//recursive function
// from top to bottom, when it reaches bottom, means the above parent nodes are all balanced
// height(leaf) = 0
// time complexity: O(nlogn)
int height(node *ptr){
if(ptr == 0)
return 0;
return max(height(ptr->left), height(ptr->right)) + 1;
}
bool is_balanced(node *ptr){
if(ptr == nullptr)
return true; // base case
int bal_factor = abs(height(ptr->left) - height(ptr->right));
if(bal_factor > 1)
return false;
else
return is_balanced(ptr->left) && is_balanced(ptr->right);
}
// improve the efficiency, check balance while calculating height
int checkheight(node *root){
if(root == nullptr)
return 0;
int left = checkheight(root->left);
if(left == -1)
return -1;
int right = checkheight(root->right);
if(right == -1)
return -1;
int dif = abs(left - right);
if(dif > 1)
return -1;
else
return max(left, right) + 1;
}
bool is_balanced1(node *root){
int check = checkheight(root);
if(check == -1)
return false;
else
return true;
}
int main(){
node *root1 = new node(8);
int a[5] = {3, 9, 13, 4, 1};
int num1 = 5;
for(int i = 0; i < num1; ++i){
insert(root1, a[i]);
}
cout << "the height of the first tree is " << height(root1) << endl;
cout << is_balanced1(root1) << endl; //balanced
node *root2 = new node(8);
int b[6] = {3, 9, 13, 4, 1, 14};
int num2 = 6;
for(int i = 0; i < num2; ++i){
insert(root2, b[i]);
}
cout << "the height of the first tree is " << height(root2) << endl;
cout << is_balanced1(root2) << endl; //not balanced
}
| [
"pengqin@umich.edu"
] | pengqin@umich.edu |
ecad0d6dbc97a81789ee34191c2d4317f62c6bde | 6b2a8dd202fdce77c971c412717e305e1caaac51 | /solutions_2645486_0/C++/ADJA/B.cpp | 92e790b867dd33b9218bc0a023b183e8c79b7a4b | [] | no_license | alexandraback/datacollection | 0bc67a9ace00abbc843f4912562f3a064992e0e9 | 076a7bc7693f3abf07bfdbdac838cb4ef65ccfcf | refs/heads/master | 2021-01-24T18:27:24.417992 | 2017-05-23T09:23:38 | 2017-05-23T09:23:38 | 84,313,442 | 2 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 1,109 | cpp | #include <iostream>
#include <fstream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <utility>
#include <iomanip>
using namespace std;
int tn, ans;
int e, r, n;
int v[100000];
int d[100][50];
int main() {
freopen("B-small-attempt1.in","r",stdin);
freopen("output.txt","w",stdout);
scanf("%d", &tn);
for (int test = 1; test <= tn; test++) {
ans = 0;
scanf("%d %d %d", &e, &r, &n);
for (int i = 1; i <= n; i++)
scanf("%d", &v[i]);
for (int i = 1; i <= n + 5; i++)
for (int j = 0; j <= e; j++)
d[i][j] = -1;
d[1][e] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= e; j++) {
if (d[i][j] == -1)
continue;
for (int k = 0; k <= j; k++) {
d[i + 1][min(j - k + r, e)] = max(d[i + 1][min(j - k + r, e)], d[i][j] + v[i] * k);
}
}
for (int i = 0; i <= e; i++)
ans = max(ans, d[n + 1][i]);
printf("Case #%d: %d\n", test, ans);
}
return 0;
} | [
"eewestman@gmail.com"
] | eewestman@gmail.com |
7255c3efaf1d0345b8627b6c4fb0bc56e8e77c62 | 2478b9d9c90975ad53e3664d31b6efeecd38c1cd | /gedw/src/gfx/array.cpp | 49e5ccd8682060ab8328616c1d3e9be7dd319776 | [] | no_license | alex5nader/gedw | 9e26f47df22a474f69cc759d5f975ad9f0b72e9b | 8d9787040fdae0a428000aa6cdde49f0461a6305 | refs/heads/main | 2023-06-16T06:17:55.175016 | 2021-06-30T21:44:35 | 2021-06-30T21:44:35 | 380,647,671 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,302 | cpp | #include "gfx/array.h"
#include <functional>
#include <numeric>
#include <stdio.h>
#include <GL/glew.h>
#include "util/types.h"
using namespace gedw;
using namespace gedw::gfx;
uint genVertexArrays(uint count) {
uint id;
glGenVertexArrays(count, &id);
return id;
}
VertexArray::VertexArray(const Slice<float>& vertices, const std::initializer_list<uint>& attributeSizes) :
GlObject(genVertexArrays(1)),
buffer(vertices),
vertexSize(std::accumulate(attributeSizes.begin(), attributeSizes.end(), 0))
{
printf("Create VA %u\n", this->id);
this->bind();
this->buffer.bind();
const uint stride = vertexSize * sizeof(float);
uint offset = 0, i = 0;
for (uint attributeSize : attributeSizes) {
glEnableVertexAttribArray(i);
glVertexAttribPointer(i, attributeSize, GL_FLOAT, GL_FALSE, stride, (const void*)(offset * sizeof(float)));
offset += attributeSize;
i += 1;
}
}
void VertexArray::bind() const {
glBindVertexArray(this->id);
}
void VertexArray::unbind() const {
glBindVertexArray(0);
}
uint VertexArray::getVertexCount() const {
return this->buffer.getCount() / this->vertexSize;
}
VertexArray::~VertexArray() {
printf("Delete VA %u\n", this->id);
glDeleteVertexArrays(1, &this->id);
}
| [
"contact@alexhabi.ch"
] | contact@alexhabi.ch |
d5dfa0833d73f664555841da2e104d635ba454f3 | 93aed9611b499f39ecedfc8c9d5a839803add7d2 | /examples/cpp/acp_challenge_routing.cc | f3ec6abf63f2c1ad34744a25014d7dc3b54b2cb9 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | bask/or-tools | 73e83dcb05bd8b9e2b0a33eebbc5bd96aa33bf2e | 60e0e6d1a417f788f5e861a1460227bfbcaac04c | refs/heads/master | 2021-01-23T00:06:59.607979 | 2015-03-02T14:49:31 | 2015-03-02T14:49:31 | 37,256,176 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,634 | cc | // Copyright 2010-2014 Google
// 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.
//
// ACP 2014 challenge
#include <cstdio>
#include "base/commandlineflags.h"
#include "base/file.h"
#include "base/filelinereader.h"
#include "base/hash.h"
#include "base/integral_types.h"
#include "base/logging.h"
#include "base/split.h"
#include "base/map_util.h"
#include "base/stringprintf.h"
#include "base/strtoint.h"
#include "constraint_solver/constraint_solver.h"
#include "constraint_solver/routing.h"
#include "util/tuple_set.h"
DEFINE_string(input, "", "");
DEFINE_string(solution, "", "");
DEFINE_int32(ls_seed, 0, "ls seed");
DEFINE_int32(ls_size, 8, "ls size");
DEFINE_int32(ls_perm, 11, "ls perm");
DECLARE_string(routing_first_solution);
DECLARE_bool(routing_no_lns);
DECLARE_bool(routing_trace);
DECLARE_bool(routing_guided_local_search);
namespace operations_research {
class AcpData {
public:
AcpData()
: num_periods_(-1), num_products_(-1), inventory_cost_(0), state_(0) {}
void Load(const std::string& filename) {
FileLineReader reader(filename.c_str());
reader.set_line_callback(
NewPermanentCallback(this, &AcpData::ProcessNewLine));
reader.Reload();
if (!reader.loaded_successfully()) {
LOG(ERROR) << "Could not open acp challenge file";
}
}
void ProcessNewLine(char* const line) {
const std::vector<std::string> words =
strings::Split(line, " ", strings::SkipEmpty());
if (words.empty()) return;
switch (state_) {
case 0: {
num_periods_ = atoi32(words[0]);
state_ = 1;
break;
}
case 1: {
num_products_ = atoi32(words[0]);
state_ = 2;
break;
}
case 2: {
due_dates_per_product_.resize(due_dates_per_product_.size() + 1);
CHECK_EQ(words.size(), num_periods_) << "Error with line " << line;
for (int i = 0; i < num_periods_; ++i) {
if (atoi32(words[i]) == 1) {
due_dates_per_product_.back().push_back(i);
}
}
if (due_dates_per_product_.size() == num_products_) {
state_ = 3;
}
break;
}
case 3: {
inventory_cost_ = atoi32(words[0]);
state_ = 4;
break;
}
case 4: {
transitions_.resize(transitions_.size() + 1);
CHECK_EQ(words.size(), num_products_);
for (int i = 0; i < num_products_; ++i) {
transitions_.back().push_back(atoi32(words[i]));
}
break;
}
default: {
LOG(ERROR) << "Should not be here";
}
}
}
std::string DebugString() const {
return StringPrintf("AcpData(%d periods, %d products, %d cost)",
num_periods_, num_products_, inventory_cost_);
}
const std::vector<std::vector<int>>& due_dates_per_product() const {
return due_dates_per_product_;
}
const std::vector<std::vector<int>>& transitions() const {
return transitions_;
}
int num_periods() const { return num_periods_; }
int num_products() const { return num_products_; }
int inventory_cost() const { return inventory_cost_; }
private:
int num_periods_;
int num_products_;
int inventory_cost_;
std::vector<std::vector<int>> due_dates_per_product_;
std::vector<std::vector<int>> transitions_;
int state_;
};
void LoadSolution(const std::string& filename, std::vector<int>* vec) {
File* const file = File::OpenOrDie(filename, "r");
std::string line;
file->ReadToString(&line, 10000);
const std::vector<std::string> words =
strings::Split(line, " ", strings::SkipEmpty());
LOG(INFO) << "Solution file has " << words.size() << " entries";
vec->clear();
for (const std::string& word : words) {
vec->push_back(atoi32(word));
}
LOG(INFO) << " - loaded " << strings::Join(*vec, " ");
}
int Evaluate(const AcpData& data, const std::vector<int>& schedule) {
std::vector<int> indices(data.num_products(), 0);
int early_days = 0;
for (int i = 0; i < schedule.size(); ++i) {
const int product = schedule[i];
if (product >= data.num_products() || product < -1) {
return kint32max;
}
if (product != -1) {
const int index = indices[product];
if (index >= data.due_dates_per_product()[product].size()) {
LOG(INFO) << "Strange";
return kint32max;
}
indices[product]++;
const int due_date = data.due_dates_per_product()[product][index];
if (i > due_date) {
return kint32max;
}
early_days += due_date - i;
}
}
int previous = -1;
int transition_cost = 0;
for (const int product : schedule) {
if (previous != -1 && product != -1 && previous != product) {
transition_cost += data.transitions()[previous][product];
}
if (product != -1) {
previous = product;
}
}
return transition_cost + early_days * data.inventory_cost();
}
int64 OneDistance(RoutingModel::NodeIndex from, RoutingModel::NodeIndex to) {
return 1;
}
class ProductMatrix {
public:
ProductMatrix(const AcpData& data, const std::vector<int>& item_to_product)
: data_(data), item_to_product_(item_to_product) {}
int64 Distance(RoutingModel::NodeIndex from,
RoutingModel::NodeIndex to) const {
if (from.value() == 0 || to.value() == 0) {
return 0;
}
const int index1 = item_to_product_[from.value() - 1];
const int index2 = item_to_product_[to.value() - 1];
return data_.transitions()[index1][index2];
}
private:
const AcpData& data_;
const std::vector<int>& item_to_product_;
};
void Solve(const std::string& filename, const std::string& solution_file) {
const char* kTime = "Time";
LOG(INFO) << "Load " << filename;
AcpData data;
data.Load(filename);
std::vector<int> best;
int best_cost = kint32max;
if (!solution_file.empty()) {
LoadSolution(solution_file, &best);
best.resize(data.num_periods());
best_cost = Evaluate(data, best);
LOG(INFO) << "Initial solution cost = " << best_cost;
}
int num_active_periods = 0;
std::vector<int> due_dates_per_period(data.num_periods(), 0);
for (const std::vector<int>& d : data.due_dates_per_product()) {
for (const int v : d) {
due_dates_per_period[v]++;
num_active_periods++;
}
}
LOG(INFO) << "num active periods = " << num_active_periods;
std::vector<bool> active_periods(num_active_periods);
std::vector<int> modified_dates_to_dates;
std::vector<int> dates_to_modified_dates;
int count = 0;
for (int period = data.num_periods() - 1; period >= 0; --period) {
count += due_dates_per_period[period];
if (count > 0) {
count--;
active_periods[period] = true;
} else {
active_periods[period] = false;
}
}
for (int i = 0; i < data.num_periods(); ++i) {
if (active_periods[i]) {
dates_to_modified_dates.push_back(modified_dates_to_dates.size());
modified_dates_to_dates.push_back(i);
} else {
dates_to_modified_dates.push_back(-1);
}
}
LOG(INFO) << "original: " << strings::Join(dates_to_modified_dates, " ");
LOG(INFO) << "modified: " << strings::Join(modified_dates_to_dates, " ");
std::vector<int> item_to_product;
std::vector<int> modified_due_dates;
for (int i = 0; i < data.num_products(); ++i) {
for (const int j : data.due_dates_per_product()[i]) {
item_to_product.push_back(i);
modified_due_dates.push_back(dates_to_modified_dates[j]);
}
}
RoutingModel routing(num_active_periods + 1, 1);
const RoutingModel::NodeIndex kDepot(0);
routing.SetDepot(kDepot);
// Setting first solution heuristic (cheapest addition).
FLAGS_routing_first_solution = "Savings";
// Disabling Large Neighborhood Search, comment out to activate it.
FLAGS_routing_no_lns = true;
FLAGS_routing_trace = true;
FLAGS_routing_guided_local_search = true;
ProductMatrix matrix(data, item_to_product);
routing.SetArcCostEvaluatorOfAllVehicles(
NewPermanentCallback(&matrix, &ProductMatrix::Distance));
routing.AddDimension(NewPermanentCallback(OneDistance), 0,
num_active_periods + 2, true, kTime);
const RoutingDimension& time_dimension = routing.GetDimensionOrDie(kTime);
for (int i = 0; i < num_active_periods; ++i) {
const int due_date = modified_due_dates[i];
LOG(INFO) << i << ": " << due_date;
time_dimension.CumulVar(1 + i)->SetMax(due_date + 1);
}
// Solve, returns a solution if any (owned by RoutingModel).
const Assignment* solution = routing.Solve();
if (solution != NULL) {
LOG(INFO) << solution->DebugString();
} else {
LOG(INFO) << "No solution";
}
}
} // namespace operations_research
static const char kUsage[] =
"Usage: see flags.\nThis program runs the ACP 2014 summer school "
"competition";
int main(int argc, char** argv) {
FLAGS_log_prefix = false;
google::SetUsageMessage(kUsage);
google::ParseCommandLineFlags(&argc, &argv, true);
if (FLAGS_input.empty()) {
LOG(FATAL) << "Please supply a data file with --input=";
}
operations_research::Solve(FLAGS_input, FLAGS_solution);
return 0;
}
| [
"lperron@google.com"
] | lperron@google.com |
d47ec45cf1e6bdb71511d641e50c8451ae015dcd | 1e395205d1c315c269a44c2e465831f862b2a491 | /src/nimbro_robotcontrol/contrib/rbdl/source/addons/luamodel/luamodel.cc | f69ebdf44c822ea160c274c270663c694b047379 | [
"Zlib"
] | permissive | anh0001/EROS | 01c46f88cc91ef0677b482124b2974790143e723 | a5fae8bf9612cd13fbbcfc0838685430a6fe8fa4 | refs/heads/master | 2021-08-28T00:07:13.261399 | 2021-08-20T08:56:12 | 2021-08-20T08:56:12 | 195,176,022 | 0 | 2 | MIT | 2021-08-20T08:52:12 | 2019-07-04T05:44:14 | null | UTF-8 | C++ | false | false | 8,838 | cc | #include "rbdl/rbdl.h"
#include "luamodel.h"
#include <iostream>
#include <map>
#include "luatables.h"
extern "C"
{
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
}
using namespace std;
static void bail(lua_State *L, const char *msg){
std::cerr << msg << lua_tostring(L, -1) << endl;
abort();
}
namespace RigidBodyDynamics {
namespace Addons {
using namespace Math;
typedef map<string, unsigned int> StringIntMap;
StringIntMap body_table_id_map;
SpatialVector get_spatial_vector (lua_State *L, const string &path, int index = -1) {
SpatialVector result (0., 0., 0., 0., 0., 0.);
std::vector<double> array = ltGetDoubleVectorAt (L, path.c_str(), index);
if (array.size() != 6) {
cerr << "Invalid array size for spatial vector variable '" << path << "'." << endl;
abort();
}
for (unsigned int i = 0; i < 6; i++) {
result[i] = array[i];
}
return result;
}
Vector3d get_vector3d (lua_State *L, const string &path, int index = -1) {
Vector3d result;
std::vector<double> array = ltGetDoubleVectorAt (L, path.c_str(), index);
if (array.size() != 3) {
cerr << "Invalid array size for 3d vector variable '" << path << "'." << endl;
abort();
}
for (unsigned int i = 0; i < 3; i++) {
result[i] = array[i];
}
return result;
}
Matrix3d get_matrix3d (lua_State *L, const string &path) {
Matrix3d result;
// two ways either as flat array or as a lua table with three columns
if (ltGetLengthAt (L, path.c_str(), -1) == 3) {
Vector3d row = get_vector3d (L, path, 1);
result(0,0) = row[0];
result(0,1) = row[1];
result(0,2) = row[2];
row = get_vector3d (L, path, 2);
result(1,0) = row[0];
result(1,1) = row[1];
result(1,2) = row[2];
row = get_vector3d (L, path, 3);
result(2,0) = row[0];
result(2,1) = row[1];
result(2,2) = row[2];
return result;
}
std::vector<double> array = ltGetDoubleVectorAt (L, path.c_str(), -1);
if (array.size() != 9) {
cerr << "Invalid array size for 3d matrix variable '" << path << "'." << endl;
abort();
}
for (unsigned int i = 0; i < 9; i++) {
result.data()[i] = array[i];
}
return result;
}
bool read_frame_params (lua_State *L,
const string &path,
unsigned int &parent_id,
SpatialTransform &joint_frame,
Joint &joint,
Body &body,
std::string &body_name,
bool verbose) {
if (!ltIsExisting (L, (path + ".name").c_str())) {
cerr << "Error: could not find required value '" << path << ".name'." << endl;
return false;
}
body_name = ltGetString (L, (path + ".name").c_str());
if (!ltIsExisting (L, (path + ".parent").c_str())) {
cerr << "Error: could not find required value '" << path << ".parent' for body '" << body_name << "'." << endl;
return false;
}
string parent_frame = ltGetString (L, (path + ".parent").c_str());
StringIntMap::iterator parent_iter = body_table_id_map.find (parent_frame);
if (parent_iter == body_table_id_map.end()) {
cerr << "Error: could not find the parent frame for frame '" << body_name << "'!" << endl;
return false;
}
parent_id = body_table_id_map[parent_frame];
if (verbose) {
cout << "frame name = " << body_name << endl;
cout << " parent = " << parent_frame << endl;
cout << " parent_id = " << parent_id << endl;
}
// create the joint_frame
if (!ltIsExisting(L, (path + ".joint_frame").c_str())) {
joint_frame = SpatialTransform();
} else {
Vector3d r (0., 0., 0.);
Matrix3d E (Matrix3d::Identity(3,3));
if (ltIsExisting(L, (path + ".joint_frame.r").c_str())) {
r = get_vector3d (L, path + ".joint_frame.r");
}
if (ltIsExisting(L, (path + ".joint_frame.E").c_str())) {
E = get_matrix3d (L, path + ".joint_frame.E");
}
joint_frame = SpatialTransform (E, r);
}
if (verbose)
cout << " joint_frame = " << joint_frame << endl;
// create the joint
if (!ltIsExisting (L, (path + ".joint").c_str())) {
joint = Joint(JointTypeFixed);
} else {
unsigned int joint_dofs = static_cast<unsigned int> (ltGetLength (L, (path + ".joint").c_str()));
// special case: joint_dof specified as { X., X., X., X., X., X.}. In
if (ltIsNumberAt (L, (path + ".joint").c_str(), 1)
&& ltIsNumberAt (L, (path + ".joint").c_str(), 2)
&& ltIsNumberAt (L, (path + ".joint").c_str(), 3)
&& ltIsNumberAt (L, (path + ".joint").c_str(), 4)
&& ltIsNumberAt (L, (path + ".joint").c_str(), 5)
&& ltIsNumberAt (L, (path + ".joint").c_str(), 6) ) {
joint = Joint (get_spatial_vector (L, path + ".joint"));
} else {
// otherwise: joint_dof specified as { { DOF1}, { DOF2}, ... }. In
if (verbose)
cout << " joint_dofs = " << joint_dofs << endl;
switch (joint_dofs) {
case 0: joint = Joint(JointTypeFixed);
break;
case 1: joint = Joint(get_spatial_vector(L, path + ".joint", 1));
break;
case 2: joint = Joint(
get_spatial_vector(L, path + ".joint", 1),
get_spatial_vector(L, path + ".joint", 2)
);
break;
case 3: joint = Joint(
get_spatial_vector(L, path + ".joint", 1),
get_spatial_vector(L, path + ".joint", 2),
get_spatial_vector(L, path + ".joint", 3)
);
break;
case 4: joint = Joint(
get_spatial_vector(L, path + ".joint", 1),
get_spatial_vector(L, path + ".joint", 2),
get_spatial_vector(L, path + ".joint", 3),
get_spatial_vector(L, path + ".joint", 4)
);
break;
case 5: joint = Joint(
get_spatial_vector(L, path + ".joint", 1),
get_spatial_vector(L, path + ".joint", 2),
get_spatial_vector(L, path + ".joint", 3),
get_spatial_vector(L, path + ".joint", 4),
get_spatial_vector(L, path + ".joint", 5)
);
break;
case 6: joint = Joint(
get_spatial_vector(L, path + ".joint", 1),
get_spatial_vector(L, path + ".joint", 2),
get_spatial_vector(L, path + ".joint", 3),
get_spatial_vector(L, path + ".joint", 4),
get_spatial_vector(L, path + ".joint", 5),
get_spatial_vector(L, path + ".joint", 6)
);
break;
default:
cerr << "Invalid number of DOFs for joint in frame '" << path << ".joint'" << endl;
return false;
}
}
}
if (!ltIsExisting (L, (path + ".body").c_str())) {
body = Body();
} else {
double mass = 0.;
Vector3d com (0., 0., 0.);
Matrix3d inertia (Matrix3d::Zero(3,3));
inertia(0,0) = 1.;
inertia(1,1) = 1.;
inertia(2,2) = 1.;
if (ltIsExisting (L, (path + ".body.mass").c_str()) ) {
mass = ltGetDouble (L, (path + ".body.mass").c_str());
}
if (ltIsExisting (L, (path + ".body.com").c_str() )) {
com = get_vector3d (L, path + ".body.com");
}
if (ltIsExisting (L, (path + ".body.inertia").c_str() )) {
inertia = get_matrix3d (L, path + ".body.inertia");
}
if (verbose) {
cout << " mass = " << mass << endl;
cout << " com = " << com << endl;
cout << " inertia = " << inertia << endl;
}
body = Body (mass, com, inertia);
}
// if (verbose)
// cout << " Body = " << endl << body.mSpatialInertia << endl;
return true;
}
bool LuaModelReadFromFile (const char* filename, Model* model, bool verbose) {
assert (model);
body_table_id_map["ROOT"] = 0;
lua_State *L;
L = luaL_newstate();
luaL_openlibs(L);
if (luaL_loadfile(L, filename) || lua_pcall (L, 0, 1, 0)) {
bail (L, "Error running file: ");
}
if (ltIsExisting (L, "gravity")) {
model->gravity = get_vector3d (L, "gravity");
if (verbose)
cout << "gravity = " << model->gravity.transpose() << endl;
}
vector<string> frame_names = ltGetKeys (L, "frames");
unsigned int parent_id;
Math::SpatialTransform joint_frame;
Joint joint;
Body body;
string body_name;
for (unsigned int i = 0; i < frame_names.size(); i++) {
string frame_path = string ("frames") + string (".") + string (frame_names[i]);
if (!read_frame_params(L, frame_path,
parent_id,
joint_frame,
joint,
body,
body_name,
verbose
)) {
cerr << "Error reading frame " << frame_names[i] << "." << endl;
lua_close (L);
return false;
}
if (verbose) {
cout << "+ Adding Body " << endl;
cout << " parent_id : " << parent_id << endl;
cout << " joint_frame: " << joint_frame << endl;
cout << " joint dofs : " << joint.mDoFCount << endl;
for (unsigned int j = 0; j < joint.mDoFCount; j++) {
cout << " " << j << ": " << joint.mJointAxes[j].transpose() << endl;
}
cout << " body inertia: " << endl << body.mSpatialInertia << endl;
cout << " body_name : " << body_name << endl;
}
unsigned int body_id = model->AddBody (parent_id, joint_frame, joint, body, body_name);
body_table_id_map[body_name] = body_id;
if (verbose)
cout << " body id : " << body_id << endl;
}
lua_close (L);
return true;
}
}
}
| [
"anhrisn@gmail.com"
] | anhrisn@gmail.com |
13a749d8944aa6a1f4ef4edf1223b79973e1bb01 | d18605793daa8d5098813d5acfa31ab9219a5b82 | /FWCore/Utilities/interface/Transition.h | ed3baf8ae137388289e424ea46d0005659deb8e6 | [
"Apache-2.0"
] | permissive | jaimeleonh/cmssw | 7fd567997a244934d6c78e9087cb2843330ebe09 | 6218e450291666997449b8f0f6ac9d1c1efb6d9b | refs/heads/master | 2023-04-06T14:42:57.263616 | 2019-05-23T12:34:29 | 2019-05-23T12:34:29 | 181,003,620 | 1 | 0 | Apache-2.0 | 2019-04-12T12:28:16 | 2019-04-12T12:28:15 | null | UTF-8 | C++ | false | false | 1,140 | h | #ifndef FWCore_Utilities_Transition_h
#define FWCore_Utilities_Transition_h
/*----------------------------------------------------------------------
Transition: The allowed framework transitions
----------------------------------------------------------------------*/
#include "FWCore/Utilities/interface/BranchType.h"
#include <type_traits>
namespace edm {
enum class Transition {
Event,
BeginLuminosityBlock,
EndLuminosityBlock,
BeginRun,
EndRun,
NumberOfTransitions
};
//Useful for converting EndBranchType to BranchType
constexpr BranchType convertToBranchType(Transition iValue) {
constexpr BranchType branches[]={InEvent,InLumi,InLumi,InRun,InRun};
return branches[static_cast<std::underlying_type<Transition>::type>(iValue)];
}
constexpr Transition convertToTransition(BranchType iValue) {
constexpr Transition trans[]={Transition::Event,Transition::BeginLuminosityBlock,Transition::BeginRun};
return trans[iValue];
}
constexpr bool isEndTransition(Transition iValue) {
return iValue==Transition::EndLuminosityBlock or iValue==Transition::EndRun;
}
}
#endif
| [
"chrisdjones15@gmail.com"
] | chrisdjones15@gmail.com |
1ec8964ae242de297ce4739b1c2c158ec16e6aa3 | 9c9e8fa145e8c36493bb7465ddbf7af98b684ea1 | /ConstructorsAndDestructors/Meep.h | e451c9db8949d591d8e154c66dcf7a8dede9e52c | [] | no_license | amandaevans18/ConstructorsAndDestructors | 410572478d2470c8310ae6a1948162d87c329ce7 | 397a6f5a14ebaaaa3fc64e0b575d780678faba4b | refs/heads/master | 2020-03-31T19:33:50.458921 | 2018-11-09T01:55:33 | 2018-11-09T01:55:33 | 152,502,859 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 270 | h | #pragma once
#include "raylib.h"
#include <iostream>
class meep
{
public:
//Vars
bool enabled = true;
Texture2D texture;
Texture2D* dTexture;
// Constructors & Destructors
meep();
meep(bool _enabled);
~meep();
// Misc Functions
void refresh();
private:
}; | [
"s189068@students.aie.edu"
] | s189068@students.aie.edu |
7ffb2689ade6cad8705cb6cf13b65c26d659b834 | e0a38063f6efa16a7d7ea6fbf501b847ea83b6b2 | /HelicityLD/helicityLD.h | cdabdd4a21b236b39bc789e43c6d871fadfdd04d | [] | no_license | awhitbeck/usercode | 36ea45963cb3858b6f592cb2819e695cd150db4d | 45c68f98ecd6cb4ea7799df9c0e597413a1eb5d1 | refs/heads/master | 2020-06-04T05:57:12.188214 | 2013-11-15T19:00:27 | 2013-11-15T19:00:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,383 | h | #include <iostream>
#include "RooRealVar.h"
#include "RooPentaSpinTwo.h"
#include "RooBtheta.h"
#include "RooBphione.h"
#include "RooBkg2l2jHL.h"
#include "RooProdPdf.h"
class signalModel{
public:
signalModel();
void setVars(double mH);
RooRealVar* cosTheta1;
RooRealVar* cosTheta2;
RooRealVar* phi;
RooRealVar* cosThetaS;
RooRealVar* phi1;
RooRealVar* fppVal;
RooRealVar* fmmVal;
RooRealVar* fpmVal;
RooRealVar* fp0Val;
RooRealVar* f0mVal;
RooRealVar* phippVal;
RooRealVar* phimmVal;
RooRealVar* phipmVal;
RooRealVar* phip0Val;
RooRealVar* phi0mVal;
RooRealVar* fz1Val;
RooRealVar* fz2Val;
RooRealVar* R1Val;
RooRealVar* R2Val;
RooRealVar* para2;
RooRealVar* para4;
RooRealVar* para6;
RooRealVar* para8;
RooRealVar* acca0;
RooRealVar* acca1;
RooRealVar* acca2;
RooRealVar* acca4;
RooRealVar* a2;
RooRealVar* a4;
RooRealVar* cutOff;
RooRealVar* g;
RooRealVar* b2;
RooRealVar* b4;
RooRealVar* N;
RooPentaSpinTwo* signal;
};
class backgroundModel{
public:
backgroundModel();
void setVars(double mH);
RooRealVar* cosTheta1;
RooRealVar* h1_para2;
RooRealVar* h1_para4;
RooRealVar* h1_acca2;
RooRealVar* h1_acca4;
RooBtheta* h1PDF;
RooRealVar* cosTheta2;
RooRealVar* h2_acca0;
RooRealVar* h2_acca2;
RooRealVar* h2_acca4;
RooRealVar* h2_g;
RooRealVar* h2_cutOff;
RooBkg2l2jHL* h2PDF;
RooRealVar* cosThetaS;
RooRealVar* hs_para2;
RooRealVar* hs_para4;
RooRealVar* hs_acca2;
RooRealVar* hs_acca4;
RooBtheta* hsPDF;
RooRealVar* phi;
RooRealVar* phi_para2;
RooRealVar* phi_para4;
RooRealVar* phi_acca2;
RooRealVar* phi_acca4;
RooRealVar* phi_acca6;
RooRealVar* phi_acca8;
RooBphione* phiPDF;
RooRealVar* phi1;
RooRealVar* phi1_para2;
RooRealVar* phi1_para4;
RooRealVar* phi1_acca2;
RooRealVar* phi1_acca4;
RooRealVar* phi1_acca6;
RooRealVar* phi1_acca8;
RooBphione* phi1PDF;
RooProdPdf* background;
};
class helicityLD{
public:
helicityLD();
void setVars(double mH);
double getLD(double h1, double h2, double hs, double phi, double phi1, double mZZ);
backgroundModel* bkgPDF;
signalModel* sigPDF;
};
| [
""
] | |
405d4f95f9d1eecb40d2c6d6d01c282f4381471c | 01c8a0f7699a894512a04f99ddea5d57fa79e72a | /code/Edit Distance.cpp | e1ffe1a41280982bc8f494bcf10fea5b4a02eb88 | [] | no_license | 4T-Shirt/LeetCode | 365f58584fb978e2d1e015e31ee6c3c686eba19e | e58a373a5178ac33f058a7dc89051573f4b16b06 | refs/heads/master | 2021-01-23T16:37:32.452305 | 2013-12-05T12:36:55 | 2013-12-05T12:36:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 698 | cpp | const int maxs = 502;
class Solution {
public:
int minDistance(string word1, string word2) {
// IMPORTANT: Please reset any member data you declared, as
// the same Solution instance will be reused for each test case.
int lena = word1.length(),lenb=word2.length();
int dp[maxs][maxs];
memset(dp,0,sizeof(dp));
for (int i=0;i<lena;++i)
dp[i][lenb] = lena-i;
for (int i=0;i<=lenb;++i)
dp[lena][i] = lenb-i;
for (int i=lena-1;i>=0;--i)
for (int j=lenb-1;j>=0;--j)
dp[i][j] = min(dp[i+1][j+1]+(word1[i]==word2[j]?0:1),1+min(dp[i][j+1],dp[i+1][j]));
return dp[0][0];
}
}; | [
"huachi1989@gmail.com"
] | huachi1989@gmail.com |
7128ab5ff3f31a60c7b238e72cda44c8d3d24c2f | cd763faab645a564b3d23faf9a988b4885af0733 | /main.cpp | 28da591b6b958173f379bc4f86f655bc65e7a131 | [] | no_license | QinlinChen/Painter | d4bac92cda2391527ba4d07d82acbaf82bd359b3 | 1439ffb182917359fea4f8c19e6e70440922dd50 | refs/heads/master | 2020-04-26T12:31:57.700669 | 2019-06-08T06:29:41 | 2019-06-08T06:29:41 | 173,552,800 | 7 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 299 | cpp | #include "mainwindow.h"
#include "paintercli.h"
#include <QApplication>
int main(int argc, char *argv[])
{
if (argc > 1) {
PainterCLI cliApp;
return cliApp.exec(argc, argv);
}
QApplication app(argc, argv);
MainWindow win;
win.show();
return app.exec();
}
| [
"chenqinlin98@gmail.com"
] | chenqinlin98@gmail.com |
91aad265d5c07d90fa5fdeb85eaf75ad9d780bb8 | af69e335fc0ff9632964d061833713b672abad01 | /Temp/StagingArea/Data/il2cppOutput/System_Core_System_Security_Cryptography_AesManage1129950597.h | b40dd45503ad836349d62751c52bef73650d0577 | [] | no_license | PruthvishMShirur/Solar-System | ca143ab38cef582705f0beb76f7fef8b28e25ef9 | 5cf3eaa66949801aa9a34cd3cf80eeefa64d2342 | refs/heads/master | 2023-05-26T17:53:37.489349 | 2021-06-16T19:56:48 | 2021-06-16T19:56:48 | 377,611,177 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 550 | h | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include "System_Core_System_Security_Cryptography_Aes1218282760.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Security.Cryptography.AesManaged
struct AesManaged_t1129950597 : public Aes_t1218282760
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"42893637+PruthvishMShirur@users.noreply.github.com"
] | 42893637+PruthvishMShirur@users.noreply.github.com |
d8049f4fd638cedbf35e3edae41c4d5540b018de | 350d6ea7d82208b5027e8c23a2a17bc42fef4daa | /dependencies-include/nxogre/include/NxOgreSceneRenderer.h | 32b8ff069aebce7a9772e0ee44527fd2f32b310c | [] | no_license | bach74/Lisa | 2436d4da3765b9fe307d5e3dc31bfe532cf37dce | d80af7b880c0f99b914028dcf330d00ef0540cd3 | refs/heads/master | 2021-01-23T11:49:37.826497 | 2010-12-09T16:31:22 | 2010-12-09T16:31:22 | 1,153,210 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,048 | h | /** \file NxOgreSceneRenderer.h
* \brief Header for the SceneRenderer, NullSceneRenderer and Renderable classes
* \version 1.0-20
*
* \licence NxOgre a wrapper for the PhysX physics library.
* Copyright (C) 2005-8 Robin Southern of NxOgre.org http://www.nxogre.org
* 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef __NXOGRE_SCENE_RENDERER_H__
#define __NXOGRE_SCENE_RENDERER_H__
#include "NxOgrePrerequisites.h"
#include "NxOgreContainer.h"
#include "NxOgrePose.h"
#include "NxOgreRenderableSource.h"
#include "BetajaenCC.h"
#include "NxOgreNodeRenderable.h" // For: NodeRenderableParams
#include "NxOgreMeshRenderable.h" // For: MeshRenderableParams
namespace NxOgre {
//////////////////////////////////////////////////////////////////////////////
class NxPublicClass RenderEvent {
public:
NxReal Delta;
NxReal Accumulated;
};
//////////////////////////////////////////////////////////////////////////////
class NxPublicClass Renderables {
public:
Actors actors;
Characters characters;
//Cloths cloths
//...
};
//////////////////////////////////////////////////////////////////////////////
class NxPublicClass SceneRenderer {
friend class Scene;
public:
SceneRenderer(Scene*, NxString rendererUserData);
virtual ~SceneRenderer();
void render(const TimeStep&);
void registerSource(RenderableSource*);
void unregisterSource(RenderableSource*);
enum RenderAccuracy {
/** \brief Everything gets rendered, regardless if it has changed or not.
Most accurate, but slowest form of rendering.
*/
RA_ALL,
/** \brief Things get rendered according to NxTransform from Scene
*/
RA_NX_TRANSFORM,
/** \brief Things get rendered according to known moved sources.
\default
*/
RA_SOURCES
};
void setAccuracy(RenderAccuracy);
virtual NodeRenderable* createNodeRenderable(NodeRenderableParams) = 0;
virtual MeshRenderable* createMeshRenderable(MeshRenderableParams, Resources::Mesh*) = 0;
virtual void setCustom(const NxString& identifier, void* ptr) = 0;
virtual void setCustom(const NxString& identifier, const NxString& value) = 0;
virtual void* getCustom(const NxString& identifier) = 0;
protected:
Scene* mScene;
NxScene* mNxScene;
RenderAccuracy mRenderAccuracy;
typedef Betajaen::SharedList<RenderableSource> RenderableSources;
RenderableSources mSources;
private:
};
//////////////////////////////////////////////////////////////////////////////
class NxPublicClass NullSceneRenderer : public SceneRenderer {
friend class Scene;
public:
NullSceneRenderer(Scene* s, NxString rud) : SceneRenderer(s, rud) {}
~NullSceneRenderer() {}
NodeRenderable* createNodeRenderable(NodeRenderableParams) {
return NULL;
}
MeshRenderable* createMeshRenderable(MeshRenderableParams, Resources::Mesh*) {
return NULL;
}
void setCustom(const NxString& identifier, void* ptr) {}
void setCustom(const NxString& identifier, const NxString& value) {}
void* getCustom(const NxString& identifier) {return 0;}
protected:
private:
};
};
#endif
| [
"tomislav.reichenbach@fer.hr"
] | tomislav.reichenbach@fer.hr |
34b44f16ab8276989d1ee23928001aa19e3916aa | a6a208018266e93d2d4306bbdf600d2fcd5145f5 | /Color.h | 1332ebce90dc0e94bcb19ad7f58fcfe653e18185 | [] | no_license | alvaropascualcrespo/Camara | 872e4e8946f7d599a63324430fd5ece3497e18d7 | ca1b156f4a3d01d1cbf6f44991763efebbfd30f7 | refs/heads/master | 2020-06-08T19:10:06.012431 | 2014-05-01T11:10:41 | 2014-05-01T11:10:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 443 | h | //---------------------------------------------------------------------------
#ifndef ColorH
#define ColorH
#include <gl\gl.h>
//---------------------------------------------------------------------------
class Color{
private:
public:
GLfloat r;
GLfloat g;
GLfloat b;
Color(GLfloat red, GLfloat green, GLfloat blue){r = red; g = green; b = blue;};
};
#endif
| [
"alvaropascualcrespo@gmail.com"
] | alvaropascualcrespo@gmail.com |
055405032c2dae6b553a3f665dc6a1dbe9995ee1 | 522c568e8920d76a94198599614e9315f575ce23 | /Temp/Actor/Animation/WRIKAnimInstance.h | efae29a79cf72341d0b3f8c31125029f3d86cdf6 | [] | no_license | kyukyu86/Demo | 2ba6fe1f2264f9d4820437736c9870a5c59960cb | d2bb86e623ec5f621e860aa5defe335ee672ca53 | refs/heads/master | 2023-01-07T11:46:08.313633 | 2020-11-06T08:59:06 | 2020-11-06T08:59:06 | 269,510,905 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,312 | h | // Copyright 2019-2024 WemadeXR Inc. All rights reserved.
#pragma once
#include "CoreMinimal.h"
#include "Actor/Animation/WRAnimInstance.h"
#include "Component/IK/WRSpiderLegIKComponent.h"
#include "WRIKAnimInstance.generated.h"
/**
*
*/
UCLASS()
class WR_API UWRIKAnimInstance : public UWRAnimInstance
{
GENERATED_BODY()
public:
UWRIKAnimInstance();
virtual void NativeBeginPlay() override;
virtual void NativeUpdateAnimation(float DeltaSeconds) override;
private:
//! IK Component Init
void InitIKFootRef();
//! IK Component Tick
void TickIKFoot(float DeltaSeconds);
//! IK Component Ref
UPROPERTY()
class UWRSpiderLegIKComponent* InSpiderLegComp;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "IKFoot Value", meta = (AllowPrivateAccess = "true"))
bool IsInitialize;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "IKFoot Value", meta = (AllowPrivateAccess = "true"))
bool IsCanUse;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "IKFoot Value", meta = (AllowPrivateAccess = "true"))
bool IsMoving;
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "IKFoot Value", meta = (AllowPrivateAccess = "true"))
FWRFablikLegTransforms InLegTransforms;
public:
void SetIsMoving(bool InIsMoving)
{
if (IsCanUse == true)
IsMoving = InIsMoving;
}
};
| [
"pelpin2080@gmail.com"
] | pelpin2080@gmail.com |
148144d83bffb40054734e27b6dac76af6be9c3a | 9a2b42afe98d7d08f8265cd55be42eb2d6c57eee | /01 C Lang/001Arrays/arrayMain.cpp | ce69d60141a006f06ab9f56a14591384a45f9061 | [] | no_license | Taowang6987365/DataStructure | c926756cd3046fe55efb4b210049faa1dc275af8 | 9de98e44254fb98082e7bd130eed1ef7e2c30289 | refs/heads/main | 2023-03-29T04:56:47.827367 | 2021-03-12T01:42:18 | 2021-03-12T01:42:18 | 346,888,374 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 164 | cpp | #include <iostream>
#include<stdio.h>
using namespace std;
int main()
{
int A[] = { 2,4,6,8,10,12,14};
for (int x : A)
{
printf("%d\n", x);
}
return 0;
}
| [
"taowang.qc@gmail.com"
] | taowang.qc@gmail.com |
21d3c49f7d865fe5c114eb231450a3b03d53a2ae | c5c559574b06453c91fec4d173e2f3f09b0b7964 | /LeetCode/May/Possible Bipartition.cpp | 16df272e31500c5ab5eb3b364f937c6e36d96f85 | [] | no_license | iamishansharma/Competitive-Programming | bdbd02f4a02f7b83472348bb29cc2b6c5d3d51c7 | 320ab013b3199b81247b3136eb85b1e42d4655e6 | refs/heads/master | 2022-12-16T19:04:42.764489 | 2020-09-20T15:46:12 | 2020-09-20T15:46:12 | 270,191,905 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,043 | cpp | /*Given a set of N people (numbered 1, 2, ..., N), we would like to split everyone into two groups of any size.
Each person may dislike some other people, and they should not go into the same group.
Formally, if dislikes[i] = [a, b], it means it is not allowed to put the people numbered a and b into the same group.
Return true if and only if it is possible to split everyone into two groups in this way.
Example 1:
Input: N = 4, dislikes = [[1,2],[1,3],[2,4]]
Output: true
Explanation: group1 [1,4], group2 [2,3]
Example 2:
Input: N = 3, dislikes = [[1,2],[1,3],[2,3]]
Output: false
Example 3:
Input: N = 5, dislikes = [[1,2],[2,3],[3,4],[4,5],[1,5]]
Output: false
Constraints:
1 <= N <= 2000
0 <= dislikes.length <= 10000
dislikes[i].length == 2
1 <= dislikes[i][j] <= N
dislikes[i][0] < dislikes[i][1]
There does not exist i != j for which dislikes[i] == dislikes[j].*/
#define WHITE 0
#define RED 1
#define BLUE 2
class Solution
{
public:
bool possibleBipartition(int N, vector<vector<int>> &edges)
{
vector<vector<int>> adj(N + 1); // adjacency list for undirected graph
vector<int> color(N + 1, WHITE); // color of each vertex in graph, initially WHITE
vector<bool> explored(N + 1, false); // to check if each vertex has been explored exactly once
// create adjacency list from given edges
for (auto &edge: edges)
{
int u = edge[0];
int v = edge[1];
adj[u].push_back(v);
adj[v].push_back(u);
}
// print adjacency list (comment out before submitting)
for (int i = 0; i <= N; ++i)
{
cout << "adj[" << i << "]: ";
for (int j = 0; j < adj[i].size(); ++j)
{
cout << adj[i][j] << " ";
}
cout << "\n";
}
// queue to perform BFS over each connected component in the graph
// while performing BFS, we check if we encounter any conflicts while
// coloring the vertices of the graph
// conflicts indicate that bi-partition is not possible
queue<int> q;
for (int i = 1; i <= N; ++i)
{
if (!explored[i])
{
// this component has not been colored yet
// we color the first vertex RED and push it into the queue
color[i] = RED;
q.push(i);
// perform BFS from vertex i
while (!q.empty())
{
int u = q.front();
q.pop();
// check if u is already explored
if (explored[u])
{
continue;
}
explored[u] = true;
// for each neighbor of u, execute this loop
for (auto v: adj[u])
{
// v is u's neighboring vertex
// checking if there's any conflict in coloring
if (color[v] == color[u])
{
// conflict edge found, so we return false
// as bi-partition will not be possible
return false;
}
// we color v with the opposite color of u
if (color[u] == RED)
{
color[v] = BLUE;
}
else
{
color[v] = RED;
}
q.push(v);
}
}
}
}
// if no conflicts encountered then graph must be bipartite
// so we return true
return true;
}
}; | [
"sharmaishan747@gmail.com"
] | sharmaishan747@gmail.com |
b7e1a4571739bfe86a0aaeb94240b5969c332dbc | e4f07fa2a63a56cbaa9e72410a743f340665648b | /src_mixed/compute_stress_atom.h | 98b727bf808a23302cb6ef18520376241c38da54 | [] | no_license | sepehrs07/Parallel_Path_Swapping | c3fa36b76f70c779fb121d9f0395377d1167a3f3 | ded12d7fda51976230a12256776d4d551805dbcb | refs/heads/master | 2016-09-15T23:30:20.287698 | 2014-05-13T01:32:55 | 2014-05-13T01:32:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,157 | h | /* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#ifndef COMPUTE_STRESS_ATOM_H
#define COMPUTE_STRESS_ATOM_H
#include "compute.h"
namespace LAMMPS_NS {
class ComputeStressAtom : public Compute {
public:
ComputeStressAtom(class LAMMPS *, int, char **);
~ComputeStressAtom();
void init() {}
void compute_peratom();
int pack_reverse_comm(int, int, double *);
void unpack_reverse_comm(int, int *, double *);
double memory_usage();
private:
int keflag,pairflag,bondflag,angleflag,dihedralflag,improperflag,fixflag;
int nmax;
double **stress;
};
}
#endif
| [
"sepehr.saroukhani@gmail.com"
] | sepehr.saroukhani@gmail.com |
20e8a2cf004e75b130795d3a6bdf2ba9977602e7 | 3b1c4900464e0190cf343211092089c57352873f | /SrProject/Engine/PhysX/Samples/SampleFramework/renderer/src/d3d9/D3D9RendererTexture2D.cpp | 2ab7b7f1c3b295b8b79b8b0de9a5786675102535 | [] | no_license | Borzen/SrProject | 7b8901f0015416736632574ef750b4018b0f5832 | 7c1f721528b0a26d86f124463ba929c99242c6aa | refs/heads/master | 2021-01-20T03:40:16.050980 | 2014-03-25T22:25:44 | 2014-03-25T22:25:44 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,237 | cpp | /*
* Copyright 2008-2012 NVIDIA Corporation. All rights reserved.
*
* NOTICE TO USER:
*
* This source code is subject to NVIDIA ownership rights under U.S. and
* international Copyright laws. Users and possessors of this source code
* are hereby granted a nonexclusive, royalty-free license to use this code
* in individual and commercial software.
*
* NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE
* CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR
* IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH
* REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
* IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL,
* OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
* OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE
* OR PERFORMANCE OF THIS SOURCE CODE.
*
* U.S. Government End Users. This source code is a "commercial item" as
* that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting of
* "commercial computer software" and "commercial computer software
* documentation" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995)
* and is provided to the U.S. Government only as a commercial end item.
* Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through
* 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the
* source code with only those rights set forth herein.
*
* Any use of this source code in individual and commercial software must
* include, in the user documentation and internal comments to the code,
* the above Disclaimer and U.S. Government End Users Notice.
*/
#include <RendererConfig.h>
#if defined(RENDERER_ENABLE_DIRECT3D9)
#include "D3D9RendererTexture2D.h"
#include <RendererTexture2DDesc.h>
#include <SamplePlatform.h>
using namespace SampleRenderer;
static D3DFORMAT getD3D9TextureFormat(RendererTexture2D::Format format)
{
D3DFORMAT d3dFormat = static_cast<D3DFORMAT>(SampleFramework::SamplePlatform::platform()->getD3D9TextureFormat(format));
RENDERER_ASSERT(d3dFormat != D3DFMT_UNKNOWN, "Unable to convert to D3D9 Texture Format.");
return d3dFormat;
}
static D3DTEXTUREFILTERTYPE getD3D9TextureFilter(RendererTexture2D::Filter filter)
{
D3DTEXTUREFILTERTYPE d3dFilter = D3DTEXF_FORCE_DWORD;
switch(filter)
{
case RendererTexture2D::FILTER_NEAREST: d3dFilter = D3DTEXF_POINT; break;
case RendererTexture2D::FILTER_LINEAR: d3dFilter = D3DTEXF_LINEAR; break;
case RendererTexture2D::FILTER_ANISOTROPIC: d3dFilter = D3DTEXF_ANISOTROPIC; break;
}
RENDERER_ASSERT(d3dFilter != D3DTEXF_FORCE_DWORD, "Unable to convert to D3D9 Filter mode.");
return d3dFilter;
}
static D3DTEXTUREADDRESS getD3D9TextureAddressing(RendererTexture2D::Addressing addressing)
{
D3DTEXTUREADDRESS d3dAddressing = D3DTADDRESS_FORCE_DWORD;
switch(addressing)
{
case RendererTexture2D::ADDRESSING_WRAP: d3dAddressing = D3DTADDRESS_WRAP; break;
case RendererTexture2D::ADDRESSING_CLAMP: d3dAddressing = D3DTADDRESS_CLAMP; break;
case RendererTexture2D::ADDRESSING_MIRROR: d3dAddressing = D3DTADDRESS_MIRROR; break;
}
RENDERER_ASSERT(d3dAddressing != D3DTADDRESS_FORCE_DWORD, "Unable to convert to D3D9 Addressing mode.");
return d3dAddressing;
}
D3D9RendererTexture2D::D3D9RendererTexture2D(IDirect3DDevice9 &d3dDevice, const RendererTexture2DDesc &desc) :
RendererTexture2D(desc),
m_d3dDevice(d3dDevice)
{
m_d3dTexture = 0;
m_usage = 0;
m_pool = D3DPOOL_MANAGED;
m_format = getD3D9TextureFormat(desc.format);
m_d3dMinFilter = getD3D9TextureFilter(desc.filter);
m_d3dMagFilter = getD3D9TextureFilter(desc.filter);
m_d3dMipFilter = getD3D9TextureFilter(desc.filter);
m_d3dAddressingU = getD3D9TextureAddressing(desc.addressingU);
m_d3dAddressingV = getD3D9TextureAddressing(desc.addressingV);
if(desc.renderTarget)
{
m_usage = D3DUSAGE_RENDERTARGET;
m_pool = D3DPOOL_DEFAULT;
}
if(isDepthStencilFormat(desc.format))
{
m_usage = D3DUSAGE_DEPTHSTENCIL;
m_pool = D3DPOOL_DEFAULT;
}
onDeviceReset();
}
D3D9RendererTexture2D::~D3D9RendererTexture2D(void)
{
if(m_d3dTexture)
{
D3DCAPS9 pCaps;
m_d3dDevice.GetDeviceCaps(&pCaps);
DWORD i = pCaps.MaxTextureBlendStages;
while(i--) m_d3dDevice.SetTexture(i, NULL);
SampleFramework::SamplePlatform::platform()->D3D9BlockUntilNotBusy(m_d3dTexture);
m_d3dTexture->Release();
}
}
void *D3D9RendererTexture2D::lockLevel(PxU32 level, PxU32 &pitch)
{
void *buffer = 0;
if(m_d3dTexture)
{
D3DLOCKED_RECT lockedRect;
HRESULT result = m_d3dTexture->LockRect((DWORD)level, &lockedRect, 0, D3DLOCK_NOSYSLOCK);
RENDERER_ASSERT(result == D3D_OK, "Unable to lock Texture 2D.");
if(result == D3D_OK)
{
buffer = lockedRect.pBits;
pitch = (PxU32)lockedRect.Pitch;
}
}
return buffer;
}
void D3D9RendererTexture2D::unlockLevel(PxU32 level)
{
if(m_d3dTexture)
{
m_d3dTexture->UnlockRect(level);
}
}
void D3D9RendererTexture2D::bind(PxU32 samplerIndex)
{
m_d3dDevice.SetTexture( (DWORD)samplerIndex, m_d3dTexture);
m_d3dDevice.SetSamplerState((DWORD)samplerIndex, D3DSAMP_MINFILTER, m_d3dMinFilter);
m_d3dDevice.SetSamplerState((DWORD)samplerIndex, D3DSAMP_MAGFILTER, m_d3dMagFilter);
m_d3dDevice.SetSamplerState((DWORD)samplerIndex, D3DSAMP_MIPFILTER, m_d3dMipFilter);
m_d3dDevice.SetSamplerState((DWORD)samplerIndex, D3DSAMP_ADDRESSU, m_d3dAddressingU);
m_d3dDevice.SetSamplerState((DWORD)samplerIndex, D3DSAMP_ADDRESSV, m_d3dAddressingV);
}
void D3D9RendererTexture2D::onDeviceLost(void)
{
if(m_pool != D3DPOOL_MANAGED)
{
if(m_d3dTexture)
{
m_d3dTexture->Release();
m_d3dTexture = 0;
}
}
}
void D3D9RendererTexture2D::onDeviceReset(void)
{
if(!m_d3dTexture)
{
HRESULT result = m_d3dDevice.CreateTexture((UINT)getWidth(), (UINT)getHeight(), (UINT)getNumLevels(), m_usage, m_format, m_pool, &m_d3dTexture, 0);
RENDERER_ASSERT(result == D3D_OK, "Unable to create D3D9 Texture.");
if(result == D3D_OK)
{
}
}
}
#endif // #if defined(RENDERER_ENABLE_DIRECT3D9)
| [
"Borzen00@gmail.com"
] | Borzen00@gmail.com |
f1b0d82af722817138aba811eb8a4414ff111b0d | d4baaa6748dda226b88a1afb2fba2b6c6f54a3cc | /QiQiChat/client/source/register_window.cpp | 4bda52da23cb669dffad1546a17c99a55404635b | [] | no_license | zhangjiuchao/ProgramDesign | 8343363e9ebd4ad8bc2beb051c36f450cda653fe | 175c286b2ed2eca3c386f7aaf7ec13404989a95f | refs/heads/master | 2020-06-30T18:34:16.947478 | 2016-08-26T15:20:53 | 2016-08-26T15:20:53 | 66,571,078 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 3,411 | cpp |
//新账号注册模块
#include "register_window.h"
#include "chat_client.h"
#include "ui_register_window.h"
#include "dialog.h"
#include "mainwindow.h"
#include "QMessageBox"
register_window::register_window(QWidget *parent) :
QDialog(parent),
ui(new Ui::register_window)
{
ui->setupUi(this);
this->setFocus();
ui->lineEdit_ID->setPlaceholderText("输入账户名");
ui->lineEdit_name->setPlaceholderText("输入昵称");
ui->lineEdit_password->setPlaceholderText("输入密码");
ui->lineEdit_password_2->setPlaceholderText("确认密码");
ui->lineEdit_password->setEchoMode(QLineEdit::Password);
ui->lineEdit_password_2->setEchoMode(QLineEdit::Password);
timer = new QTimer;
timer->setInterval(15000);
connect(timer,SIGNAL(timeout()),this,SLOT(connect_timeout()));
connect(Socket,SIGNAL(ResponseForRegiste()),this,SLOT(response_for_registe()));
}
register_window::~register_window()
{
delete ui;
}
void register_window::on_pushButton_2_clicked() //取消注册，返回登录界面
{
Dialog *log_window = new Dialog;
log_window->setAttribute(Qt::WA_DeleteOnClose,true);
this->close();
log_window->show();
}
void register_window::on_pushButton_clicked() //注册新账号
{
QString id = ui->lineEdit_ID->text();
QString name = ui->lineEdit_name->text();
QString password = ui->lineEdit_password->text();
QString password_2 = ui->lineEdit_password_2->text();
if(id == ""||name == ""||password == ""||password_2 == "")
{
QMessageBox *mm = new QMessageBox;
mm->setText("所有项输入均不能为空");
mm->exec();
}
else
{
if(password != password_2) //两次输入的密码不同
{
QMessageBox *m = new QMessageBox;
m->setText("请确认两次密码相同");
m->show();
}
else //向服务器发送注册信息
{
timer->start();
ui->pushButton->setText("正在注册...");
Socket->newConnect();
QDataStream out(&(Socket->block),QIODevice::WriteOnly);
out<<tr("REGISTER")<<id<<name<<password;
Socket->sendMessage();
}
}
}
void register_window::connect_timeout() //连接服务器超时
{
timer->stop();
Socket->tcpsocket->abort();
QMessageBox *message = new QMessageBox;
message->setText("连接超时，请检查你的网络");
ui->pushButton->setText("确认");
message->show();
}
void register_window::response_for_registe() //服务器对账号注册的回应
{
timer->stop();
QDataStream in(Socket->block);
QString isRegisted;
in>>isRegisted;
if(isRegisted == "SUCCESS") //注册成功
{
MainWindow *mainWin = new MainWindow; //显示主页面
mainWin->setAttribute(Qt::WA_DeleteOnClose,true);
this->close();
host_account = ui->lineEdit_ID->text();
host_name = ui->lineEdit_name->text();
mainWin->setinfor(host_account,host_name);
mainWin->show();
Socket->block.clear();
}
else //注册失败
{
QMessageBox *message = new QMessageBox;
message->setText("注册失败");
message->show();
ui->pushButton->setText("确认");
Socket->tcpsocket->abort(); //断开连接
}
}
| [
"1665327050@qq.com"
] | 1665327050@qq.com |
ad4e191a953733d654c1b278713786168dc4a67e | 023318452b2c0669cb456360eb94feeb8163fd4a | /ControlEstoque/mw_principal.h | 6eaa7b0f6bd326d768379f699ba9e506d85ddefa | [] | no_license | josewmarinho/controlEstoque | 7bc512b0f58b2f990b5c117a277b7661a37a387b | a53bbbf8b3b01b91f0d2784ac2a64aaeee5a1435 | refs/heads/master | 2022-12-18T01:43:57.695586 | 2020-09-23T17:06:21 | 2020-09-23T17:06:21 | 294,543,543 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 833 | h | #ifndef MW_PRINCIPAL_H
#define MW_PRINCIPAL_H
#include <QMainWindow>
#include <QtSql>
QT_BEGIN_NAMESPACE
namespace Ui { class mw_principal; }
QT_END_NAMESPACE
class mw_principal : public QMainWindow
{
Q_OBJECT
public:
mw_principal(QWidget *parent = nullptr);
~mw_principal();
QIcon cadFechado;
QIcon *cadAberto=new QIcon();
void fechar();
private slots:
void on_btn_bloquear_clicked();
void on_pushButton_2_clicked();
void on_actionEstoque_triggered();
void on_actionColaboradores_triggered();
void on_actionVendas_triggered();
void on_pushButton_3_clicked();
void on_pushButton_4_clicked();
void on_pushButton_5_clicked();
void on_actionSair_triggered();
void on_actionSobre_triggered();
private:
Ui::mw_principal *ui;
};
#endif // MW_PRINCIPAL_H
| [
"josewellingtonjunior@hotmail.com"
] | josewellingtonjunior@hotmail.com |
24f988f210051a6e49b8005677e1572df5007bd4 | 8433f3c273676339e441050d601d195cda35b9c6 | /src/qt/bitcoinstrings.cpp | a7571936888d746838fd7ba27a869f198f512c1a | [
"MIT"
] | permissive | BTCDDev/VpnCoin-mac | bb24d8c5011145fb0472ba5cf750888e5862e628 | bf6426a334848bfc0d617c5add0b5d6dd74ceff2 | refs/heads/master | 2021-01-24T15:52:53.571871 | 2015-03-14T03:47:06 | 2015-03-14T03:47:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,988 | cpp | #include <QtGlobal>
// Automatically generated by extract_strings.py
#ifdef __GNUC__
#define UNUSED __attribute__((unused))
#else
#define UNUSED
#endif
static const char UNUSED *bitcoin_strings[] = {QT_TRANSLATE_NOOP("bitcoin-core", "To use the %s option"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"%s, you must set a rpcpassword in the configuration file:\n"
" %s\n"
"It is recommended you use the following random password:\n"
"rpcuser=vpncoinrpc\n"
"rpcpassword=%s\n"
"(you do not need to remember this password)\n"
"The username and password MUST NOT be the same.\n"
"If the file does not exist, create it with owner-readable-only file "
"permissions.\n"
"It is also recommended to set alertnotify so you are notified of problems;\n"
"for example: alertnotify=echo %%s | mail -s \"VPNCoin Alert\" admin@foo."
"com\n"),
QT_TRANSLATE_NOOP("bitcoin-core", "Error"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"An error occurred while setting up the RPC port %u for listening on IPv6, "
"falling back to IPv4: %s"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"An error occurred while setting up the RPC port %u for listening on IPv4: %s"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"You must set rpcpassword=<password> in the configuration file:\n"
"%s\n"
"If the file does not exist, create it with owner-readable-only file "
"permissions."),
QT_TRANSLATE_NOOP("bitcoin-core", "VPNCoin version"),
QT_TRANSLATE_NOOP("bitcoin-core", "Usage:"),
QT_TRANSLATE_NOOP("bitcoin-core", "Send command to -server or vpncoind"),
QT_TRANSLATE_NOOP("bitcoin-core", "List commands"),
QT_TRANSLATE_NOOP("bitcoin-core", "Get help for a command"),
QT_TRANSLATE_NOOP("bitcoin-core", "VPNCoin"),
QT_TRANSLATE_NOOP("bitcoin-core", "Options:"),
QT_TRANSLATE_NOOP("bitcoin-core", "This help message"),
QT_TRANSLATE_NOOP("bitcoin-core", "Specify configuration file (default: vpncoin.conf)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Specify pid file (default: vpncoind.pid)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Specify data directory"),
QT_TRANSLATE_NOOP("bitcoin-core", "Specify wallet file (within data directory)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Set database cache size in megabytes (default: 25)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Set database disk log size in megabytes (default: 100)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Specify connection timeout in milliseconds (default: 5000)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Connect through socks proxy"),
QT_TRANSLATE_NOOP("bitcoin-core", "Select the version of socks proxy to use (4-5, default: 5)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Use proxy to reach tor hidden services (default: same as -proxy)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Allow DNS lookups for -addnode, -seednode and -connect"),
QT_TRANSLATE_NOOP("bitcoin-core", "Listen for connections on <port> (default: 15714 or testnet: 25714)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Maintain at most <n> connections to peers (default: 125)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Add a node to connect to and attempt to keep the connection open"),
QT_TRANSLATE_NOOP("bitcoin-core", "Connect only to the specified node(s)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Connect to a node to retrieve peer addresses, and disconnect"),
QT_TRANSLATE_NOOP("bitcoin-core", "Specify your own public address"),
QT_TRANSLATE_NOOP("bitcoin-core", "Only connect to nodes in network <net> (IPv4, IPv6 or Tor)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Discover own IP address (default: 1 when listening and no -externalip)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Accept connections from outside (default: 1 if no -proxy or -connect)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Bind to given address. Use [host]:port notation for IPv6"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Query for peer addresses via DNS lookup, if low on addresses (default: 1 "
"unless -connect)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Always query for peer addresses via DNS lookup (default: 0)"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Sync time with other nodes. Disable if time on your system is precise e.g. "
"syncing with NTP (default: 1)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Sync checkpoints policy (default: strict)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Threshold for disconnecting misbehaving peers (default: 100)"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Number of seconds to keep misbehaving peers from reconnecting (default: "
"86400)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Maximum per-connection receive buffer, <n>*1000 bytes (default: 5000)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Maximum per-connection send buffer, <n>*1000 bytes (default: 1000)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Use UPnP to map the listening port (default: 1 when listening)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Use UPnP to map the listening port (default: 0)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Fee per KB to add to transactions you send"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"When creating transactions, ignore inputs with value less than this "
"(default: 0.01)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Accept command line and JSON-RPC commands"),
QT_TRANSLATE_NOOP("bitcoin-core", "Run in the background as a daemon and accept commands"),
QT_TRANSLATE_NOOP("bitcoin-core", "Use the test network"),
QT_TRANSLATE_NOOP("bitcoin-core", "Output extra debugging information. Implies all other -debug* options"),
QT_TRANSLATE_NOOP("bitcoin-core", "Output extra network debugging information"),
QT_TRANSLATE_NOOP("bitcoin-core", "Prepend debug output with timestamp"),
QT_TRANSLATE_NOOP("bitcoin-core", "Shrink debug.log file on client startup (default: 1 when no -debug)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Send trace/debug info to console instead of debug.log file"),
QT_TRANSLATE_NOOP("bitcoin-core", "Send trace/debug info to debugger"),
QT_TRANSLATE_NOOP("bitcoin-core", "Username for JSON-RPC connections"),
QT_TRANSLATE_NOOP("bitcoin-core", "Password for JSON-RPC connections"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Listen for JSON-RPC connections on <port> (default: 15715 or testnet: 25715)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Allow JSON-RPC connections from specified IP address"),
QT_TRANSLATE_NOOP("bitcoin-core", "Send commands to node running on <ip> (default: 127.0.0.1)"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Execute command when the best block changes (%s in cmd is replaced by block "
"hash)"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Execute command when a wallet transaction changes (%s in cmd is replaced by "
"TxID)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Require a confirmations for change (default: 0)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Minimize weight consumption (experimental) (default: 0)"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Execute command when a relevant alert is received (%s in cmd is replaced by "
"message)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Upgrade wallet to latest format"),
QT_TRANSLATE_NOOP("bitcoin-core", "Set key pool size to <n> (default: 100)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Rescan the block chain for missing wallet transactions"),
QT_TRANSLATE_NOOP("bitcoin-core", "Attempt to recover private keys from a corrupt wallet.dat"),
QT_TRANSLATE_NOOP("bitcoin-core", "How many blocks to check at startup (default: 2500, 0 = all)"),
QT_TRANSLATE_NOOP("bitcoin-core", "How thorough the block verification is (0-6, default: 1)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Imports blocks from external blk000?.dat file"),
QT_TRANSLATE_NOOP("bitcoin-core", "Block creation options:"),
QT_TRANSLATE_NOOP("bitcoin-core", "Set minimum block size in bytes (default: 0)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Set maximum block size in bytes (default: 250000)"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Set maximum size of high-priority/low-fee transactions in bytes (default: "
"27000)"),
QT_TRANSLATE_NOOP("bitcoin-core", "SSL options: (see the Bitcoin Wiki for SSL setup instructions)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Use OpenSSL (https) for JSON-RPC connections"),
QT_TRANSLATE_NOOP("bitcoin-core", "Server certificate file (default: server.cert)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Server private key (default: server.pem)"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Acceptable ciphers (default: TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:"
"@STRENGTH)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Invalid amount for -paytxfee=<amount>: '%s'"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Warning: -paytxfee is set very high! This is the transaction fee you will "
"pay if you send a transaction."),
QT_TRANSLATE_NOOP("bitcoin-core", "Invalid amount for -mininput=<amount>: '%s'"),
QT_TRANSLATE_NOOP("bitcoin-core", "Initialization sanity check failed. VPNCoin is shutting down."),
QT_TRANSLATE_NOOP("bitcoin-core", "Wallet %s resides outside data directory %s."),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Cannot obtain a lock on data directory %s. VPNCoin is probably already "
"running."),
QT_TRANSLATE_NOOP("bitcoin-core", "Verifying database integrity..."),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Error initializing database environment %s! To recover, BACKUP THAT "
"DIRECTORY, then remove everything from it except for wallet.dat."),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Warning: wallet.dat corrupt, data salvaged! Original wallet.dat saved as "
"wallet.{timestamp}.bak in %s; if your balance or transactions are incorrect "
"you should restore from a backup."),
QT_TRANSLATE_NOOP("bitcoin-core", "wallet.dat corrupt, salvage failed"),
QT_TRANSLATE_NOOP("bitcoin-core", "Unknown -socks proxy version requested: %i"),
QT_TRANSLATE_NOOP("bitcoin-core", "Unknown network specified in -onlynet: '%s'"),
QT_TRANSLATE_NOOP("bitcoin-core", "Invalid -proxy address: '%s'"),
QT_TRANSLATE_NOOP("bitcoin-core", "Invalid -tor address: '%s'"),
QT_TRANSLATE_NOOP("bitcoin-core", "Cannot resolve -bind address: '%s'"),
QT_TRANSLATE_NOOP("bitcoin-core", "Failed to listen on any port. Use -listen=0 if you want this."),
QT_TRANSLATE_NOOP("bitcoin-core", "Cannot resolve -externalip address: '%s'"),
QT_TRANSLATE_NOOP("bitcoin-core", "Invalid amount for -reservebalance=<amount>"),
QT_TRANSLATE_NOOP("bitcoin-core", "Unable to sign checkpoint, wrong checkpointkey?\n"),
QT_TRANSLATE_NOOP("bitcoin-core", "Loading block index..."),
QT_TRANSLATE_NOOP("bitcoin-core", "Error loading blkindex.dat"),
QT_TRANSLATE_NOOP("bitcoin-core", "Loading wallet..."),
QT_TRANSLATE_NOOP("bitcoin-core", "Error loading wallet.dat: Wallet corrupted"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Warning: error reading wallet.dat! All keys read correctly, but transaction "
"data or address book entries might be missing or incorrect."),
QT_TRANSLATE_NOOP("bitcoin-core", "Error loading wallet.dat: Wallet requires newer version of VPNCoin"),
QT_TRANSLATE_NOOP("bitcoin-core", "Wallet needed to be rewritten: restart VPNCoin to complete"),
QT_TRANSLATE_NOOP("bitcoin-core", "Error loading wallet.dat"),
QT_TRANSLATE_NOOP("bitcoin-core", "Cannot downgrade wallet"),
QT_TRANSLATE_NOOP("bitcoin-core", "Cannot write default address"),
QT_TRANSLATE_NOOP("bitcoin-core", "Rescanning..."),
QT_TRANSLATE_NOOP("bitcoin-core", "Importing blockchain data file."),
QT_TRANSLATE_NOOP("bitcoin-core", "Importing bootstrap blockchain data file."),
QT_TRANSLATE_NOOP("bitcoin-core", "Loading addresses..."),
QT_TRANSLATE_NOOP("bitcoin-core", "Error: could not start node"),
QT_TRANSLATE_NOOP("bitcoin-core", "Done loading"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Unable to bind to %s on this computer. VPNCoin is probably already running."),
QT_TRANSLATE_NOOP("bitcoin-core", "Unable to bind to %s on this computer (bind returned error %d, %s)"),
QT_TRANSLATE_NOOP("bitcoin-core", "Error: Wallet locked, unable to create transaction "),
QT_TRANSLATE_NOOP("bitcoin-core", "Error: Wallet unlocked for staking only, unable to create transaction."),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Error: This transaction requires a transaction fee of at least %s because of "
"its amount, complexity, or use of recently received funds "),
QT_TRANSLATE_NOOP("bitcoin-core", "Error: Transaction creation failed "),
QT_TRANSLATE_NOOP("bitcoin-core", "Sending..."),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Error: The transaction was rejected. This might happen if some of the coins "
"in your wallet were already spent, such as if you used a copy of wallet.dat "
"and coins were spent in the copy but not marked as spent here."),
QT_TRANSLATE_NOOP("bitcoin-core", "Invalid amount"),
QT_TRANSLATE_NOOP("bitcoin-core", "Insufficient funds"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"Warning: Please check that your computer's date and time are correct! If "
"your clock is wrong VPNCoin will not work properly."),
QT_TRANSLATE_NOOP("bitcoin-core", "Warning: This version is obsolete, upgrade required!"),
QT_TRANSLATE_NOOP("bitcoin-core", "WARNING: syncronized checkpoint violation detected, but skipped!"),
QT_TRANSLATE_NOOP("bitcoin-core", "Warning: Disk space is low!"),
QT_TRANSLATE_NOOP("bitcoin-core", ""
"WARNING: Invalid checkpoint found! Displayed transactions may not be "
"correct! You may need to upgrade, or notify developers."),
}; | [
"whitj00@ymail.com"
] | whitj00@ymail.com |
60dec965ccd6b689edbcc693243dc1af7de33af0 | 9b211466cc37ba4ea4549c48ce873a51078e3d14 | /FBStringLib/StringConverter.cpp | 65982b39d93b16023acd8c5e37028c9025cf45dc | [] | no_license | wangscript/fastbirdEngine | d3d0647409c560b242ad705588a78690e6f38044 | 1cbe629e95ddea48e6cffd90ed344e4034b86867 | refs/heads/master | 2021-01-24T01:59:07.460774 | 2016-01-27T22:23:31 | 2016-01-27T22:23:31 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,243 | cpp | /*
-----------------------------------------------------------------------------
This source file is part of fastbird engine
For the latest info, see http://www.jungwan.net/
Copyright (c) 2013-2015 Jungwan Byun
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 "StringConverter.h"
#include "StringLib.h"
#include <sstream>
namespace fb{
TString StringConverter::ToString(Real val, unsigned short precision,
unsigned short width, char fill, std::ios::fmtflags flags)
{
std::_tstringstream stream;
stream.precision(precision);
stream.width(width);
stream.fill(fill);
if (flags)
stream.setf(flags);
stream << val;
return stream.str();
}
//-----------------------------------------------------------------------
TString StringConverter::ToString(int val,
unsigned short width, char fill, std::ios::fmtflags flags)
{
std::_tstringstream stream;
stream.width(width);
stream.fill(fill);
if (flags)
stream.setf(flags);
stream << val;
return stream.str();
}
//-----------------------------------------------------------------------
TString StringConverter::ToString(size_t val,
unsigned short width, char fill, std::ios::fmtflags flags)
{
std::_tstringstream stream;
stream.width(width);
stream.fill(fill);
if (flags)
stream.setf(flags);
stream << val;
return stream.str();
}
//-----------------------------------------------------------------------
TString StringConverter::ToString(unsigned long val,
unsigned short width, char fill, std::ios::fmtflags flags)
{
std::_tstringstream stream;
stream.width(width);
stream.fill(fill);
if (flags)
stream.setf(flags);
stream << val;
return stream.str();
}
//-----------------------------------------------------------------------
TString StringConverter::ToStringK(unsigned val)
{
std::_tstringstream stream;
if (val > 1000)
{
val += 500;
val /= 1000;
stream << val << "K";
}
else
{
stream << val;
}
return stream.str();
}
//-----------------------------------------------------------------------
TString StringConverter::ToString(long val,
unsigned short width, char fill, std::ios::fmtflags flags)
{
std::_tstringstream stream;
stream.width(width);
stream.fill(fill);
if (flags)
stream.setf(flags);
stream << val;
return stream.str();
}
//-----------------------------------------------------------------------
TString StringConverter::ToString(bool val, bool yesNo)
{
if (val)
{
if (yesNo)
{
return _T("yes");
}
else
{
return _T("true");
}
}
else
if (yesNo)
{
return _T("no");
}
else
{
return _T("false");
}
}
//-----------------------------------------------------------------------
TString StringConverter::ToString(const TStringVector& val)
{
std::_tstringstream stream;
TStringVector::const_iterator i, iend, ibegin;
ibegin = val.begin();
iend = val.end();
for (i = ibegin; i != iend; ++i)
{
if (i != ibegin)
stream << " ";
stream << *i;
}
return stream.str();
}
TString StringConverter::ToHexa(unsigned val){
std::stringstream stream;
stream << "0x" << std::hex << val;
return stream.str();
}
//-----------------------------------------------------------------------
Real StringConverter::ParseReal(const TString& val, Real defaultValue)
{
// Use istd::_tstringstream for direct correspondence with ToString
std::_tstringstream str(val);
Real ret = defaultValue;
str >> ret;
return ret;
}
//-----------------------------------------------------------------------
int StringConverter::ParseInt(const TString& val, int defaultValue)
{
// Use istd::_tstringstream for direct correspondence with ToString
std::_tstringstream str(val);
int ret = defaultValue;
str >> ret;
return ret;
}
//-----------------------------------------------------------------------
unsigned int StringConverter::ParseUnsignedInt(const TString& val, unsigned int defaultValue)
{
// Use istd::_tstringstream for direct correspondence with ToString
std::_tstringstream str(val);
unsigned int ret = defaultValue;
str >> ret;
return ret;
}
unsigned int StringConverter::ParseHexa(const TString& val, unsigned int defaultValue)
{
std::_tstringstream str(val);
unsigned int ret = defaultValue;
str >> std::hex >> ret;
return ret;
}
//-----------------------------------------------------------------------
long StringConverter::ParseLong(const TString& val, long defaultValue)
{
// Use istd::_tstringstream for direct correspondence with ToString
std::_tstringstream str(val);
long ret = defaultValue;
str >> ret;
return ret;
}
//-----------------------------------------------------------------------
unsigned long StringConverter::ParseUnsignedLong(const TString& val, unsigned long defaultValue)
{
// Use istd::_tstringstream for direct correspondence with ToString
std::_tstringstream str(val);
unsigned long ret = defaultValue;
str >> ret;
return ret;
}
unsigned long long StringConverter::ParseUnsignedLongLong(const TString& val, unsigned long long defaultValue)
{
std::_tstringstream str(val);
unsigned long long ret = defaultValue;
str >> ret;
return ret;
}
//-----------------------------------------------------------------------
bool StringConverter::ParseBool(const TString& val, bool defaultValue)
{
if ((StartsWith(val, _T("true")) || StartsWith(val, _T("yes"))
|| StartsWith(val, _T("1"))))
return true;
else if ((StartsWith(val, _T("false")) || StartsWith(val, _T("no"))
|| StartsWith(val, _T("0"))))
return false;
else
return defaultValue;
}
//-----------------------------------------------------------------------
TStringVector StringConverter::ParseStringVector(const TString& val, const std::string& delims,
unsigned int maxSplits , bool preserveDelims)
{
return Split(val, delims, maxSplits, preserveDelims);
}
//-----------------------------------------------------------------------
bool StringConverter::IsNumber(const TString& val)
{
std::_tstringstream str(val);
float tst;
str >> tst;
return !str.fail() && str.eof();
}
} | [
"jungwan82@gmail.com"
] | jungwan82@gmail.com |
6d79d9312bec42f24108af9bc77fcea1b607b7a9 | 1a467ebe83af21f1a2ff984c2b980c09a4961c58 | /app/src/main/cpp/libffmpeg_decoder/audio_packet.cpp | 836cf9012b4c424d8b46ce560ed529f6e3a68bfd | [] | no_license | fanzhangvip/ffmpegdecodePcm | c109d1a449bed07d27237f3bff72c0e07718102e | f2728bf20d41dc4cdc91ccc339157a188e761769 | refs/heads/master | 2020-03-24T17:13:42.891655 | 2018-05-10T09:35:29 | 2018-05-10T09:35:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 63 | cpp | //
// Created by TY on 2018/5/9.
//
#include "audio_packet.h"
| [
"568478312@qq.com"
] | 568478312@qq.com |
eca69d50e218cceb9a59ff6a1374bf5447a32ada | e1769b6b7ed2335b2cf5a7f6b847cb8c8d53db0e | /source/put/source/loader.h | d671616487e434d402ffb9e43b3e14755726f9bf | [
"MIT"
] | permissive | dejan-stankovic/pmtech | c286290555cfb9440f579820420bed5b39284df1 | 97593bb8bb2a4f592e0505a00ebca7ba2e709efc | refs/heads/master | 2020-11-27T16:18:20.553060 | 2019-11-28T21:38:55 | 2019-11-28T21:38:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 869 | h | // loader.h
// Copyright 2014 - 2019 Alex Dixon.
// License: https://github.com/polymonster/pmtech/blob/master/license.md
#pragma once
#include "pen.h"
#include "renderer.h"
#include "str/Str.h"
#include <vector>
namespace put
{
typedef pen::texture_creation_params texture_info;
// Textures
u32 load_texture(const c8* filename);
void save_texture(const c8* filename, const texture_info& tcp);
void get_texture_info(u32 handle, texture_info& info);
Str get_texture_filename(u32 handle);
void texture_browser_ui();
// Hot loading
void init_hot_loader();
void poll_hot_loader();
void trigger_hot_loader(const Str& cmd);
Str get_build_cmd();
void add_file_watcher(const c8* filename, void (*build_callback)(),
void (*hotload_callback)(std::vector<hash_id>& dirty));
} // namespace put
| [
"alexandercdixon@gmail.com"
] | alexandercdixon@gmail.com |
36363abb212bd556c20f76e8ca4b409b7917e151 | 78d83fb73628a9a89d4861f35ef4f7a3d679c34a | /1024.cc | 8ea397f42bee8d3fc402c55098efd3d62d9f644e | [] | no_license | MrXJC/PAT-BASIC-LEVEL | 347e2ad716ee0560a7d6187a4e50d95789c1c094 | c6cd1968e47b53af7ca51855be2620bfcebb8458 | refs/heads/master | 2016-08-12T16:28:24.344166 | 2016-03-10T07:00:44 | 2016-03-10T07:00:44 | 52,589,194 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 830 | cc | #include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<sstream>
#define LOCAL
using namespace std;
int main()
{
#ifdef LOCAL
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#endif
char sign,dir,ch,b[10001],zhi[10001];
int ex,a,i;
int length;
scanf("%c%d.%[^E]E%c%s",&sign,&a,b,&dir,zhi);
stringstream io;
io<<zhi;
io>>ex;
if(sign=='-')
cout<<"-";
if(ex==0){
printf("%d.",a);
printf("%s\n",b);
return 0;
}
if(dir=='+')
{
int len;
len = strlen(b);
printf("%d",a);
if(len<=ex){
printf("%s",b);
for(i=0;i<ex-len;++i)printf("0");
printf("\n");
}else{
for(i=0;i<ex;++i){
printf("%c",b[i]);
}
printf(".");
printf("%s\n",b+ex);
}
}
else
{
printf("0.");
for(i=0;i<ex-1;++i){
printf("0");
}
printf("%d",a);
printf("%s\n",b);
}
return 0;
}
| [
"281514212@qq.com"
] | 281514212@qq.com |
dc3582b5f243d32b37e608ef35de453d168ea454 | 60cbf52012b82f1c3d3dbdbab8e98089c19ffd99 | /stacks and queue/reverse stack using 1 stack.cpp | cae4156a2af4e8a563111da09b2737cd13da681f | [] | no_license | harshitmuhal/cpp | 7b55841c7a87785b2307971c1e342f7cb2d16326 | 71b5027a8a8ed36b6c56ba93089d5f6f87314ab3 | refs/heads/master | 2023-08-21T17:34:53.532972 | 2021-10-05T12:44:14 | 2021-10-05T12:44:14 | 196,346,853 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 475 | cpp | #include<bits/stdc++.h>
using namespace std;
void display(stack<int>s){
while(!s.empty()){
cout<<s.top()<<" ";
s.pop();
}
cout<<endl;
}
void reverse(stack<int>&s,stack<int>tmp){
if(tmp.empty()){
return;
}
int x=tmp.top();
tmp.pop();
reverse(s,tmp);
s.push(x);
}
int main(){
stack<int>s;
s.push(1);
s.push(2);
s.push(3);
s.push(4);
display(s);
stack<int>tmp;
while(!s.empty()){
tmp.push(s.top());
s.pop();
}
reverse(s,tmp);
display(s);
return 0;
} | [
"harshit@Harshits-MacBook-Air.local"
] | harshit@Harshits-MacBook-Air.local |
332b632e040f3e863bdf8f9d344ec4f30f9e6fae | 6e3fb0d07ff23762d832272e888bf757e412e875 | /VxSdkNet/Include/VideoEncodingOption.h | b8179c8a63e7b7560b2e1c2adb2dfc61652c0f7e | [] | no_license | pelcointegrations/VxSdk.NET | a5fac199c6f8d2ee4df78e5056209b6bb7a87767 | a4ea664068bfc9066f5afc67f0096c4573900b1d | refs/heads/master | 2022-01-28T16:36:58.632979 | 2022-01-12T19:57:05 | 2022-01-12T19:57:05 | 165,756,408 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,847 | h | // Declares the video encoding option class.
#ifndef VideoEncodingOption_h__
#define VideoEncodingOption_h__
#include "VxSdk.h"
namespace VxSdkNet {
/// <summary>
/// The VideoEncodingOption class represents the valid video encoding options/limits for the specified format.
/// </summary>
public ref class VideoEncodingOption {
public:
/// <summary>
/// Values that represent the profile used by an encoder to select the features used.
/// </summary>
enum class EncoderProfile {
/// <summary>An error or unknown value was returned.</summary>
Unknown,
/// <summary>MPEG4 Advanced Simple profile.</summary>
AdvancedSimple,
/// <summary>H264 Baseline profile.</summary>
Baseline,
/// <summary>H264 Extended profile.</summary>
Extended,
/// <summary>H264 High profile.</summary>
High,
/// <summary>H264/H265 Main profile.</summary>
Main,
/// <summary>H265 Main10 profile.</summary>
Main10,
/// <summary>MPEG4 Simple profile.</summary>
Simple
};
/// <summary>
/// Constructor.
/// </summary>
VideoEncodingOption() {
Framerates = gcnew System::Collections::Generic::List<float>();
Profiles = gcnew System::Collections::Generic::List<EncoderProfile>();
RateControls = gcnew System::Collections::Generic::List<System::String^>();
Resolutions = gcnew System::Collections::Generic::List<Resolution^>();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="vxVideoEncodingOption">The vx video encoding option.</param>
VideoEncodingOption(VxSdk::VxVideoEncodingOption* vxVideoEncodingOption) {
Format = (DataInterface::StreamFormats)vxVideoEncodingOption->format;
HasOptions = vxVideoEncodingOption->hasOptions;
MaxBitrate = vxVideoEncodingOption->maxBitrate;
MinBitrate = vxVideoEncodingOption->minBitrate;
MaxGop = vxVideoEncodingOption->maxGop;
MinGop = vxVideoEncodingOption->minGop;
Framerates = gcnew System::Collections::Generic::List<float>();
for (int i = 0; i < vxVideoEncodingOption->frameratesSize; i++) {
Framerates->Add(vxVideoEncodingOption->framerates[i]);
}
Profiles = gcnew System::Collections::Generic::List<EncoderProfile>();
for (int i = 0; i < vxVideoEncodingOption->profilesSize; i++) {
Profiles->Add((EncoderProfile)vxVideoEncodingOption->profiles[i]);
}
RateControls = gcnew System::Collections::Generic::List<System::String^>();
for (int i = 0; i < vxVideoEncodingOption->rateControlsSize; i++) {
RateControls->Add(Utils::ConvertCppString(vxVideoEncodingOption->rateControls[i]));
}
Resolutions = gcnew System::Collections::Generic::List<Resolution^>();
for (int i = 0; i < vxVideoEncodingOption->resolutionsSize; i++) {
Resolutions->Add(gcnew Resolution(&vxVideoEncodingOption->resolutions[i]));
}
}
/// <summary>
/// Gets or sets the media stream encoding format that these options/limits apply to.
/// </summary>
/// <value>The media stream encoding format.</value>
property DataInterface::StreamFormats Format;
/// <summary>
/// Gets or sets the list of valid framerates.
/// </summary>
/// <value>A <c>List</c> of valid framerates.</value>
property System::Collections::Generic::List<float>^ Framerates;
/// <summary>
/// Gets or sets whether there are any video encoding options available. If <c>true</c> you must first switch to
/// the <see cref="Format"/> to determine them.
/// </summary>
/// <value><c>true</c> if there are options available, otherwise <c>false</c>.</value>
property bool HasOptions;
/// <summary>
/// Gets or sets the maximum bitrate that can be set for the stream (in bps).
/// </summary>
/// <value>The maximum bitrate (in bps).</value>
property int MaxBitrate;
/// <summary>
/// Gets or sets the maximum GOP size that can be set for the stream.
/// </summary>
/// <value>The maximum GOP size.</value>
property int MaxGop;
/// <summary>
/// Gets or sets the minimum bitrate that can be set for the stream (in bps).
/// </summary>
/// <value>The minimum bitrate (in bps).</value>
property int MinBitrate;
/// <summary>
/// Gets or sets the minimum GOP size that can be set for the stream.
/// </summary>
/// <value>The minimum GOP size.</value>
property int MinGop;
/// <summary>
/// Gets or sets the list of encoding profiles that are available for the stream.
/// </summary>
/// <value>A <c>List</c> of encoding profiles.</value>
property System::Collections::Generic::List<EncoderProfile>^ Profiles;
/// <summary>
/// Gets or sets the list of available methods that control the bitrate of the stream.
/// </summary>
/// <value>A <c>List</c> of rate control methods.</value>
property System::Collections::Generic::List<System::String^>^ RateControls;
/// <summary>
/// Gets or sets the list of resolutions that are available for the stream.
/// </summary>
/// <value>A <c>List</c> of resolutions.</value>
property System::Collections::Generic::List<Resolution^>^ Resolutions;
};
}
#endif // VideoEncodingOption_h__ | [
"zach.moore@pelco.com"
] | zach.moore@pelco.com |
033d241a6ebd4eb80be945d925e52b0079555e43 | efda10cc1ec6ada8ae4dd704262e5930098a852f | /Practice/36/C++/TridtsatShestoye.cpp | 2ec32d3a46472b8425f0dd7e1849b6a8ccc9b859 | [] | no_license | FragrantScorpio/Programming | 6e0bb7822307593d120eabc593de6b14e7140d1f | 810382c78cd671046f816ce175a5b6402da8bf2f | refs/heads/main | 2023-04-27T16:52:30.508057 | 2021-05-16T16:11:15 | 2021-05-16T16:11:15 | 302,444,771 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,380 | cpp | #include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
const auto PI = 3.141592653589793;
const double limit = 1e-10;
enum coord_system
{
Cartesian,
Polar
};
class Point {
private:
double x, y;
public:
string data;
Point(double a1 = 0, double a2 = 0, coord_system syst= coord_system::Cartesian)
{
if (syst == coord_system::Cartesian) { this->x = a1; this->y = a2; }
else {
x = a1 * cos(a2); y = a1 * sin(a2);
}
};
double get_x() { return this->x; }
double get_y() { return this->y; }
double get_r() { return sqrt((pow(x, 2) + pow(y, 2))); }
double get_phi() { return atan2(this->y, this->x); }
void set_x(double a) { x = a; return; }
void set_y(double a) { y = a; return; }
void set_r(double r) { double f = (get_phi()); this->x = r * cos(f); this->y = r * sin(f); return; }
void set_phi(double phi) {
double buff = get_r(); x = buff * cos(phi); y = buff * sin(phi);
return; }
bool operator==(Point p2)
{
if ((abs(this->get_x() - p2.get_x()) <= limit) and (abs(this->get_y() - p2.get_y() <= limit))) return 1;
else return 0;
}
bool operator!=(Point p2) { return *this != p2; };
friend ostream& operator<<(ostream& output, Point& p)
{
output << "(" << p.get_x() << "," << p.get_y() << "), ";
return output;
}
friend istream& operator>> (istream& input, Point& p)
{
string buf;
input >> buf;
if (buf[0] == '(') { buf = buf.substr(1); }
auto fin = buf.find(')');
buf = buf.substr(0, fin);
auto x = buf.substr(0, buf.find(','));
auto y = buf.substr(buf.find(',') + 1);
p.x = stod(x);
p.y = stod(y);
return input;
}
};
int main() {
std::vector<Point> original;
std::ifstream fin("data.txt");
if (!fin.is_open()) {
std::cout << "Can't open file" << std::endl;
return 1;
}
else {
while (!fin.eof()) {
Point p;
fin >> p;
fin.ignore(2); // Точки разделены двумя символами ", "
original.push_back(p);
}
fin.close();
}
std::vector<Point> simulacrum(original);
for (auto& p : simulacrum) {
std::cout << "before\n" << p << "\n";
p.set_x(p.get_x() + 10);
p.set_phi(p.get_phi() + 180 * PI / 180);
p.set_y(-p.get_y());
p.set_x(-p.get_x() - 10);
//если убрать тут минус и удалить set_phi и set_y то будет выдавать it works, следовательно
//мне надо было сделать так, чтобы при вызова phi или Y он менял значения из одной системы в другую
//после всех вычислений все вернулрсь бы на исходную, но у меня это не вышло, я сделал все что в моих силах
std::cout << "after\n" << p << std::endl;
}
if (std::equal(original.begin(), original.end(), simulacrum.begin()))
std::cout << "\nIt works!\n";
else
std::cout << "\nIt not works!\n";
}
| [
"71697086+FragrantScorpio@users.noreply.github.com"
] | 71697086+FragrantScorpio@users.noreply.github.com |
b083eb8c1b402933cc5fd01e3f76b583e85b136f | 0b7fd0e1314d442780395068305b511cf3f6d7ca | /src/vertical3d/input/MouseEventListener.h | c0bf9c1de620915c0d8e557415c29e23b7ee6f93 | [] | no_license | sigsegv42/v3dlibs | b1baa4b07df46d5168ed169b5ae95a5c4c693085 | 2fad4d38b1700442f0b15a6b8db200f1925dd1e9 | refs/heads/master | 2020-06-02T10:54:47.188214 | 2014-12-24T21:40:07 | 2014-12-24T21:40:07 | 1,419,110 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 580 | h | /**
* (c) Joshua Farr <j.wgasa@gmail.com>
*/
#ifndef INCLUDED_V3D_MOUSEEVENTLISTENER
#define INCLUDED_V3D_MOUSEEVENTLISTENER
#include "../event/EventListener.h"
namespace v3D
{
/**
* An event listener for mouse events.
*/
class MouseEventListener : public EventListener
{
public:
virtual ~MouseEventListener() { }
virtual void motion(unsigned int x, unsigned int y) = 0;
virtual void buttonPressed(unsigned int button) = 0;
virtual void buttonReleased(unsigned int button) = 0;
};
}; // end namespace v3D
#endif // INCLUDED_V3D_MOUSEEVENTLISTENER
| [
"j.wgasa@gmail.com"
] | j.wgasa@gmail.com |
4451d174b43fd40638a4830c1ba802c8e4de56f5 | 367fba5df552aef1ee9aa6add6bb512b781bc6d4 | /3rdParty/nodejs/8.0.0/source/deps/icu-small/source/common/norm2allmodes.h | 9516817e4aa8f3c198ac6ea9df2def2b5b298a17 | [
"ICU",
"NTP",
"ISC",
"LicenseRef-scancode-openssl",
"Artistic-2.0",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause",
"NAIST-2003",
"BSD-3-Clause",
"Zlib",
"LicenseRef-scancode-unknown-license-reference",
"MIT",
"LicenseRef-scancode-unicode",
"LicenseRef-scancode-free-unknown"
] | permissive | hamoriakos/ApertusVR | 2d3e5736b26404198b222d24388bb3c1c162ee69 | 14303ab54963e52409ed376cdafae5c43004074b | refs/heads/master | 2021-09-16T00:13:48.980732 | 2017-06-28T18:23:14 | 2017-06-28T18:23:14 | 105,749,913 | 0 | 1 | MIT | 2018-06-13T13:54:38 | 2017-10-04T09:11:13 | C++ | UTF-8 | C++ | false | false | 13,027 | h | // © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
* Copyright (C) 2014, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
* loadednormalizer2impl.h
*
* created on: 2014sep07
* created by: Markus W. Scherer
*/
#ifndef __NORM2ALLMODES_H__
#define __NORM2ALLMODES_H__
#include "unicode/utypes.h"
#if !UCONFIG_NO_NORMALIZATION
#include "unicode/normalizer2.h"
#include "unicode/unistr.h"
#include "cpputils.h"
#include "normalizer2impl.h"
U_NAMESPACE_BEGIN
// Intermediate class:
// Has Normalizer2Impl and does boilerplate argument checking and setup.
class Normalizer2WithImpl : public Normalizer2 {
public:
Normalizer2WithImpl(const Normalizer2Impl &ni) : impl(ni) {}
virtual ~Normalizer2WithImpl();
// normalize
virtual UnicodeString &
normalize(const UnicodeString &src,
UnicodeString &dest,
UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) {
dest.setToBogus();
return dest;
}
const UChar *sArray=src.getBuffer();
if(&dest==&src || sArray==NULL) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
dest.setToBogus();
return dest;
}
dest.remove();
ReorderingBuffer buffer(impl, dest);
if(buffer.init(src.length(), errorCode)) {
normalize(sArray, sArray+src.length(), buffer, errorCode);
}
return dest;
}
virtual void
normalize(const UChar *src, const UChar *limit,
ReorderingBuffer &buffer, UErrorCode &errorCode) const = 0;
// normalize and append
virtual UnicodeString &
normalizeSecondAndAppend(UnicodeString &first,
const UnicodeString &second,
UErrorCode &errorCode) const {
return normalizeSecondAndAppend(first, second, TRUE, errorCode);
}
virtual UnicodeString &
append(UnicodeString &first,
const UnicodeString &second,
UErrorCode &errorCode) const {
return normalizeSecondAndAppend(first, second, FALSE, errorCode);
}
UnicodeString &
normalizeSecondAndAppend(UnicodeString &first,
const UnicodeString &second,
UBool doNormalize,
UErrorCode &errorCode) const {
uprv_checkCanGetBuffer(first, errorCode);
if(U_FAILURE(errorCode)) {
return first;
}
const UChar *secondArray=second.getBuffer();
if(&first==&second || secondArray==NULL) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return first;
}
int32_t firstLength=first.length();
UnicodeString safeMiddle;
{
ReorderingBuffer buffer(impl, first);
if(buffer.init(firstLength+second.length(), errorCode)) {
normalizeAndAppend(secondArray, secondArray+second.length(), doNormalize,
safeMiddle, buffer, errorCode);
}
} // The ReorderingBuffer destructor finalizes the first string.
if(U_FAILURE(errorCode)) {
// Restore the modified suffix of the first string.
first.replace(firstLength-safeMiddle.length(), 0x7fffffff, safeMiddle);
}
return first;
}
virtual void
normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
UnicodeString &safeMiddle,
ReorderingBuffer &buffer, UErrorCode &errorCode) const = 0;
virtual UBool
getDecomposition(UChar32 c, UnicodeString &decomposition) const {
UChar buffer[4];
int32_t length;
const UChar *d=impl.getDecomposition(c, buffer, length);
if(d==NULL) {
return FALSE;
}
if(d==buffer) {
decomposition.setTo(buffer, length); // copy the string (Jamos from Hangul syllable c)
} else {
decomposition.setTo(FALSE, d, length); // read-only alias
}
return TRUE;
}
virtual UBool
getRawDecomposition(UChar32 c, UnicodeString &decomposition) const {
UChar buffer[30];
int32_t length;
const UChar *d=impl.getRawDecomposition(c, buffer, length);
if(d==NULL) {
return FALSE;
}
if(d==buffer) {
decomposition.setTo(buffer, length); // copy the string (algorithmic decomposition)
} else {
decomposition.setTo(FALSE, d, length); // read-only alias
}
return TRUE;
}
virtual UChar32
composePair(UChar32 a, UChar32 b) const {
return impl.composePair(a, b);
}
virtual uint8_t
getCombiningClass(UChar32 c) const {
return impl.getCC(impl.getNorm16(c));
}
// quick checks
virtual UBool
isNormalized(const UnicodeString &s, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) {
return FALSE;
}
const UChar *sArray=s.getBuffer();
if(sArray==NULL) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return FALSE;
}
const UChar *sLimit=sArray+s.length();
return sLimit==spanQuickCheckYes(sArray, sLimit, errorCode);
}
virtual UNormalizationCheckResult
quickCheck(const UnicodeString &s, UErrorCode &errorCode) const {
return Normalizer2WithImpl::isNormalized(s, errorCode) ? UNORM_YES : UNORM_NO;
}
virtual int32_t
spanQuickCheckYes(const UnicodeString &s, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) {
return 0;
}
const UChar *sArray=s.getBuffer();
if(sArray==NULL) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
return (int32_t)(spanQuickCheckYes(sArray, sArray+s.length(), errorCode)-sArray);
}
virtual const UChar *
spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const = 0;
virtual UNormalizationCheckResult getQuickCheck(UChar32) const {
return UNORM_YES;
}
const Normalizer2Impl &impl;
};
class DecomposeNormalizer2 : public Normalizer2WithImpl {
public:
DecomposeNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {}
virtual ~DecomposeNormalizer2();
private:
virtual void
normalize(const UChar *src, const UChar *limit,
ReorderingBuffer &buffer, UErrorCode &errorCode) const {
impl.decompose(src, limit, &buffer, errorCode);
}
using Normalizer2WithImpl::normalize; // Avoid warning about hiding base class function.
virtual void
normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
UnicodeString &safeMiddle,
ReorderingBuffer &buffer, UErrorCode &errorCode) const {
impl.decomposeAndAppend(src, limit, doNormalize, safeMiddle, buffer, errorCode);
}
virtual const UChar *
spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const {
return impl.decompose(src, limit, NULL, errorCode);
}
using Normalizer2WithImpl::spanQuickCheckYes; // Avoid warning about hiding base class function.
virtual UNormalizationCheckResult getQuickCheck(UChar32 c) const {
return impl.isDecompYes(impl.getNorm16(c)) ? UNORM_YES : UNORM_NO;
}
virtual UBool hasBoundaryBefore(UChar32 c) const { return impl.hasDecompBoundary(c, TRUE); }
virtual UBool hasBoundaryAfter(UChar32 c) const { return impl.hasDecompBoundary(c, FALSE); }
virtual UBool isInert(UChar32 c) const { return impl.isDecompInert(c); }
};
class ComposeNormalizer2 : public Normalizer2WithImpl {
public:
ComposeNormalizer2(const Normalizer2Impl &ni, UBool fcc) :
Normalizer2WithImpl(ni), onlyContiguous(fcc) {}
virtual ~ComposeNormalizer2();
private:
virtual void
normalize(const UChar *src, const UChar *limit,
ReorderingBuffer &buffer, UErrorCode &errorCode) const {
impl.compose(src, limit, onlyContiguous, TRUE, buffer, errorCode);
}
using Normalizer2WithImpl::normalize; // Avoid warning about hiding base class function.
virtual void
normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
UnicodeString &safeMiddle,
ReorderingBuffer &buffer, UErrorCode &errorCode) const {
impl.composeAndAppend(src, limit, doNormalize, onlyContiguous, safeMiddle, buffer, errorCode);
}
virtual UBool
isNormalized(const UnicodeString &s, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) {
return FALSE;
}
const UChar *sArray=s.getBuffer();
if(sArray==NULL) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return FALSE;
}
UnicodeString temp;
ReorderingBuffer buffer(impl, temp);
if(!buffer.init(5, errorCode)) { // small destCapacity for substring normalization
return FALSE;
}
return impl.compose(sArray, sArray+s.length(), onlyContiguous, FALSE, buffer, errorCode);
}
virtual UNormalizationCheckResult
quickCheck(const UnicodeString &s, UErrorCode &errorCode) const {
if(U_FAILURE(errorCode)) {
return UNORM_MAYBE;
}
const UChar *sArray=s.getBuffer();
if(sArray==NULL) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return UNORM_MAYBE;
}
UNormalizationCheckResult qcResult=UNORM_YES;
impl.composeQuickCheck(sArray, sArray+s.length(), onlyContiguous, &qcResult);
return qcResult;
}
virtual const UChar *
spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &) const {
return impl.composeQuickCheck(src, limit, onlyContiguous, NULL);
}
using Normalizer2WithImpl::spanQuickCheckYes; // Avoid warning about hiding base class function.
virtual UNormalizationCheckResult getQuickCheck(UChar32 c) const {
return impl.getCompQuickCheck(impl.getNorm16(c));
}
virtual UBool hasBoundaryBefore(UChar32 c) const {
return impl.hasCompBoundaryBefore(c);
}
virtual UBool hasBoundaryAfter(UChar32 c) const {
return impl.hasCompBoundaryAfter(c, onlyContiguous, FALSE);
}
virtual UBool isInert(UChar32 c) const {
return impl.hasCompBoundaryAfter(c, onlyContiguous, TRUE);
}
const UBool onlyContiguous;
};
class FCDNormalizer2 : public Normalizer2WithImpl {
public:
FCDNormalizer2(const Normalizer2Impl &ni) : Normalizer2WithImpl(ni) {}
virtual ~FCDNormalizer2();
private:
virtual void
normalize(const UChar *src, const UChar *limit,
ReorderingBuffer &buffer, UErrorCode &errorCode) const {
impl.makeFCD(src, limit, &buffer, errorCode);
}
using Normalizer2WithImpl::normalize; // Avoid warning about hiding base class function.
virtual void
normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
UnicodeString &safeMiddle,
ReorderingBuffer &buffer, UErrorCode &errorCode) const {
impl.makeFCDAndAppend(src, limit, doNormalize, safeMiddle, buffer, errorCode);
}
virtual const UChar *
spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const {
return impl.makeFCD(src, limit, NULL, errorCode);
}
using Normalizer2WithImpl::spanQuickCheckYes; // Avoid warning about hiding base class function.
virtual UBool hasBoundaryBefore(UChar32 c) const { return impl.hasFCDBoundaryBefore(c); }
virtual UBool hasBoundaryAfter(UChar32 c) const { return impl.hasFCDBoundaryAfter(c); }
virtual UBool isInert(UChar32 c) const { return impl.isFCDInert(c); }
};
struct Norm2AllModes : public UMemory {
Norm2AllModes(Normalizer2Impl *i)
: impl(i), comp(*i, FALSE), decomp(*i), fcd(*i), fcc(*i, TRUE) {}
~Norm2AllModes();
static Norm2AllModes *createInstance(Normalizer2Impl *impl, UErrorCode &errorCode);
static Norm2AllModes *createNFCInstance(UErrorCode &errorCode);
static Norm2AllModes *createInstance(const char *packageName,
const char *name,
UErrorCode &errorCode);
static const Norm2AllModes *getNFCInstance(UErrorCode &errorCode);
static const Norm2AllModes *getNFKCInstance(UErrorCode &errorCode);
static const Norm2AllModes *getNFKC_CFInstance(UErrorCode &errorCode);
Normalizer2Impl *impl;
ComposeNormalizer2 comp;
DecomposeNormalizer2 decomp;
FCDNormalizer2 fcd;
ComposeNormalizer2 fcc;
};
U_NAMESPACE_END
#endif // !UCONFIG_NO_NORMALIZATION
#endif // __NORM2ALLMODES_H__
| [
"akos.hamori@sztaki.mta.hu"
] | akos.hamori@sztaki.mta.hu |
28429e32294227c922d4fc31ce59a3c3ad23138e | 46c937ea89163fc1bd95eb1ad61f114258cd015c | /lock.cpp | c88755d0502953de0b4a6585c001b8dcac0a59cb | [] | no_license | hakonmagnus/Cpp-tutorials | a3597c2049b0a282e0c41477c4d1c442e169b49e | 35c0aac650a9c2550846c30ad74dc762f9bbb344 | refs/heads/master | 2022-04-05T22:27:01.288302 | 2020-02-05T15:17:09 | 2020-02-05T15:17:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 67 | cpp | //std::lock in c++
//It is generally used to lock multiple mutex's
| [
"mandavia.u@husky.neu.edu"
] | mandavia.u@husky.neu.edu |
fa4645dd3b719a8ca83e84011360709bf89e06bb | 2b0ff7f7529350a00a34de9050d3404be6d588a0 | /048_對話盒相關/41_Disable_ESC/Disable_ESCDlg.h | 93ba3d08e163a5dede1b950ecc42f604052115ee | [] | no_license | isliulin/jashliao_VC | 6b234b427469fb191884df2def0b47c4948b3187 | 5310f52b1276379b267acab4b609a9467f43d8cb | refs/heads/master | 2023-05-13T09:28:49.756293 | 2021-06-08T13:40:23 | 2021-06-08T13:40:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,403 | h | // Disable_ESCDlg.h : header file
//
#if !defined(AFX_DISABLE_ESCDLG_H__932800B7_0E68_49D5_8E5C_062A3FCE9D49__INCLUDED_)
#define AFX_DISABLE_ESCDLG_H__932800B7_0E68_49D5_8E5C_062A3FCE9D49__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
/////////////////////////////////////////////////////////////////////////////
// CDisable_ESCDlg dialog
class CDisable_ESCDlg : public CDialog
{
// Construction
public:
CDisable_ESCDlg(CWnd* pParent = NULL); // standard constructor
// Dialog Data
//{{AFX_DATA(CDisable_ESCDlg)
enum { IDD = IDD_DISABLE_ESC_DIALOG };
// NOTE: the ClassWizard will add data members here
//}}AFX_DATA
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CDisable_ESCDlg)
public:
virtual BOOL PreTranslateMessage(MSG* pMsg);
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
HICON m_hIcon;
// Generated message map functions
//{{AFX_MSG(CDisable_ESCDlg)
virtual BOOL OnInitDialog();
afx_msg void OnSysCommand(UINT nID, LPARAM lParam);
afx_msg void OnPaint();
afx_msg HCURSOR OnQueryDragIcon();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_DISABLE_ESCDLG_H__932800B7_0E68_49D5_8E5C_062A3FCE9D49__INCLUDED_)
| [
"jash.liao@gmail.com"
] | jash.liao@gmail.com |
530462cf875c96b116e8c02047b7493e8b21e498 | 24ea2b22507a91e5d0e471603e5db55a43305d0c | /src/uscxml/plugins/datamodel/ecmascript/JavaScriptCore/dom/JSCNotation.cpp | 6ff9079c9266e76198395489c2c53210fd55023f | [
"BSD-2-Clause"
] | permissive | bjqiwei/uscxml | aa0af80c617d507b8707c49d6f0d16604944c3a2 | 944c17d31993cdf6a651f6a40ca0f7ea02100bd3 | refs/heads/master | 2021-01-17T23:35:48.523806 | 2013-10-28T20:43:27 | 2013-10-28T20:43:27 | 13,945,320 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,995 | cpp | /**
* @file
* @author This file has been generated by generate-bindings.pl. DO NOT MODIFY!
* @copyright Simplified BSD
*
* @cond
* This program is free software: you can redistribute it and/or modify
* it under the terms of the FreeBSD license as published by the FreeBSD
* project.
*
* 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.
*
* You should have received a copy of the FreeBSD license along with this
* program. If not, see <http://www.opensource.org/licenses/bsd-license>.
* @endcond
*/
#include "JSCNode.h"
#include "JSCNotation.h"
namespace Arabica {
namespace DOM {
JSClassRef JSCNotation::Tmpl;
JSStaticValue JSCNotation::staticValues[] = {
{ "publicId", publicIdAttrGetter, 0, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },
{ "systemId", systemIdAttrGetter, 0, kJSPropertyAttributeDontDelete | kJSPropertyAttributeReadOnly },
{ 0, 0, 0, 0 }
};
JSStaticFunction JSCNotation::staticFunctions[] = {
{ 0, 0, 0 }
};
JSValueRef JSCNotation::publicIdAttrGetter(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef *exception) {
struct JSCNotationPrivate* privData = (struct JSCNotationPrivate*)JSObjectGetPrivate(object);
JSStringRef stringRef = JSStringCreateWithUTF8CString(privData->nativeObj->getPublicId().c_str());
JSValueRef retVal = JSValueMakeString(ctx, stringRef);
JSStringRelease(stringRef);
return retVal;
}
JSValueRef JSCNotation::systemIdAttrGetter(JSContextRef ctx, JSObjectRef object, JSStringRef propertyName, JSValueRef *exception) {
struct JSCNotationPrivate* privData = (struct JSCNotationPrivate*)JSObjectGetPrivate(object);
JSStringRef stringRef = JSStringCreateWithUTF8CString(privData->nativeObj->getSystemId().c_str());
JSValueRef retVal = JSValueMakeString(ctx, stringRef);
JSStringRelease(stringRef);
return retVal;
}
}
}
| [
"radomski@tk.informatik.tu-darmstadt.de"
] | radomski@tk.informatik.tu-darmstadt.de |
a86dd677674b004fee3d950f114274407626a565 | dbe3235e2c741a2161702718922d9eba02499acb | /c++project/c++项目（2019.8）/Bullet.cpp | a730ca0c0610839d43275785e8f1c7643a100b3d | [
"MIT"
] | permissive | HeXavi8/2D_TankWar | 07b227fcd79e56d2b6cf9d96a7b9dcf682b4dcbc | 3b6d852b44aee9279d1250cb07b94bd165c7b903 | refs/heads/main | 2023-06-18T02:57:24.017603 | 2021-07-11T15:30:10 | 2021-07-11T15:30:10 | 334,987,520 | 3 | 0 | null | 2021-06-08T14:51:44 | 2021-02-01T15:06:20 | C++ | GB18030 | C++ | false | false | 3,269 | cpp | #include "Bullet.h"
Bullet::Bullet()
{
}
Bullet::Bullet(Point pos, Dir dir, COLORREF color)
{
my_pos = pos;
my_dir = dir;
my_color = color;
my_step = 12;
my_boolDisappear = false;
CalculateSphere();
}
Bullet::~Bullet()
{
}
void Bullet::Display() // 绘制
{
COLORREF fill_color_save = getfillcolor();//这个函数用于获取当前的填充颜色
COLORREF color_save = getcolor(); //这个函数用于获取当前绘图前景色
my_color = YELLOW;
setfillcolor(my_color);
setcolor(my_color);
fillcircle(my_pos.GetX() , my_pos.GetY() , 4);
setcolor(color_save);
setfillcolor(fill_color_save);
}
void Bullet::Move()// 描述子弹的运动
{
switch (my_dir)
{
case UP:
my_pos.SetY(my_pos.GetY() - my_step);
CalculateSphere();
if (my_pos.GetY() < 20 )
{
my_boolDisappear = true;
}
//障碍物设置
if (120 < my_pos.GetX() && my_pos.GetX() < 300)
{
if (360 < my_pos.GetY() && my_pos.GetY() < 380)
{
my_boolDisappear = true;
}
}
if (280 < my_pos.GetX() && my_pos.GetX() < 440)
{
if (160 < my_pos.GetY() && my_pos.GetY() < 181)
{
my_boolDisappear = true;
}
}
if (440 < my_pos.GetX() && my_pos.GetX() < 460)
{
if (320 < my_pos.GetY() && my_pos.GetY() < 341)
{
my_boolDisappear = true;
}
}
break;
case DOWN:
my_pos.SetY(my_pos.GetY() + my_step);
CalculateSphere();
if (my_pos.GetY() > 520 )
{
my_boolDisappear = true;
}
if (280 < my_pos.GetX() && my_pos.GetX() < 460)
{
if (159 < my_pos.GetY() && my_pos.GetY() < 180)
{
my_boolDisappear = true;
}
}
if (120 < my_pos.GetX() && my_pos.GetX() < 140)
{
if (199 < my_pos.GetY() && my_pos.GetY() < 220)
{
my_boolDisappear = true;
}
}
if (140 < my_pos.GetX() && my_pos.GetX() < 300)
{
if (359 < my_pos.GetY() && my_pos.GetY() < 380)
{
my_boolDisappear = true;
}
}
break;
case LEFT:
my_pos.SetX(my_pos.GetX() - my_step);
CalculateSphere();
if (my_pos.GetX() < 20)
{
my_boolDisappear = true;
}
if (440 < my_pos.GetX() && my_pos.GetX() < 461)
{
if (160 < my_pos.GetY() && my_pos.GetY() < 340)
{
my_boolDisappear = true;
}
}
if (280 < my_pos.GetX() && my_pos.GetX() < 301)
{
if (360 < my_pos.GetY() && my_pos.GetY() < 380)
{
my_boolDisappear = true;
}
}
if (120 < my_pos.GetX() && my_pos.GetX() < 141)
{
if (200 < my_pos.GetY() && my_pos.GetY() < 360)
{
my_boolDisappear = true;
}
}
break;
case RIGHT:
my_pos.SetX(my_pos.GetX() + my_step);
CalculateSphere();
if (my_pos.GetX() > SCREEN_HEIGHT + BATTLEGROUND_LEFT )
{
my_boolDisappear = true;
}
if (119 < my_pos.GetX() && my_pos.GetX() < 140)
{
if (200 < my_pos.GetY() && my_pos.GetY() < 380)
{
my_boolDisappear = true;
}
}
if (279 < my_pos.GetX() && my_pos.GetX() < 300)
{
if (160 < my_pos.GetY() && my_pos.GetY() < 180)
{
my_boolDisappear = true;
}
}
if (439 < my_pos.GetX() && my_pos.GetX() < 460)
{
if (180 < my_pos.GetY() && my_pos.GetY() < 340)
{
my_boolDisappear = true;
}
}
break;
default:
break;
}
}
void Bullet::CalculateSphere()
{
my_rectSphere.Set(my_pos.GetX() - 2, my_pos.GetY() - 2, my_pos.GetX() + 2, my_pos.GetY() + 2);
}
| [
"825308876@qq.com"
] | 825308876@qq.com |
c2fa2d66ee501ad1fad53a946fc60d3612d3213e | e8a3c0b3722cacdb99e15693bff0a4333b7ccf16 | /Code forces/B Weakened Common Divisor.cpp | b286e8e9248a6c6ab34bc23d3bda91978699699b | [] | no_license | piyush1146115/Competitive-Programming | 690f57acd374892791b16a08e14a686a225f73fa | 66c975e0433f30539d826a4c2aa92970570b87bf | refs/heads/master | 2023-08-18T03:04:24.680817 | 2023-08-12T19:15:51 | 2023-08-12T19:15:51 | 211,923,913 | 5 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,672 | cpp | /*
* FILE: B Weakened Common Divisor.cpp
*
* @author: Piyush Kanti Das <piyush123kantidas[at]gmail[dot]com>
*
* LINK:
*
* DATE CREATED: 27.09.2018 21:23:09 +06
*
* DESCRIPTION:
*
* DEVELOPMENT HISTORY:
* Date Version Description
* --------------------------------------------------------------
* 27-09-2018 1.0 File Created
*
*/
/*
// _______________________________________________________________/\\\_________
// ______________________________________________________________\/\\\_________
// ___/\\\\\\\\\___/\\\____/\\\__/\\\____________________________\/\\\_________
// __/\\\/////\\\_\///____\//\\\/\\\___/\\\____/\\\__/\\\\\\\\\\_\/\\\_________
// _\/\\\\\\\\\\___/\\\____\//\\\\\___\/\\\___\/\\\_\/\\\//////__\/\\\\\\\\\\__
// _\/\\\//////___\/\\\_____\//\\\____\/\\\___\/\\\_\/\\\\\\\\\\_\/\\\/////\\\_
// _\/\\\_________\/\\\__/\\_/\\\_____\/\\\___\/\\\_\////////\\\_\/\\\___\/\\\_
// _\/\\\_________\/\\\_\//\\\\/______\//\\\\\\\\\___/\\\\\\\\\\_\/\\\___\/\\\_
// _\///__________\///___\////_________\/////////___\//////////__\///____\///__
//
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double lf;
typedef unsigned long long ull;
typedef pair<long long, long long > pii;
typedef vector<pii> vpii;
typedef vector<int> vi;
typedef vector<long long> vll;
#define __FastIO ios_base::sync_with_stdio(false); cin.tie(0)
#define forr(i, a, b) for (__typeof (a) i=a; i<=b; i++)
#define rof(i, b, a) for (__typeof (a) i=b; i>=a; i--)
#define rep(i, n) for (__typeof (n) i=0; i<n; i++)
#define forit(i, s) for (__typeof ((s).end ()) i = (s).begin (); i != (s).end (); ++i)
#define all(ar) ar.begin(), ar.end()
#define fill(ar) memset(ar, -1, sizeof(ar))
#define clr(a) memset(a, 0, sizeof(a))
#define nl cout << '\n';
#define sp cout << ' ';
#define ckk cout << "##########\n"
#define pb push_back
#define MP make_pair
#define debug1(x) cerr << #x << ": " << x << endl
#define debug2(x, y) cerr << #x << ": " << x << '\t' << #y << ": " << y << endl
#define debug3(x, y, z) cerr << #x << ": " << x << '\t' << #y << ": " << y << '\t' << #z << ": " << z << endl
#define gama 0.57721566490
#define PI acos(-1.0)
#define INF 0x7fffffff
#define MOD 1000000007
#define EPS 1e-7
#define MAX 150005
ll BM( ll a, ll b, ll m ) {
if ( b == 0 ) return 1 ;
ll x = BM(a, b / 2, m);
x = (( x % m) * (x % m)) % m;
if ( b % 2 ) x = (( x % m) * (a % m)) % m ;
return x ;
}
//Auto-format --> ctrl+shift+a
/********************* Code starts here ************************/
pii ara[MAX];
vll prime;
bool chk[MAX];
int main() {
__FastIO; //Be aware to use it!
int n;
cin >> n;
rep(i, n) {
cin >> ara[i].first >> ara[i].second;
}
for (ll i = 2; i <= 100000; i++) {
if (chk[i] == 0) {
prime.pb(i);
for (ll j = i * i ; j <= 100000; j += i) {
chk[j] = 1;
}
}
}
set<ll> s;
for (int i = 0; prime[i]*prime[i] <= ara[0].first; i++) {
if (ara[0].first % prime[i] == 0) {
while (ara[0].first % prime[i] == 0) {
s.insert(prime[i]);
ara[0].first /= prime[i];
}
}
}
if (ara[0].first > 1) {
s.insert(ara[0].first);
}
for (int i = 0; prime[i]*prime[i] <= ara[0].second; i++) {
if (ara[0].second % prime[i] == 0) {
while (ara[0].second % prime[i] == 0) {
s.insert(prime[i]);
ara[0].second /= prime[i];
}
}
}
if (ara[0].second > 1) {
s.insert(ara[0].second);
}
/*
forit(it, s) {
cout << *it << endl;
}
*/
set<ll> temp;
ll ans = ara[0].first;
for (ll j = 1; j < n; j++) {
temp.clear();
ans = -1;
forit(i, s) {
if (ara[j].first % (*i) == 0) {
temp.insert(*i);
ans = *i;
// debug2(j, ara[j].first);
// cout << *i << endl;
}
if (ara[j].second % (*i) == 0) {
temp.insert(*i);
ans = *i;
// debug2(j, ara[j].second);
// cout << *i << endl;
}
}
// debug1(ans);
s.clear();
s = temp;
}
cout << ans << endl;
return 0;
}
| [
"piyush123kantidas@gmail.com"
] | piyush123kantidas@gmail.com |
13773d1a1f7b73fbefd48e82ac4b365182643e20 | 1a3f3e86f807c4da203b580d2aa44ccaf85abc3c | /src/include/TheLite2d/TextureTiles.h | 56f140048998fa44816e8e86f4860186055b73ec | [] | no_license | joan-esteban/TheLite2d | 311b4eed861d5dda903c3088919056625dcc971a | d03ea868d3f32d6c923fa7aed21b0f687b9ec4cb | refs/heads/master | 2021-10-21T08:35:52.377850 | 2019-03-03T18:51:10 | 2019-03-03T18:51:10 | 172,781,399 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,166 | h | #pragma once
#include <map>
#include "Texture.h"
namespace thelite2d {
class TextureTilesExtractor {
public:
std::vector <Texture> extract(const Texture &texture, int columns, int rows) const {
std::vector <Texture> result;
auto tileW = texture.getWidth() / columns;
auto tileH = texture.getHeight() / rows;
for (int j = 0; j < rows; j++)
for (int i = 0; i < columns; i++){
SDL_Rect rect;
rect.x = tileW * i;
rect.y = tileH * j;
rect.w = tileW;
rect.h = tileH;
auto frame = Texture{ *texture.getSdlWrapper(),texture.getSdltexture().lock(), rect };
result.push_back(Texture{ *texture.getSdlWrapper(),texture.getSdltexture().lock(), rect });
}
return result;
}
private:
};
class TextureMultiFileExtractor {
public:
std::vector <Texture> extract(SDLWrapper &sdl, std::string pattern, int firstFrame, int lastFrame, TextureCache *cache ) const {
std::vector <Texture> result;
for (int i = firstFrame; i <= lastFrame; i++) {
char buf[1024];
snprintf(buf, sizeof(buf), pattern.c_str(), i);
result.push_back(Texture{ sdl, buf,cache });
}
return result;
}
};
}
| [
"joanestebanr@gmail.com"
] | joanestebanr@gmail.com |
b3293d283c18da07407409dc1efa2df1470bc9aa | fd221efb1165d56ff7007a3b82aa84b1019883e0 | /Parallel/lab1/main.cpp | 728bb57501c454b872cd83ed89bb448a783e43b5 | [] | no_license | CyanoFresh/KPI-Labs | 822a8057a1db8f4df04e0b71b498f80dc42fd281 | 894332df2cc5a6eb32ce08938f7ebecf21e0dc02 | refs/heads/master | 2023-01-09T06:50:03.303627 | 2021-12-06T18:14:40 | 2021-12-06T18:14:40 | 253,018,181 | 0 | 1 | null | 2023-01-07T05:54:00 | 2020-04-04T14:28:25 | JavaScript | UTF-8 | C++ | false | false | 2,650 | cpp | #include <iostream>
#include <cmath>
#include <chrono>
#include <thread>
#include <vector>
#include <iomanip>
using namespace std;
using namespace std::chrono;
constexpr double a = 0.5;
constexpr double b = 2;
constexpr double h1 = 0.001;
constexpr double h2 = 0.0001;
constexpr double numCores1 = 7;
constexpr double numCores2 = 100;
double f(double x) {
return pow(log(x), 3);
}
double F(double x) {
return x * pow(log(x), 3) - 3 * x * pow(log(x), 2) + 6 * x * log(x) - 6 * x;
}
double calcIntegral(double h) {
double result = 0;
double n = (b - a) / h;
for (int i = 0; i < n; i++) {
result += f(a + h * (i + 0.5));
}
result *= h;
return result;
}
void threadF(int start, int end, double h, double &result) {
result = 0;
for (int i = start; i < end; i++) {
result += f(a + h * (i + 0.5));
}
result *= h;
}
void runMetrics(double h, int numCores) {
cout << "Running with h = " << h << ", numCores = " << numCores << endl;
double n = (b - a) / h;
double jobPerCore = n / numCores;
auto start = high_resolution_clock::now();
double serialResult = calcIntegral(h);
auto stop = high_resolution_clock::now();
auto serialDuration = duration_cast<nanoseconds>(stop - start);
start = high_resolution_clock::now();
double parallelResult = 0;
double threadResults[numCores];
vector<thread> threadList;
for (int i = 0; i < numCores; i++) {
double begin = i * jobPerCore;
double end = begin + jobPerCore;
threadList.emplace_back(
threadF,
begin,
end,
h,
ref(threadResults[i])
);
}
for (int i = 0; i < numCores; i++) {
threadList[i].join();
parallelResult += threadResults[i];
}
stop = high_resolution_clock::now();
auto parallelDuration = duration_cast<microseconds>(stop - start);
cout << "Serial result: " << std::fixed << std::setprecision(7) << serialResult << " (" << serialDuration.count()
<< " ns)" << endl;
cout << "Parallel result: " << std::fixed << std::setprecision(7) << parallelResult << " ("
<< parallelDuration.count() << " ns)" << endl;
double speedup = (double) serialDuration.count() / parallelDuration.count();
cout << "Speedup factor: " << speedup << endl;
cout << "Efficiency ratio: " << speedup / numCores << endl << endl;
}
int main() {
double referenceResult = F(b) - F(a);
cout << "Reference F result: " << referenceResult << endl << endl;
runMetrics(h1, numCores1);
runMetrics(h2, numCores2);
}
| [
"cyanofresh@gmail.com"
] | cyanofresh@gmail.com |
84ee7489497e973f44e17e59efcc61ffb328586c | 4089ba635150e5f85119c08707cbcb27483ecb2c | /src/User.cpp | de8db38a28ff11bd48bad4be3854fd7ef384a2c6 | [] | no_license | SWDesgn/HighwayPilot | a7788c53bdd9430833d5434ce95a7faf02962632 | b266395f2fc44785abb6f50cbeaf72dea4c30b1f | refs/heads/main | 2023-06-30T13:13:09.579578 | 2021-08-07T10:36:37 | 2021-08-07T10:36:37 | 393,652,579 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,836 | cpp | /*
******************************************************************************
** CarMaker - Version 9.1.1
** Vehicle Dynamics Simulation Toolkit
**
** Copyright (C) IPG Automotive GmbH
** Bannwaldallee 60 Phone +49.721.98520.0
** 76185 Karlsruhe Fax +49.721.98520.99
** Germany WWW www.ipg-automotive.com
******************************************************************************
**
** Functions
** ---------
**
** Initialization
**
** User_Init_First ()
** User_PrintUsage ()
** User_ScanCmdLine ()D
** User_Init ()
** User_Register ()
** User_DeclQuants ()
**
** User_Param_Add ()
** User_Param_Get ()
**
**
** Main TestRun Start/End:
**
** User_TestRun_Start_atBegin ()
** User_TestRun_Start_atEnd ()
** User_TestRun_Start_StaticCond_Calc ()
** User_TestRun_Start_Finalize ()
** User_TestRun_RampUp ()
**
** User_TestRun_End_First ()
** User_TestRun_End ()
**
**
** Main Cycle:
**
** User_In ()
**
** User_DrivMan_Calc ()
** User_Traffic_Calc ()
** User_VehicleControl_Calc ()
** User_Brake_Calc () in Vhcl_Calc ()
** User_Calc ()
** User_Check_IsIdle ()
**
** User_Out ()
**
**
** APO Communication:
**
** User_ApoMsg_Eval ()
** User_ApoMsg_Send ()
**
** User_ShutDown ()
** User_End ()
** User_Cleanup ()
**
**
******************************************************************************
*/
#include <Global.h>
#if defined(WIN32)
# include <windows.h>
#endif
#include <stdlib.h>
#include <string.h>
#include <math.h>
#if defined(XENO)
# include <mio.h>
#endif
#include <CarMaker.h>
#include <Car/Vehicle_Car.h>
#include <ADASRP.h>
#include <rbs.h>
#include "IOVec.h"
#include "User.h"
#include "Highway_Pilot.h"
#include <Vehicle/Sensor_Road.h>
#include <Vehicle/Sensor_Object.h>
#include <Vehicle/Sensor_TSign.h>
#include <Vehicle/Sensor_ObjectByLane.h>
#include "EHorizon.h"
/* @@PLUGIN-BEGIN-INCLUDE@@ - Automatically generated code - don't edit! */
/* @@PLUGIN-END@@ */
Highway_Pilot highwayPilot;
int UserCalcCalledByAppTestRunCalc = 0;
tUser User;
tEHorizon* myEHorizon = NULL;
/*
** User_Init_First ()
**
** First, low level initialization of the User module
**
** Call:
** - one times at start of program
** - no realtime conditions
**
*/
int
User_Init_First(void)
{
memset(&User, 0, sizeof(User));
return 0;
}
/*
** User_PrintUsage ()
**
** Print the user/application specific programm arguments
*/
void
User_PrintUsage(const char* Pgm)
{
/* REMARK: 1 log statement for each usage line, no line breaks */
LogUsage("\n");
LogUsage("Usage: %s [options] [testrun]\n", Pgm);
LogUsage("Options:\n");
#if defined(CM_HIL)
{
const tIOConfig* cf;
const char* defio = IO_GetDefault();
LogUsage(" -io %-12s Default I/O configuration (%s)\n", "default",
(defio != NULL && strcmp(defio, "none") != 0) ? defio : "minimal I/O");
for (cf = IO_GetConfigurations(); cf->Name != NULL; cf++)
LogUsage(" -io %-12s %s\n", cf->Name, cf->Description);
}
#endif
}
/*
** User_ScanCmdLine ()
**
** Scan application specific command line arguments
**
** Return:
** - argv: last unscanned argument
** - NULL: error or unknown argument
*/
char**
User_ScanCmdLine(int argc, char** argv)
{
const char* Pgm = argv[0];
/* I/O configuration to be used in case no configuration was
specified on the command line. */
IO_SelectDefault("default" /* or "demoapp", "demorbs,demofr" etc. */);
while (*++argv) {
if (strcmp(*argv, "-io") == 0 && argv[1] != NULL) {
if (IO_Select(*++argv) != 0)
return NULL;
}
else if (strcmp(*argv, "-h") == 0 || strcmp(*argv, "-help") == 0) {
User_PrintUsage(Pgm);
SimCore_PrintUsage(Pgm); /* Possible exit(), depending on CM-platform! */
return NULL;
}
else if ((*argv)[0] == '-') {
LogErrF(EC_General, "Unknown option '%s'", *argv);
return NULL;
}
else {
break;
}
}
return argv;
}
/*
** User_Init ()
**
** Basic initialization of the module User.o
**
** Call:
** - once at program start
** - no realtime conditions
*/
int
User_Init(void)
{
highwayPilot.init();
return 0;
}
int
User_Register(void)
{
/* @@PLUGIN-BEGIN-REGISTER@@ - Automatically generated code - don't edit! */
/* @@PLUGIN-END@@ */
return 0;
}
/*
** User_DeclQuants ()
**
** Add user specific quantities to the dictionary
**
** Call:
** - once at program start
** - no realtime conditions
*/
void
User_DeclQuants(void)
{
int i;
for (i = 0; i < N_USEROUTPUT; i++) {
char sbuf[32];
sprintf(sbuf, "UserOut_%02d", i);
DDefDouble(NULL, sbuf, "", &User.Out[i], DVA_IO_Out);
}
#if !defined(LABCAR)
RBS_DeclQuants();
#endif
DDefInt(NULL, "cycleCounter", "", highwayPilot.getCycleCounterPtr(), DVA_None);
DDefInt(NULL, "laneChangeRequest", "", highwayPilot.getLaneChangeReqPtr(), DVA_VC);
}
/*
** User_Param_Add ()
**
** Update all modified application specific parameters in the test stand
** parameter file (ECUParameters).
**
** If the variable SimCore.TestRig.ECUParam.Modified set to 1 somewhere else
** CarMaker calls this function to let the user add or change all necessary
** entries before the file is written.
** So, if writing the ECUParam file is necessary, set ECUParam.Modified to 1.
** The next TestRun start or end, CarMaker calls this function and writes
** the file to the harddisk.
**
** Call:
** - in a separate thread (no realtime contitions)
** - when starting a new test run
*/
int
User_Param_Add(void)
{
#if defined(CM_HIL)
/* ECU parameters */
if (SimCore.TestRig.ECUParam.Inf == NULL)
return -1;
#endif
return 0;
}
/*
** User_Param_Get ()
**
** Update all modified application specific parameters from the test stand
** parameter file (ECUParameters).
**
** Call:
** - in a separate thread (no realtime conditions)
** - if User_Param_Get() wasn't called
** - when starting a new test run, if
** - the files SimParameters and/or
** - ECUParameters
** are modified since last reading
**
** return values:
** 0 ok
** -1 no testrig parameter file
** -2 testrig parameter error
** -3 i/o configuration specific error
** -4 no simulation parameters
** -5 simulation parameters error
** -6 FailSafeTester parameter/init error
*/
int
User_Param_Get(void)
{
int rv = 0;
#if defined(CM_HIL)
/*** testrig / ECU parameters */
if (SimCore.TestRig.ECUParam.Inf == NULL)
return -1;
if (IO_Param_Get(SimCore.TestRig.ECUParam.Inf) != 0)
rv = -2;
#endif
/*** simulation parameters */
if (SimCore.TestRig.SimParam.Inf == NULL)
return -4;
return rv;
}
/*
** User_TestRun_Start_atBegin ()
**
** Special things before a new simulation starts like
** - reset user variables to their default values
** - reset counters
** - ...
**
** Call:
** - in separate thread (no realtime conditions)
** - when starting a new test run
** - after (standard) infofiles are read in
** - before reading parameters for Environment, DrivMan, Car, ...
** the models are NOT in the simulation-can-start-now state
** (after Start(), before StaticCond())
*/
int
User_TestRun_Start_atBegin(void)
{
int rv = 0;
int i;
for (i = 0; i < N_USEROUTPUT; i++)
User.Out[i] = 0.0;
if (IO_None)
return rv;
#if defined(CM_HIL)
if (FST_New(SimCore.TestRig.ECUParam.Inf) != 0)
rv = -6;
#endif
return rv;
}
/*
** User_TestRun_Start_atEnd ()
**
** Special things before a new simulation starts like
** - reset user variables to there default values
** - reset counters
** - ...
**
** Call:
** - in separate thread (no realtime conditions)
** - when starting a new test run
** - at the end, behind reading parameters for Environment, DrivMan,
** Car, ...
** the models are NOT in the simulation-can-start-now state
** (after Start(), before StaticCond())
*/
int
User_TestRun_Start_atEnd(void)
{
highwayPilot.init();
tEHorizonCfgIF CfgIF;
CfgIF.Type = EHorizonType_RoutePath;
CfgIF.rObjId = Env.Route.ObjId;
CfgIF.ehMask = EHOT_MIN | EHOT_SPEEDLIM;
CfgIF.nREmax = 5;
CfgIF.ds = 10;
CfgIF.maxrange = 300;
myEHorizon = EHorizon_New(&CfgIF, "MyEHorizon");
return 0;
}
/*
** User_TestRun_Start_StaticCond_Calc ()
**
** called in non RT context
*/
int
User_TestRun_Start_StaticCond_Calc(void)
{
return 0;
}
/*
** User_TestRun_Start_Finalize ()
**
** called in RT context
*/
int
User_TestRun_Start_Finalize(void)
{
return 0;
}
/*
** User_TestRun_RampUp ()
**
** Perform a smooth transition of variables (e.g. I/O)
** from their current state to the new testrun.
** This function is called repeatedly, once during each cycle, until
** it returns true (or issues an error message), so the function should
** return true if transitioning is done, false otherwise.
**
** In case of an error the function should issue an apropriate
** error message and return false;
**
** Called in RT context, in state SCState_StartSim,
** after preprocessing is done, before starting the engine.
** Please note, that in this early initialization state no calculation
** of the vehicle model takes place.
*/
int
User_TestRun_RampUp(double dt)
{
int IsReady = 1;
return IsReady;
}
/*
** User_TestRun_End_First ()
**
** Invoked immediately after the end of a simulation is initiated,
** but before data storage ends and before transitioning into SCState_Idle.
** - Send Scratchpad-note
** - ...
**
** Call:
** - in main task, in the main loop (real-time conditions!)
** - when a test run is finished (SimCore.State is SCState_End)
*/
int
User_TestRun_End_First(void)
{
return 0;
}
/*
** User_TestRun_End ()
**
** Special things after the end of a simulation like
** - switch off an air compressor
** - Write something to a file
** - ...
**
** Call:
** - in separate thread (no realtime conditions)
** - when a test run is finished (SimCore.State is SCState_End<xyz>)
*/
int
User_TestRun_End(void)
{
EHorizon_Delete(myEHorizon);
myEHorizon = NULL;
return 0;
}
/*
** User_In ()
**
** Assign quantities of the i/o vector to model variables
**
** Call:
** - in the main loop
** - pay attention to realtime condition
** - just after IO_In()
*/
void
User_In(const unsigned CycleNo)
{
if (SimCore.State != SCState_Simulate)
return;
tEHorizonIF IF;
IF.PreviewDist = 300;
IF.s = Car.sRoad;
IF.nDynPath = 0;
IF.nSL = 0;
highwayPilot.setInput().reset();
EHorizon_Eval(myEHorizon, &IF);
if (IF.nSL > 0) {
highwayPilot.setInput().setSpeedLimit(IF.SpeedLimit[IF.nSL - 1].val);
}
}
/*
** User_DrivMan_Calc ()
**
** called
** - in RT context
** - after DrivMan_Calc()
*/
int
User_DrivMan_Calc(double dt)
{
/* Rely on the Vehicle Operator within DrivMan module to get
the vehicle in driving state using the IPG's
PowerTrain Control model 'Generic' or similar */
if (Vehicle.OperationState != OperState_Driving) {
return 0;
}
return 0;
}
/*
** User_VehicleControl_Calc ()
**
** called
** - in RT context
** - after VehicleControl_Calc()
*/
int
User_VehicleControl_Calc(double dt)
{
/* Rely on the Vehicle Operator within DrivMan module to get
the vehicle in driving state using the IPG's
PowerTrain Control model 'Generic' or similar */
if (Vehicle.OperationState != OperState_Driving)
return 0;
/********HIGHWAY*PILOT*********/
highwayPilot.setInput().setEgoVel(Vehicle.v);
highwayPilot.setInput().setEgoAcc(Vehicle.PoI_Acc_1[0], Vehicle.PoI_Acc_1[1]);
if (RoadSensor != nullptr) {
highwayPilot.setInput().setRoadCurvature(RoadSensor->
Route.CurveXY);
highwayPilot.setInput().egoLane.exists = true;
highwayPilot.setInput().egoLane.dev_dist = RoadSensor->Path.Deviation.Dist;
highwayPilot.setInput().egoLane.dev_angl = RoadSensor->Path.Deviation.Ang;
if (RoadSensor->Lanes.nLanesL > 0) {
highwayPilot.setInput().leftLane.dev_dist = RoadSensor->Lanes.left[0].tMidLane + RoadSensor->Lanes.left[0].width / 2 + 0.6;
highwayPilot.setInput().leftLane.dev_angl = RoadSensor->Path.Deviation.Ang;
}
if (RoadSensor->Lanes.nLanesR > 0) {
highwayPilot.setInput().rightLane.dev_dist = RoadSensor->Lanes.right[0].tMidLane - RoadSensor->Lanes.right[0].width / 2 - 0.6;
highwayPilot.setInput().rightLane.dev_angl = RoadSensor->Path.Deviation.Ang;
}
}
if (ObjByLane != nullptr && ObjByLane[0].nLanes > 0) {
const auto objByLanesCenter = ObjByLane[0].Lane[OBL_LaneScope::LS_Center];
if (objByLanesCenter[0].nObjF > 0) {
const auto obj = objByLanesCenter[0].ObjFront[0];
highwayPilot.setInput().relObj.id = obj.ObjID;
highwayPilot.setInput().relObj.rel_dist[0] = obj.sMin;
highwayPilot.setInput().relObj.abs_vel = obj.VelLong;
highwayPilot.setInput().relObj.rel_vel = obj.VelLong - highwayPilot.getInput().veh_vel_abs;
}
const auto objByLanesLeft = ObjByLane[0].Lane[OBL_LaneScope::LS_Left];
highwayPilot.setInput().leftLane.exists = objByLanesLeft->DrvOn;
if (objByLanesLeft[0].nObjF > 0) {
const auto obj = objByLanesLeft[0].ObjFront[0];
highwayPilot.setInput().leftRelObj.id = obj.ObjID;
highwayPilot.setInput().leftRelObj.rel_dist[0] = obj.sMin;
highwayPilot.setInput().leftRelObj.abs_vel = obj.VelLong;
highwayPilot.setInput().leftRelObj.rel_vel = obj.VelLong - highwayPilot.getInput().veh_vel_abs;
}
const auto objByLanesRight = ObjByLane[0].Lane[OBL_LaneScope::LS_Right];
highwayPilot.setInput().rightLane.exists = objByLanesRight->DrvOn;
if (objByLanesRight[0].nObjF > 0) {
const auto obj = objByLanesRight[0].ObjFront[0];
highwayPilot.setInput().rightRelObj.id = obj.ObjID;
highwayPilot.setInput().rightRelObj.rel_dist[0] = obj.sMin;
highwayPilot.setInput().rightRelObj.abs_vel = obj.VelLong;
highwayPilot.setInput().rightRelObj.rel_vel = obj.VelLong - highwayPilot.getInput().veh_vel_abs;
}
}
highwayPilot.run();
VehicleControl.Gas = highwayPilot.getOutput().out_gas;
VehicleControl.Brake = highwayPilot.getOutput().out_brake;
VehicleControl.Steering.Ang = highwayPilot.getOutput().out_steering;
highwayPilot.setInput().print();
highwayPilot.setOutput().print();
for (int i = 0; i < 10; i++) {
User.Out[i] = highwayPilot.getOutput().debugOut.out[i];
}
return 0;
}
/*
** User_Brake_Calc ()
**
** called
** - in RT context
** - after Brake_Calc() in Vhcl_Calc()
*/
int
User_Brake_Calc(double dt)
{
/* Modify the total brake torque from the brake system model Brake.Trq_tot[]
or the target drive source torque from the brake control unit
Brake.HydBrakeCU_IF.Trq_DriveSrc_trg[]
*/
return 0;
}
/*
** User_Traffic_Calc ()
**
** called
** - in RT context
** - after Traffic_Calc()
*/
int
User_Traffic_Calc(double dt)
{
if (SimCore.State != SCState_Simulate)
return 0;
return 0;
}
/*
** User_Calc ()
**
** called in RT context
*/
int
User_Calc(double dt)
{
/* Starting with CM 6.0 User_Calc() will be invoked in EVERY simulation
state. Uncomment the following line in order to restore the behaviour
of CM 5.1 and earlier. */
/*if (!UserCalcCalledByAppTestRunCalc) return 0;*/
if (SimCore.State == SCState_Simulate) {
highwayPilot.run();
}
return 0;
}
/*
** User_Check_IsIdle ()
**
** Checking, if the simulation model is in idle conditions (stand still,
** steeringwheel angle zero, cluch pedal pressed, ...).
** If reached idle state, the calculation of vehicle model and driving
** manoevers is stopped.
** Ready for start new simulation.
**
** Return:
** 1 idle state reached
** 0 else
**
** Call:
** - in main task, in the main loop
** - pay attention to realtime condition
** - while SimCore.State==SCState_EndIdleGet
*/
int
User_Check_IsIdle(int IsIdle)
{
double val;
/*** ECU / carmodel signals */
/* vehicle and wheels: stand still */
val = 0.5 * kmh2ms;
if (Vehicle.v > val
|| fabs(Vehicle.Wheel[0]->vBelt) > val || fabs(Vehicle.Wheel[1]->vBelt) > val
|| fabs(Vehicle.Wheel[2]->vBelt) > val || fabs(Vehicle.Wheel[3]->vBelt) > val) {
IsIdle = 0;
}
/* SteerAngle: drive straight forward position */
val = 1.0 * deg2rad;
if (Vehicle.Steering.Ang > val || Vehicle.Steering.Ang < -val)
IsIdle = 0;
return IsIdle;
}
/*
** User_Out ()
**
** Assigns model quantities to variables of the i/o vector
**
** call:
** - in the main loop
** - pay attention to realtime condition
** - just before IO_Out();
*/
void
User_Out(const unsigned CycleNo)
{
#if !defined(LABCAR)
RBS_OutMap(CycleNo);
#endif
if (SimCore.State != SCState_Simulate)
return;
}
/*
** User_ApoMsg_Eval ()
**
** Communication between the application and connected GUIs.
** Evaluate messages from GUIs
**
** Call:
** - in the main loop
** - pay attention to realtime condition
** - near the end of the main loop, if the function SimCore_ApoMsg_Eval()
** skips the message
**
** Return:
** 0 : message evaluated
** -1 : message not handled
*/
int
User_ApoMsg_Eval(int Ch, char* Msg, int len, int who)
{
#if defined(CM_HIL)
/*** FailSafeTester */
if (Ch == ApoCh_CarMaker) {
if (FST_ApoMsgEval(Ch, Msg, len) <= 0)
return 0;
}
#endif
return -1;
}
/*
** User_ApoMsg_Send ()
**
** Communication between the application and connected GUIs.
** Sends messages to GUIs
**
** Call:
** - near the end of the main loop, in MainThread_FinishCycle()
** - pay attention to realtime condition
*/
void
User_ApoMsg_Send(double T, const unsigned CycleNo)
{
}
/*
** User_ShutDown ()
**
** Prepare application for shut down
**
** Call:
** - at end of program
** - no realtime conditions
*/
int
User_ShutDown(int ShutDownForced)
{
int IsDown = 0;
/* Prepare application for shutdown and return that
shutdown conditions are reached */
if (1) {
IsDown = 1;
}
return IsDown;
}
/*
** User_End ()
**
** End all models of the user module
**
** Call:
** - one times at end of program
** - no realtime conditions
*/
int
User_End(void)
{
return 0;
}
/*
** User_Cleanup ()
**
** Cleanup function of the User module
**
** Call:
** - one times at end of program, just before exit
** - no realtime conditions
*/
void
User_Cleanup(void)
{
}
| [
"altergott.oliver@gmail.com"
] | altergott.oliver@gmail.com |
3aa8997fcd470c0c0860586190a1e70e7ce278c9 | 988974528c03583f38833cb811fb539804302c4d | /priorityQueue.cpp | 8f23280a3f1da5d4907390cd91086e6c83eab316 | [] | no_license | mariaconcettavitale/Huffman-Coding | 262ca9bd0b483ebe3d6d98a0df72c20b3e7d7060 | 8cb90a9525ccd58fd52a417da8768a02e2ef206d | refs/heads/master | 2022-12-01T14:03:31.178312 | 2020-08-18T09:30:24 | 2020-08-18T09:30:24 | null | 0 | 0 | null | null | null | null | IBM852 | C++ | false | false | 3,866 | cpp | #include "priorityQueue.h"
priorityQueue::priorityQueue() /**costruttore di default della classe priority queue**/
{
treeQueue=new treeBst(); /**alloco memoria per l'alberoBsT**/
}
void priorityQueue::insertPriorityQueueBst(nodeBst *insertNode) /**metodo che inserisce i nodi nella coda**/
{
insertPriorityQueuePrivate(insertNode);
}
void priorityQueue::insertPriorityQueuePrivate(nodeBst *insertNode)
{
treeQueue->insertNodeBst(treeQueue->getRoot(),insertNode); /**richiamo del metodo dell'albero di ricerca per inserire il nodo**/
}
void priorityQueue::printQueue() /**metodo pubblico per stampare la coda di prioritÓ**/
{
treeQueue->visit(treeQueue->getRoot()); /**richiamo del metodo per la stampa dell'albero di ricerca**/
}
nodeBst *priorityQueue::extractMinQueue() /**metodo pubblico che richiama il metodo privato per l'operazione di estrazione del minimo**/
{
return extractMinTree(); /**richiamo del metodo privato per l'estrazione dell'albero**/
}
void priorityQueue::increaseKey(unsigned char element) /**tale metodo servirÓ per incrementare il valore della frequenza nel caso
in cui si rilevino elementi uguali, altrimenti creiamo e inseriamo semplicemente quell'elemento all'interno della priorityQueue**/
{
increaseKeyPrivate(element); /**richiamo del metodo increaseKey per˛ privato**/
}
nodeBst *priorityQueue::extractMinTree() /**metodo privato che richiama il metodo dell'albero per l'estrazione**/
{
return treeQueue->extractMin();
}
/**Nel metodo sottostante non facciamo altro che prendere un elemento da input e cercare all'interno dell'albero
quell'elemento, se tale elemento Ŕ presente allora salviamo la sua frequenza, lo eliminiamo e ricreamo il nodo
con la frequenza aggiornata, se invece esso Ŕ null quindi non Ŕ stato trovato, semplicemente lo inseriamo nella coda**/
void priorityQueue::increaseKeyPrivate(unsigned char element)
{
int frequency=1;
nodeBst *searchElement=NULL;
searchElement=treeQueue->searchBst(element);
if(treeQueue->getRoot()!=NULL)
{
if(searchElement!=NULL)
{
frequency=searchElement->getFrequency(); /**salviamo la frequenza dell'elemento trovato**/
treeQueue->elimNodeBst(searchElement); /**lo eliminiamo mediante il emtodo elimNodeBst dell'albero di ricerca**/
searchElement=new nodeBst(element,1); /**creiamo un nodo inizializzandolo ai valori indicati**/
frequency=frequency+1; /**aumentiamo la frequenza di uno**/
searchElement->setFrequency(frequency); /**impostiamo la frequenza**/
insertPriorityQueueBst(searchElement); /**inseriamo il nodo creato**/
}
else /**se quindi non Ŕ stato trovato**/
{
searchElement=new nodeBst(element,1); /**creiamo il nodo mediante costruttore**/
insertPriorityQueueBst(searchElement); /**e lo inseriamo**/
}
}
else /**se invece la radice Ŕ null dell'albero**/
{
searchElement=new nodeBst(element,1); /**allora inseriamo semplicemente il nodo**/
insertPriorityQueueBst(searchElement);
}
}
/**il metodo sottostante non fa altro che calcolare il size della coda, quindi ci rifacciamo al size dell'albero **/
int priorityQueue::sizeQueue()
{
int somma=sizeTree(); /**richiamo del metodo per il calcolo del size dell'albero privato**/
return somma;
}
int priorityQueue::sizeTree()
{
int sommaTree=0;
sommaTree=treeQueue->sizeTreeBst(treeQueue->getRoot()); /**richiamo del metodo sizeTreeBst dll'oggetto treeQueue che ha
come input la radice dell'albero**/
return sommaTree;
}
| [
"cvitale819@gmail.com"
] | cvitale819@gmail.com |
975fcf100238080b37678851a688aacb60a036c2 | 8380b5eb12e24692e97480bfa8939a199d067bce | /Carberp Botnet/source - absource/pro/all source/BJWJ/include/plugin/nsIPluginTagInfo2.h | d541fb68daa9ebf77aebe611446cdde20fa1be65 | [
"LicenseRef-scancode-warranty-disclaimer"
] | no_license | RamadhanAmizudin/malware | 788ee745b5bb23b980005c2af08f6cb8763981c2 | 62d0035db6bc9aa279b7c60250d439825ae65e41 | refs/heads/master | 2023-02-05T13:37:18.909646 | 2023-01-26T08:43:18 | 2023-01-26T08:43:18 | 53,407,812 | 873 | 291 | null | 2023-01-26T08:43:19 | 2016-03-08T11:44:21 | C++ | UTF-8 | C++ | false | false | 11,967 | h | /*
* DO NOT EDIT. THIS FILE IS GENERATED FROM e:/builds/moz2_slave/mozilla-1.9.1-win32-xulrunner/build/modules/plugin/base/public/nsIPluginTagInfo2.idl
*/
#ifndef __gen_nsIPluginTagInfo2_h__
#define __gen_nsIPluginTagInfo2_h__
#ifndef __gen_nsIPluginTagInfo_h__
#include "nsIPluginTagInfo.h"
#endif
/* For IDL files that don't want to include root IDL files. */
#ifndef NS_NO_VTABLE
#define NS_NO_VTABLE
#endif
enum nsPluginTagType {
nsPluginTagType_Unknown,
nsPluginTagType_Embed,
nsPluginTagType_Object,
nsPluginTagType_Applet
};
/* starting interface: nsIPluginTagInfo2 */
#define NS_IPLUGINTAGINFO2_IID_STR "6a49c9a0-019b-11d2-815b-006008119d7a"
#define NS_IPLUGINTAGINFO2_IID \
{0x6a49c9a0, 0x019b, 0x11d2, \
{ 0x81, 0x5b, 0x00, 0x60, 0x08, 0x11, 0x9d, 0x7a }}
class NS_NO_VTABLE nsIPluginTagInfo2 : public nsIPluginTagInfo {
public:
NS_DECLARE_STATIC_IID_ACCESSOR(NS_IPLUGINTAGINFO2_IID)
/**
* Get the type of the HTML tag that was used ot instantiate this
* plugin. Currently supported tags are EMBED, OBJECT and APPLET.
*/
/* readonly attribute nsPluginTagType tagType; */
NS_IMETHOD GetTagType(nsPluginTagType *aTagType) = 0;
/**
* Get the complete text of the HTML tag that was used to instantiate this plugin.
*/
/* void getTagText (out constCharPtr aTagText); */
NS_IMETHOD GetTagText(const char * *aTagText NS_OUTPARAM) = 0;
/**
* Get a ptr to the paired list of parameter names and values,
* returns the length of the array.
*
* Each name or value is a null-terminated string.
*/
/* void getParameters (in PRUint16Ref aCount, in constCharStarConstStar aNames, in constCharStarConstStar aValues); */
NS_IMETHOD GetParameters(PRUint16 & aCount, const char* const* & aNames, const char* const* & aValues) = 0;
/**
* Get the value for the named parameter. Returns null
* if the parameter was not set.
*
* @param aName - name of the parameter
* @param aResult - parameter value
* @result - NS_OK if this operation was successful
*/
/* void getParameter (in string aName, out constCharPtr aResult); */
NS_IMETHOD GetParameter(const char *aName, const char * *aResult NS_OUTPARAM) = 0;
/**
* Get the document base
*/
/* void getDocumentBase (out constCharPtr aDocumentBase); */
NS_IMETHOD GetDocumentBase(const char * *aDocumentBase NS_OUTPARAM) = 0;
/**
* Return an encoding whose name is specified in:
* http://java.sun.com/products/jdk/1.1/docs/guide/intl/intl.doc.html#25303
*/
/* void getDocumentEncoding (out constCharPtr aDocumentEncoding); */
NS_IMETHOD GetDocumentEncoding(const char * *aDocumentEncoding NS_OUTPARAM) = 0;
/**
* Get object alignment
*/
/* void getAlignment (out constCharPtr aElignment); */
NS_IMETHOD GetAlignment(const char * *aElignment NS_OUTPARAM) = 0;
/**
* Get object width
*/
/* readonly attribute unsigned long width; */
NS_IMETHOD GetWidth(PRUint32 *aWidth) = 0;
/**
* Get object height
*/
/* readonly attribute unsigned long height; */
NS_IMETHOD GetHeight(PRUint32 *aHeight) = 0;
/**
* Get border vertical space
*/
/* readonly attribute unsigned long borderVertSpace; */
NS_IMETHOD GetBorderVertSpace(PRUint32 *aBorderVertSpace) = 0;
/**
* Get border horizontal space
*/
/* readonly attribute unsigned long borderHorizSpace; */
NS_IMETHOD GetBorderHorizSpace(PRUint32 *aBorderHorizSpace) = 0;
/**
* Returns a unique id for the current document containing plugin
*/
/* readonly attribute unsigned long uniqueID; */
NS_IMETHOD GetUniqueID(PRUint32 *aUniqueID) = 0;
/**
* Returns the DOM element corresponding to the tag which references
* this plugin in the document.
*
* @param aDOMElement - resulting DOM element
* @result - NS_OK if this operation was successful
*/
/* readonly attribute nsIDOMElement DOMElement; */
NS_IMETHOD GetDOMElement(nsIDOMElement * *aDOMElement) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIPluginTagInfo2, NS_IPLUGINTAGINFO2_IID)
/* Use this macro when declaring classes that implement this interface. */
#define NS_DECL_NSIPLUGINTAGINFO2 \
NS_IMETHOD GetTagType(nsPluginTagType *aTagType); \
NS_IMETHOD GetTagText(const char * *aTagText NS_OUTPARAM); \
NS_IMETHOD GetParameters(PRUint16 & aCount, const char* const* & aNames, const char* const* & aValues); \
NS_IMETHOD GetParameter(const char *aName, const char * *aResult NS_OUTPARAM); \
NS_IMETHOD GetDocumentBase(const char * *aDocumentBase NS_OUTPARAM); \
NS_IMETHOD GetDocumentEncoding(const char * *aDocumentEncoding NS_OUTPARAM); \
NS_IMETHOD GetAlignment(const char * *aElignment NS_OUTPARAM); \
NS_IMETHOD GetWidth(PRUint32 *aWidth); \
NS_IMETHOD GetHeight(PRUint32 *aHeight); \
NS_IMETHOD GetBorderVertSpace(PRUint32 *aBorderVertSpace); \
NS_IMETHOD GetBorderHorizSpace(PRUint32 *aBorderHorizSpace); \
NS_IMETHOD GetUniqueID(PRUint32 *aUniqueID); \
NS_IMETHOD GetDOMElement(nsIDOMElement * *aDOMElement);
/* Use this macro to declare functions that forward the behavior of this interface to another object. */
#define NS_FORWARD_NSIPLUGINTAGINFO2(_to) \
NS_IMETHOD GetTagType(nsPluginTagType *aTagType) { return _to GetTagType(aTagType); } \
NS_IMETHOD GetTagText(const char * *aTagText NS_OUTPARAM) { return _to GetTagText(aTagText); } \
NS_IMETHOD GetParameters(PRUint16 & aCount, const char* const* & aNames, const char* const* & aValues) { return _to GetParameters(aCount, aNames, aValues); } \
NS_IMETHOD GetParameter(const char *aName, const char * *aResult NS_OUTPARAM) { return _to GetParameter(aName, aResult); } \
NS_IMETHOD GetDocumentBase(const char * *aDocumentBase NS_OUTPARAM) { return _to GetDocumentBase(aDocumentBase); } \
NS_IMETHOD GetDocumentEncoding(const char * *aDocumentEncoding NS_OUTPARAM) { return _to GetDocumentEncoding(aDocumentEncoding); } \
NS_IMETHOD GetAlignment(const char * *aElignment NS_OUTPARAM) { return _to GetAlignment(aElignment); } \
NS_IMETHOD GetWidth(PRUint32 *aWidth) { return _to GetWidth(aWidth); } \
NS_IMETHOD GetHeight(PRUint32 *aHeight) { return _to GetHeight(aHeight); } \
NS_IMETHOD GetBorderVertSpace(PRUint32 *aBorderVertSpace) { return _to GetBorderVertSpace(aBorderVertSpace); } \
NS_IMETHOD GetBorderHorizSpace(PRUint32 *aBorderHorizSpace) { return _to GetBorderHorizSpace(aBorderHorizSpace); } \
NS_IMETHOD GetUniqueID(PRUint32 *aUniqueID) { return _to GetUniqueID(aUniqueID); } \
NS_IMETHOD GetDOMElement(nsIDOMElement * *aDOMElement) { return _to GetDOMElement(aDOMElement); }
/* Use this macro to declare functions that forward the behavior of this interface to another object in a safe way. */
#define NS_FORWARD_SAFE_NSIPLUGINTAGINFO2(_to) \
NS_IMETHOD GetTagType(nsPluginTagType *aTagType) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTagType(aTagType); } \
NS_IMETHOD GetTagText(const char * *aTagText NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetTagText(aTagText); } \
NS_IMETHOD GetParameters(PRUint16 & aCount, const char* const* & aNames, const char* const* & aValues) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetParameters(aCount, aNames, aValues); } \
NS_IMETHOD GetParameter(const char *aName, const char * *aResult NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetParameter(aName, aResult); } \
NS_IMETHOD GetDocumentBase(const char * *aDocumentBase NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDocumentBase(aDocumentBase); } \
NS_IMETHOD GetDocumentEncoding(const char * *aDocumentEncoding NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDocumentEncoding(aDocumentEncoding); } \
NS_IMETHOD GetAlignment(const char * *aElignment NS_OUTPARAM) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetAlignment(aElignment); } \
NS_IMETHOD GetWidth(PRUint32 *aWidth) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetWidth(aWidth); } \
NS_IMETHOD GetHeight(PRUint32 *aHeight) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetHeight(aHeight); } \
NS_IMETHOD GetBorderVertSpace(PRUint32 *aBorderVertSpace) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetBorderVertSpace(aBorderVertSpace); } \
NS_IMETHOD GetBorderHorizSpace(PRUint32 *aBorderHorizSpace) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetBorderHorizSpace(aBorderHorizSpace); } \
NS_IMETHOD GetUniqueID(PRUint32 *aUniqueID) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetUniqueID(aUniqueID); } \
NS_IMETHOD GetDOMElement(nsIDOMElement * *aDOMElement) { return !_to ? NS_ERROR_NULL_POINTER : _to->GetDOMElement(aDOMElement); }
#if 0
/* Use the code below as a template for the implementation class for this interface. */
/* Header file */
class nsPluginTagInfo2 : public nsIPluginTagInfo2
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIPLUGINTAGINFO2
nsPluginTagInfo2();
private:
~nsPluginTagInfo2();
protected:
/* additional members */
};
/* Implementation file */
NS_IMPL_ISUPPORTS1(nsPluginTagInfo2, nsIPluginTagInfo2)
nsPluginTagInfo2::nsPluginTagInfo2()
{
/* member initializers and constructor code */
}
nsPluginTagInfo2::~nsPluginTagInfo2()
{
/* destructor code */
}
/* readonly attribute nsPluginTagType tagType; */
NS_IMETHODIMP nsPluginTagInfo2::GetTagType(nsPluginTagType *aTagType)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void getTagText (out constCharPtr aTagText); */
NS_IMETHODIMP nsPluginTagInfo2::GetTagText(const char * *aTagText NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void getParameters (in PRUint16Ref aCount, in constCharStarConstStar aNames, in constCharStarConstStar aValues); */
NS_IMETHODIMP nsPluginTagInfo2::GetParameters(PRUint16 & aCount, const char* const* & aNames, const char* const* & aValues)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void getParameter (in string aName, out constCharPtr aResult); */
NS_IMETHODIMP nsPluginTagInfo2::GetParameter(const char *aName, const char * *aResult NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void getDocumentBase (out constCharPtr aDocumentBase); */
NS_IMETHODIMP nsPluginTagInfo2::GetDocumentBase(const char * *aDocumentBase NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void getDocumentEncoding (out constCharPtr aDocumentEncoding); */
NS_IMETHODIMP nsPluginTagInfo2::GetDocumentEncoding(const char * *aDocumentEncoding NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void getAlignment (out constCharPtr aElignment); */
NS_IMETHODIMP nsPluginTagInfo2::GetAlignment(const char * *aElignment NS_OUTPARAM)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* readonly attribute unsigned long width; */
NS_IMETHODIMP nsPluginTagInfo2::GetWidth(PRUint32 *aWidth)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* readonly attribute unsigned long height; */
NS_IMETHODIMP nsPluginTagInfo2::GetHeight(PRUint32 *aHeight)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* readonly attribute unsigned long borderVertSpace; */
NS_IMETHODIMP nsPluginTagInfo2::GetBorderVertSpace(PRUint32 *aBorderVertSpace)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* readonly attribute unsigned long borderHorizSpace; */
NS_IMETHODIMP nsPluginTagInfo2::GetBorderHorizSpace(PRUint32 *aBorderHorizSpace)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* readonly attribute unsigned long uniqueID; */
NS_IMETHODIMP nsPluginTagInfo2::GetUniqueID(PRUint32 *aUniqueID)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* readonly attribute nsIDOMElement DOMElement; */
NS_IMETHODIMP nsPluginTagInfo2::GetDOMElement(nsIDOMElement * *aDOMElement)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* End of implementation class template. */
#endif
#endif /* __gen_nsIPluginTagInfo2_h__ */
| [
"fdiskyou@users.noreply.github.com"
] | fdiskyou@users.noreply.github.com |
70104ea75c25d27279d248ac3476c9b188656f10 | 8a7afe26f7733bcecf1bce34a081dd3d1b96787a | /libvpvl2/include/vpvl2/vmd/BaseKeyframe.h | a5bf56090985cf9fb80bd89d896fd2c3664acfb8 | [
"BSD-3-Clause"
] | permissive | sun16/MMDAI | 707cb91cb293ef4b07f90e5e8e2ac5d249a39600 | e7f811cdfd361794790e15dd57756c9a758c2a91 | refs/heads/master | 2021-01-15T19:39:13.982345 | 2012-12-04T05:11:23 | 2012-12-04T05:11:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,631 | h | /* ----------------------------------------------------------------- */
/* */
/* Copyright (c) 2009-2011 Nagoya Institute of Technology */
/* Department of Computer Science */
/* 2010-2012 hkrn */
/* */
/* All rights reserved. */
/* */
/* Redistribution and use in source and binary forms, with or */
/* without modification, are permitted provided that the following */
/* conditions are met: */
/* */
/* - Redistributions of source code must retain the above copyright */
/* notice, this list of conditions and the following disclaimer. */
/* - Redistributions in binary form must reproduce the above */
/* copyright notice, this list of conditions and the following */
/* disclaimer in the documentation and/or other materials provided */
/* with the distribution. */
/* - Neither the name of the MMDAI project team nor the names of */
/* its contributors may be used to endorse or promote products */
/* derived from this software without specific prior written */
/* permission. */
/* */
/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND */
/* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, */
/* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF */
/* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE */
/* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS */
/* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, */
/* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */
/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */
/* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON */
/* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, */
/* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY */
/* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE */
/* POSSIBILITY OF SUCH DAMAGE. */
/* ----------------------------------------------------------------- */
#ifndef VPVL2_VMD_BASEKEYFRAME_H_
#define VPVL2_VMD_BASEKEYFRAME_H_
#include "vpvl2/Common.h"
#include "vpvl2/IKeyframe.h"
namespace vpvl2
{
namespace vmd
{
class VPVL2_API BaseKeyframe : public virtual IKeyframe
{
public:
BaseKeyframe()
: m_namePtr(0),
m_timeIndex(0),
m_layerIndex(0)
{
}
virtual ~BaseKeyframe() {
delete m_namePtr;
m_namePtr = 0;
m_timeIndex = 0;
m_layerIndex = 0;
}
const IString *name() const { return m_namePtr; }
const TimeIndex &timeIndex() const { return m_timeIndex; }
const LayerIndex &layerIndex() const { return m_layerIndex; }
void setTimeIndex(const IKeyframe::TimeIndex &value) { m_timeIndex = value; }
void setLayerIndex(const LayerIndex &value) { m_layerIndex = value; }
protected:
IString *m_namePtr;
TimeIndex m_timeIndex;
LayerIndex m_layerIndex;
VPVL2_DISABLE_COPY_AND_ASSIGN(BaseKeyframe)
};
}
}
#endif
| [
"hikarin.jp@gmail.com"
] | hikarin.jp@gmail.com |
06022437264ba9d9d99377928e8a64e8ef76a7ee | 6b40e9cba1dd06cd31a289adff90e9ea622387ac | /Develop/Server/GameServer/main/GGlueQuest.cpp | ca85966a48070385fe5ec4c05086426428d77a76 | [] | no_license | AmesianX/SHZPublicDev | c70a84f9170438256bc9b2a4d397d22c9c0e1fb9 | 0f53e3b94a34cef1bc32a06c80730b0d8afaef7d | refs/heads/master | 2022-02-09T07:34:44.339038 | 2014-06-09T09:20:04 | 2014-06-09T09:20:04 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,090 | cpp | #include "stdafx.h"
#include "GGlueQuest.h"
#include "GPlayerQuest.h"
#include "GQuestInfo.h"
#include "GScriptMacro.h"
#include "GQuestSystem.h"
#include "GGlobal.h"
#include "MLocale.h"
#include "GQuestVarUpdater.h"
GGlueQuest::GGlueQuest(GPlayerQuest* pOwner)
{
m_pOwner = pOwner;
}
GGlueQuest::~GGlueQuest()
{
// do nothing
}
GPlayerQuest* GGlueQuest::GetOwnerQuest() const
{
return m_pOwner;
}
bool GGlueQuest::IsInvalidOwner() const
{
return m_pOwner == NULL;
}
const string GGlueQuest::GetLuaTableName()
{
GQuestInfo* pQuest = GetOwnerQuest()->GetInfo();
return MAKE_LUATABLE_QUEST(pQuest ? pQuest->nID : 0);
}
bool GGlueQuest::IsNull(void) const
{
if (IsInvalidOwner()) return true;
return false;
}
void GGlueQuest::UpdateQuestVar(int nVar)
{
if (IsInvalidOwner()) return;
gsys.pQuestSystem->GetQuestVarUpdater().Update(GetOwnerQuest()->GetOwner(), GetOwnerQuest()->GetInfo()->nID, nVar);
}
int GGlueQuest::GetQuestVar(void)
{
if (IsInvalidOwner()) return 0;
return GetOwnerQuest()->GetQuestVar();
}
| [
"shzdev@8fd9ef21-cdc5-48af-8625-ea2f38c673c4"
] | shzdev@8fd9ef21-cdc5-48af-8625-ea2f38c673c4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.